вторник, 28 декабря 2010 г.

Композиция функций и странные баги

Начал потихоньку вникать в теорию комбинаторов и решил попробовать их реализовать на F#.

Но наткнулся на один странный баг, который не смог воспроизвести дома. А именно, есть комбинатор функций a, b:

let (|>>) a b =
    fun x -> a x |> b

Так вот, используя интерпритатор F# из плагина к VS2008 я не мог построить комбинацию скажем таких функций:

let f1 x = x + 1
let f2 x = x.ToString()
 
Интерпритатор ругался и просил явно прописать типы.
хотя для
let f1 x = x + 1
let f2 x = x * x
 
или
 
let f2 x = (float) x + 1.0
 
комбинатор работал.
 
А вот дома, в VS2010 всё заработало в точности так, как и ожидалось.


Следующий код:

let (|>>) a b =
    fun x -> a x |> b
 
let f1 x = x + 1
let f2 x = (float) x + 1.0
let f3 x = [x]
 
let f' = f1 |>> f2 |>> f3
 
f' 10
 
выдал:
val ( |>> ) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
val f1 : int -> int
val f2 : int -> float
val f3 : 'a -> 'a list
val f' : (int -> float list)

> f' 10;;
val it : float list = [12.0] 
т.е. возможно есть какие-то проблемы с комбинаторами в старых версиях F#.
Но точно посмотреть версию F# на работе смогу только после НГ...
Всех с наступающим!)) 

четверг, 16 декабря 2010 г.

F# Snippets

Бродя по интернету в поисках инфы про quotations наткнулся у Томаса Петричека на следующую ссылку: http://fssnip.net/

более чем полезный ресурс, особенно если он будет и дальше развиваться.

вторник, 30 ноября 2010 г.

Скорость вычислений на F#

Недавно задумался над скоростью вычислений в F#, а вернее о том, стоит ли заморачиваться использую lazy() и seq. Поверхностные тесты seq показывают, что seq лучше для вычислений чем list:



> Seq.sum (seq{ for i in 1.0 .. 50.0 -> 1.0/(i*i*i) });;
Real: 00:00:00.001, CPU: 00:00:00.000, GC gen0: 0, gen1: 0, gen2: 0
val it : float = 1.201860863
> List.sum [ for i in 1.0 .. 50.0 -> 1.0/(i*i*i) ];;
Real: 00:00:00.002, CPU: 00:00:00.000, GC gen0: 0, gen1: 0, gen2: 0
val it : float = 1.201860863
> ;;
> ;;
> ;;
> Seq.sum (seq{ for i in 1.0 .. 50000.0 -> 1.0/(i*i*i) });;
Real: 00:00:00.008, CPU: 00:00:00.015, GC gen0: 0, gen1: 0, gen2: 0
val it : float = 1.202056903
> List.sum [ for i in 1.0 .. 50000.0 -> 1.0/(i*i*i) ];;
Real: 00:00:00.013, CPU: 00:00:00.015, GC gen0: 1, gen1: 0, gen2: 0
val it : float = 1.202056903
> List.sum [ for i in 1.0 .. 5000000.0 -> 1.0/(i*i*i) ];;
Real: 00:00:02.589, CPU: 00:00:02.870, GC gen0: 38, gen1: 26, gen2: 3
val it : float = 1.202056903
> Seq.sum (seq{ for i in 1.0 .. 5000000.0 -> 1.0/(i*i*i) });;
Real: 00:00:00.800, CPU: 00:00:00.795, GC gen0: 0, gen1: 0, gen2: 0
val it : float = 1.202056903

Причём чем больше эл-тов требуется вычислить, тем менее производительней становиться список, т.к. ему требуется подчищать за собой память оч. активно.


п.с. если использовать честный fold, то seq несколько замедляется, но всёравно в 2 раза быстрее списка:

> Seq.fold (fun acc e -> acc + e) 0.0 (seq{ for i in 1.0 .. 5000000.0 -> 1.0/(i*i*i) });;
Real: 00:00:01.125, CPU: 00:00:01.092, GC gen0: 0, gen1: 0, gen2: 0
val it : float = 1.202056903
> List.fold (fun acc e -> acc + e) 0.0 ([ for i in 1.0 .. 5000000.0 -> 1.0/(i*i*i) ]);;
Real: 00:00:02.716, CPU: 00:00:02.776, GC gen0: 35, gen1: 28, gen2: 1
val it : float = 1.202056903

правда стоит заметить, что для seq использование fold увеличило требуемое время на 0.3 сек, в то время когда для списка всего на 0.127 сек

пятница, 19 ноября 2010 г.

Ну разве этот код не красив?...

/// L1 ⊕k L2 = {w | (w = xy, x ∈ L1, y ∈ L2, |xy| 6 k) ∨ (w = γ, xy = γβ, x ∈ L1, y ∈ L2, |γ| = k)}.
let plus k (L1 : List) (L2 : List) =
    List.fold (fun (acc : list) (x : string) ->
        (List.map (fun (y : string) -> 
                if (x.Length + y.Length) < k 
                    then x + y
                    else (x + y).Substring(0, k)
                ) L2 
            ) @ acc
        ) [] L1

хотя мне не нравится то, как пришлось использовать fold и @. это снижает его скорость к сожалению

вторник, 16 ноября 2010 г.

Понравился этот дем...

иногда я действительно так делаю=)

четверг, 11 ноября 2010 г.

воскресенье, 7 ноября 2010 г.

Хочу стать бездушной тварью, кто-нибудь знает способ?
Всем похер.

Делай что должен - Улыбнись и иди дальше.

среда, 27 октября 2010 г.

Upd. Паттерн матчинг

В догонку к предыдущему сообщению.


let find = function
    | "by" :: "name" :: _ :: []  -> 3
    | "by" :: "autor" :: _ :: [] -> 4
    | "by" :: "autors" :: _ :: [] -> 5
    | _ -> 0
и 
let find = function
    | "by" :: "name" :: t when t <> [] -> 3
    | "by" :: "autor" :: t when t <> [] -> 4
    | "by" :: "autors" :: t when t <> [] -> 5
    | _ -> 0
Так вот, 2й вариант значительно хуже! Он развернётся аж в две функции, каждая из которых будет сложнее того, во что развернётся 1й варинт(листинги приводить не буду - всё это можно увидеть в рефлекторе).

Паттерн матчинг и выделение памяти

Есть небольшой и довольно простой код:


let replace = function
    | "by" :: "id" :: t :: [] -> 8
    | _ -> 0
t :: [] - используется для того, чтобы гарантировать наличие одного свободного эл-та в списке.

И вроде бы всё хорошо, но если посмотреть в рефлекторе, то можно увидеть такую картину:

public static int replace(FSharpList<string> _arg1)
{
    if (_arg1.get_TailOrNull() != null)
    {
        FSharpList<string> list = _arg1;
        if (string.Equals(list.get_HeadOrDefault(), "by"
&& (list.get_TailOrNull().get_TailOrNull() != null))
        {
            FSharpList<string> list2 = list.get_TailOrNull();
            if (string.Equals(list2.get_HeadOrDefault(), "id"
&& (list2.get_TailOrNull().get_TailOrNull() != null))
            {
                FSharpList<string> list3 = list2.get_TailOrNull();
                if (list3.get_TailOrNull().get_TailOrNull() == null)
                {
                    string t = list3.get_HeadOrDefault();
                    return 8;
                }
            }
        }
    }
    return 0;
}
Выделенная строка намекает на то, что выделяется память под ту же ссылку(а это лишняя работа).

Но, если использовать _ вместо t, то всё становится несколько радужней:

public static int replace(FSharpList<string> _arg1)
{
    if (_arg1.get_TailOrNull() != null)
    {
        FSharpList<string> list = _arg1;
        if (string.Equals(list.get_HeadOrDefault(), "by"
&& (list.get_TailOrNull().get_TailOrNull() != null))
        {
            FSharpList<string> list2 = list.get_TailOrNull();
            if ((string.Equals(list2.get_HeadOrDefault(), "id"
&& (list2.get_TailOrNull().get_TailOrNull() != null)) 
&& (list2.get_TailOrNull().get_TailOrNull().get_TailOrNull() == null))
            {
                return 8;
            }
        }
    }
    return 0;
}

Как можно заметить код становится значительно проще(пропадает один вложенный иф + не выделяется память под t + не вычисляется list3).

Отсюда нехитрый вывод - следует, по возможности, использовать запись вида h :: _ :: t вместо h :: elem :: t.

вторник, 26 октября 2010 г.

mutable привязки, интерпретатор и массивы

Есть такой код:

let mutable x =
    [|
     1; 2; 3; 4; 5;
     2; 3; 5; 6; 3;
     |]
 
let to_null =
    for i in 0..9 do
        x.[i] <- 0
загоняем его в интерпретатор и получаем соотв.:

val mutable x : int [] = [|0; 0; 0; 0; 0; 0; 0; 0; 0; 0|]
val to_null : unit = ()


Всё правильно, всё логично.

А теперь снова засунем в интерпретатор x:
val mutable x : int [] = [|1; 2; 3; 4; 5; 2; 3; 5; 6; 3|]

и вызовет to_null:

> to_null;;
val it : unit = ()
> x;;
val it : int [] = [|1; 2; 3; 4; 5; 2; 3; 5; 6; 3|]


Поэтому следует быть осторожным при работе с mutable привязками в интерпретаторе и, по крайней мере, перезагружать их при каждой загрузке кода в fsi.

пятница, 15 октября 2010 г.

Динамические системы в F# - задание, динамика

Решил начинать потихоньку писать код по ДС на F#. Оказалось это очень удобно и невообразимо просто, если знать что такое карринг;)

Итак, ДС состоит из двух элементов:

  1. Множество состояний S;
  2. Функция переходов(эволюции) f : S -> S.
очевидным образом можно примерно получить описание такого объекта на F#:
Set<'a> * ('a -> 'a),

т.е. это кортеж из множества и функции.

Ну с множеством всё понятно - это встроенный тип в F#, а вот с функцией не всё так гладко, т.к. не хочется каждый раз писать новую функцию для каждой ДС вручную.
Но, т.к. я рассматриваю КДС, выясняется, что любую функцию можно задать множеством пар вида (a,b), где a, b принадлежат S, а это можно представить как list<'a * 'a>.
Реализовал я это так:

let rec evo_function table a =
        match table with
            | h :: t ->
                if (fst h) = a then snd h else evo_function t a
            | _ -> failwith("dynamic error: invalid state")

Соответственно использоваться это будет следующим образом:

let ds1 = (Set[0;1], evo_function [(0,1);(1,0)])

т.е. создавая ДС я каррирую evo_function таблицей переходов функции и получаю нужную мне ДС.

Остаётся решить вопрос с созданием удобного способа динамики ДС. Но и эта проблема решается с помощью карринга легко и просто! Смотрите сами:

let evolution ds = Seq.unfold (fun state -> Some(state, state |> snd ds))

Элементарная функция создающая последовательность на основе псевдо-рекурсивных вызовов каррированной evo_function у ds. Плюс ко всему используя последовательность, как результат прогона динамики ДС я получаю выйгрыш в производительности за счёт того, что для последовательностей используются ленивые вычисления в F# :)

Вот полный пример инициализации ДС и получения для неё двух последовательных динамик:

> let ds1 = (Set[0;1], evo_function [(0,1);(1,0)]);;
val ds1 : Set * (int -> int) = (set [0; 1], )
> let evo_ds1 = evolution ds1;;
val evo_ds1 : (int -> seq)
> evo_ds1 1;;
val it : seq = seq [1; 0; 1; 0; ...]
> evo_ds1 0;;
val it : seq = seq [0; 1; 0; 1; ...]

Не правда ли элементарно? ;)

пятница, 8 октября 2010 г.

Удаление бесплодных и недостижимых символов из КС-грамматики


Не далее как сегодня утром я таки дошёл с флешкой и таки сдал эти задачки:)

Привожу тут код этих алгоритмов:

N, E - Set - мн-ва не\терминальных символов
P - Set> - мн-во правил грамматики


// функция построения Ni для DelSterileChar
    let rec del_char (N' : Set) : Set = 
        let Ni : Set = 
            Set.map (fun (a, b) -> 
                        if List.forall (fun e -> N'.Contains(e) || E.Contains(e)) b  
                            then a 
                            else "") P
            |> Set.filter (fun k -> k <> "")
        if Ni = N' then Ni
                   else del_char <| Set.union Ni N'
 
    // функци построения Ni для DelUnattChar
    let rec del_un_char (N' : Set) : Set =
        let Ni = Set.filter (fun (a, b) -> N'.Contains(a)) P
                 |> Set.fold (fun acc (a, b) -> b @ acc) []
                 |> Set.ofList
                 |> Set.union N'
        if Ni = N' then Ni
                   else del_un_char Ni
    
    // алгоритм удаления бесподных символов
    member x.DelSterileChar() : unit =
        N <- del_char <| Set []
        P <- Set.filter (fun (a, b) -> 
                            N.Contains(a) && 
                            List.forall (fun e -> N.Contains(e) || E.Contains(e)) b) P
                                
    // алгоритм удаление недостижимых символов
    member x.DelUnattChar() : unit =
        let Ni = del_un_char <| Set [S]
        N <- Set.intersect N Ni
        E <- Set.intersect E Ni
        P <- Set.filter (fun (a, b) -> Ni.Contains(a) &&
                                       List.forall (fun e -> Ni.Contains(e)) b) P

четверг, 23 сентября 2010 г.

и ещё...


ИТАК Я ДУМАЮ В ВАШЕЙ ДУШЕ....... ТУМАН

В вашей душе клубится туман, укрывая серым пологом вашу душу...
http://aeterna.ru/test.php?link=tests:108172


ВЫ ОЧЕНЬ ПОХОЖИ НА ... ПОСЕЙДОНА


А ДОРОГУ ТЕБЕ ОСВЕЩАЛО… ОСЕННЕЕ УТРЕННЕЕ СОЛНЦЕ

Осеннее утреннее солнце каждый день наполняет мир яркими, выразительными красками. Ты не терпишь бледности, вялости невыразительности. Ты признаешь яркие краски и сильные чувства. С тобою можно поделиться горестями и печалями, ведь ты всегда видишь корень проблемы и находишь решение, кладущие всем тревогам и сомнениям конец. Ты по натуре – взыскательный, добивающийся во всем, совершенства человек, для которого важно решить проблему до конца, чтобы перевернуть новую страницу жизни
http://aeterna.ru/test.php?link=tests:106205

новая порция результато тестов с Аэтерны...


СКОРО ВЫ ВЕРНЕТЕСЬ В РЕАЛЬНОСТЬ, НО ПЕРЕД ЭТИМ Я СКАЖУ ВАМ, ЧТО ВАШ ИДЕАЛЬНЫЙ ПОЦЕЛУЙ - ПОЦЕЛУЙ С ЛЮБИМЫМ ЧЕЛОВЕКОМ.

Неважно где, неважно когда, Вам важно одно - с кем. Вы хотите целовать того, кого по-настоящему любите. Этот поцелуй - отражение Ваших чувств, Вы вкладываете в него всё свою нежность и растворяетесь в ощущении счастья.
http://aeterna.ru/test.php?link=tests:71971



ВАША ДЕВУШКА С ТЕМНОЙ СТОРОНЫ: ВЕДЬМА

Она владеет тайными знаниями, умеет многое, и кажется нет того, чего она не может. Но нет, есть: она не может забыть Вас.

ПОЗДРАВЛЯЮ!!!! ВЫ - СКОРЕЕ РЕАЛИСТ!

Вы умеете смотреть на вещи реально. Если вдруг загорится автобус, в котором вы едете, вы не растеряетесь, не впадете как все в панику, а начнете действовать осознанно. Вы спасете всех из этого горящего автобуса. У вас много друзей, они любят вас за прямолинейность, искренность. Вы способны любить и ваша половинка будет счастлива с вами. Вы добрый и поможете в трудную минуту. Вы- золотая середина!
http://aeterna.ru/test.php?link=tests:58479


МНЕ КАЖЕТСЯ, ВЫ НЕОБЫЧНЫЙ ЧЕЛОВЕК...

Сегодня – улыбающийся оптимист, завтра – пессимист в глубокой депрессии, неординарны и творчески, избегаете стереотипов, Вам нравится все новое и необычное; вполне возможно, интересуетесь мистикой и другими явлениями, которые у других людей пока что не получается объяснить.
http://aeterna.ru/test.php?link=tests:110316


четверг, 9 сентября 2010 г.

к сожалению...

мде... кажется "Печальный рыцарь", как меня как то назвали, возвращается...

ну что ж, пережил один раз, переживу и второй.

да поможет мне зелёный чай.

среда, 8 сентября 2010 г.

воскресенье, 5 сентября 2010 г.

четверг, 2 сентября 2010 г.

Mercurial и мои исходники

Итак, читая книгу "Программист-прагматик" я натолкнулся на совет смысл которого в следующем: "Всё, что вы пишите, засовывайте в систему контроля версий".
Я и раньше пользовался VCS(юзал git), но это было как то не системно + под Windows в VS это ещё и неудобно(ну неудобно мне каждый раз VS Command Promt вызывать и вбивать команды), поэтому я недавно стал использовать вместо Git Mercurial.
Основным доводам стало то, что для него существует GUI в виде TortoiseHg + плагин для VS VisualHG.

Всё это стояло, работало потихоньку, но сегодня я решил несколько более систематизировать и формализовать упр. своими сорцами.

Поэтому сделал в итоге следующее:

1) В корне диска W создал папку CODEBASE, в которой создал пустой репозиторий.
*весь код у меня находится на отдельном лог. диске
2) В важных для меня солюшенах создал репозитории и протолкнул их в репозиторий CODEBASE
*веткам в репозиториях солюшенов следует давать уникальные имена, иначе их не протолкнуть в общий реп.
3) Протолкнул CODEBASE на свой реп. в codeplex.

имхо, получилось довольно неплохо))

p.s. ну и в конце ссылочка на серию статей про Mercurial.


p.s.s. хотя наверно стоить сделать в итоге 2 репозитория общих... один - для расшаривания кода в нете, а 2й - локальное хранилище всего и вся.

воскресенье, 29 августа 2010 г.

"Кости" в консоли на F#

небольшая "игрушка" написанная на F# с применением ООП...
написанная правда фигово с точки зрения того же ООП:)

смысл - посмотреть, как юзаются классы с F#)

module BoneGame

open System
open System.Collections.Generic

#light

type UserInterface () =
    member x.Roll : bool =
        printfn "Вы будете бросать кубик?"
        x.QuestYN

    member x.PrintState (data : list) : unit = 
        for e in data do
            printfn "%s" <| e

    member x.QuestYN : bool =
        printf "Ваше решениие(Y или N): "
        match Console.ReadLine() with
            | "Y" | "y" -> true
            | "N" | "n" -> false
            | _ -> x.QuestYN 

    member x.Win : unit =
        printfn "Поздравляем, Вы выйграли!!!"
        Console.ReadKey () |> ignore

    member x.Louse (name : string) : unit =
        printfn "Вы проиграли! Выйграл %s." name
        Console.ReadKey () |> ignore

    member x.GeneratePlayerList : list =
        printf "Введите имя игрока: "
        let name = Console.ReadLine()
        printfn "Будут ещё игроки?"
        if x.QuestYN then name :: x.GeneratePlayerList
        else [name]

type Player (name   : string,
             score  : int,
             UI     : UserInterface) =
    let name    = name
    let ui      = UI
    let mutable score = score

    member x.Name   with get () = name
    member x.UI     with get () = ui
    member x.Score  with get () = score and set v = score <- v + score

    member x.Roll : bool = ui.Roll

type Game () =
    let intrf = UserInterface ()
    let mutable Players = new Queue ()

    do 
        let p_name = intrf.GeneratePlayerList
        for e in p_name do
            Players.Enqueue ( new Player (e, 0, intrf))

    let max_score = 100

    let bone_roll = (new Random (int(DateTime.Now.Ticks))).Next(1, 6)

    member x.Start : unit =
        let mutable end_flag = true
        while end_flag do
            // выбираем игрока, чья очередь бросать кости
            let current_player = Players.Dequeue ()
            let mutable sum = 0
            let mutable flag = true

            Console.Clear () // !!!!!!!!!!!!!!
            // выводим данные о игровой ситуации
            current_player.UI.PrintState ["Бросает " + current_player.Name;
                                          "Очков у игрока: " + current_player.Score.ToString ();
                                          "--------------------";]
            for e in Players do
                current_player.UI.PrintState ["Противник " + e.Name;
                                              "Очков " + e.Score.ToString ()]
            current_player.UI.PrintState ["--------------------"]

            Console.ReadKey () |> ignore
            Console.Clear ()

            // бросок игрока
            current_player.UI.PrintState ["Будете бросать?"]
            while flag && current_player.Roll do
                let r = (new Random (int(DateTime.Now.Ticks))).Next(1, 6)
                current_player.UI.PrintState ["Вы выбросили " + r.ToString () + " очков"]
                if r <> 1 then 
                    sum <- sum + r
                    current_player.UI.PrintState ["За ход вы набрали " + sum.ToString () + " очков"]
                else 
                    flag <- false
                    sum  <- 0
                    current_player.UI.PrintState ["К сожалению ваши очки, набранные за ход обнуляются"]
                    Console.ReadKey () |> ignore
            current_player.Score <- sum

            // обрабатываем результаты броска
            if current_player.Score < max_score then
                Players.Enqueue (current_player)    // продолжаем игру
            else
                current_player.UI.Win |> ignore
                for e in Players do
                    e.UI.Louse |> ignore
                end_flag <- false

[]
let main _ = 
    printfn "Приветствуем вас в игре Кости!"

    let G = new Game ()
    G.Start
    Console.ReadKey() |> ignore
    0

пятница, 27 августа 2010 г.

Циклы на F#

Сейчас попытался реализовать довольно тривиальный цикл, который на C++ выглядел бы следующим образом:

while(true)
{
    string buf = "";
    cout << "write string(Y/N): ";
    cin >> buf;
    if(buf == "Y") return true;
    if(buf == "N") return false;
}

довольно тривиальная весчь, заставляющая ввести либо Y, либо N.
но вот на F# возникли некоторые проблемы(предположительно из-за того, что ключевое слово return можно не использовать и юзался #light)

т.е. написать в лоб:

while true do
  printf "write string(Y/N): "
  let Sol = Console.ReadLine()
  if Sol = "Y" then true
  if Sol = "N" then false

не получается, т.к. компилятор начинал ругаться на то, что возвращаемое выражение имеет неправильный тип...

в итоге это было решено следующим образом(в ФП стиле кстати, в императивном стиле я решения не нашёл удовлетворительного(два match и лишняя переменная не в счёт)):

type ... =
  ...
  member x.entr = 
        printfn "Enter your solution(Y/N): "
        match Console.ReadLine() with
            | "Y" -> true
            | "N" -> false
            | _ -> x.entr
  ...
  interface ... with
    member x.roll (flag : bool, data : IRollData) = 
            intrf.print data.DataList
            if flag = true then x.entr
            else false

хотя не думаю, что это лучший выход... скорее всего я как-то не так понял работу цикла while-do

четверг, 26 августа 2010 г.

Тест отображение кода

type test = 
    { A : int; B : int}
    member this.copyB dB = { this with B = this.B + dB}

ну вот, теперь я знаю, что для корректного отображения кода программ нужно использовать тег pre:)

значит скоро буду постить примеры кода на F#, раз уж я им занялся)

среда, 18 августа 2010 г.

F#, первое знакомство

F# - это функциональный язык разработанный в M$ под платформу .Net, близкий родственник Haskell.

Первые ощущения от языка - странно.
Оч. похоже на Haskell и Python на первый взгляд. Сразу бросается в глаза использование отступов для различения блоков кода, но это есть гуд кстати(есть и в питоне и в хаскеле).
Потом... функцию main можно определить следующим образом:
let main ( _ ) =
    ...
ну или более стандартно(если аргументы имеют для нас значение):
let main ( args : string[] ) =
    ...

_ - явное использование паттерн матчинга(ура, классная весч), в хаскеле оч. часто ей пользуешься)
= - опять аналогия с хаскель...

это всё хорошо, мне нравится...
но вот много строчные комментарии вида (* много\nтысч\nбукаф *) убивают... хочется стандартных, для C#, /* **/ с автопереносом и автодобавлением звёздочек...

а да, чуть не забыл... вместо привычного main, как точки входа в программу, можно использовать к примеру MaIInbl...
ибо дело в том, что точка входа опр. с помощью добавления перед функцией [%EntryPoint%]*
, которая будет точкой входа.

*вместо [% следует ставить [<, а вместо %] - >]

Обида забывает боль

Я, продолжавший путь, когда за мной вдогонку,
Эскорты чёрных рыб пускались из глубин,
И загонял июль в пылавшую воронку
Ультрамарин небес ударами дубин...


Артюр Рембо
 

среда, 11 августа 2010 г.

Нян-нян:)

CodePlex, Mercurial и переезды...

ммм... с чего бы начать... начала то особо и нету))

Пожалуй следует начать с того, что я доделал первый вариант кода для объединения динамических систем и залил его на гиториус(http://gitorious.org/fds/association_of_dynamical_systems).

Там вроде как бы всё более менее работает... но вот получилось всё достаточно криво по нескольким причинам:

  • Я плохо представлял себе структуру, которую в итоге должен построить, да и вообще с трудом представлял себе, как это всё должно выглядеть с точки зрения программирования.
  • Я плохо знал C# (я и сейчас не особо то его знаю) и его возможности. Сейчас с этим чуточку получше.
В общем говоря начало переписывания этого кода для получения вменяемой библиотеки классов и интерфейсов было делом времени. Ну и я решил начать потихоньку.

А так как я стал периодически получать от гугла ссылки на Open Source проекты выложенные на CodePlex, то было решено использовать в этот раз именно его.
Немаловажным фактором тут играет и то, что для Mercurial(который юзается на CodePlex) существует плагин VisualHG для TortoiseHG интегрирующийся в VS.

Так что теперь мой код по ДС публикуется тут(лицензия LGPL, ибо не жадный я:).

среда, 4 августа 2010 г.

jQuery пример ajax запроса

$.ajax({
type: "GET",
url: hoverText,
cache: true,
success: function(data){
item = $(".posttdMessage:last", data);
$("#textpanel").html(item.html());
$("#textpanel").slideToggle("slow");
}
});
 вот такой вот небольшой код загрузит страничку по адресу хранящемуся в hoverText,
найдёт последний элемент с классом posttdMessage
и засунет html код этого элемента в элемент с id textpanel на нашей странице:)

всё довольно просто))

пятница, 30 июля 2010 г.

четверг, 29 июля 2010 г.

вторник, 20 июля 2010 г.

пятница, 16 июля 2010 г.

Что?

ммм... задумался над важным вопросом: "Что мне больше нравится программировать?"

для начала нужно сказать, что этот вопрос очень важен с точки зрения профессионального роста, т.к. распыляться на кучи направлений не стоит(а именно это я и вижу в себе в последнее время)... haskell, Nemerle, .Net с одной стороны, Lisp, Sheme с другой, а с боку ещё пляшет html с php, xml и ruby...

хочется попробовать всё и в тоже время достичь конкретных результатов...
ну html и co. можно отбросить, ибо это временный бзик...

тогда остаётся решить что же мне нравиться больше... синтаксический сахар haskell и Nemerle или лаконичный `минимализм` Lisp?

пока что не знаю... сердце стремиться к романтике Лиспа, а разум талдычит о силе .Net

суббота, 10 июля 2010 г.

эх...

опять начинает подкрадываться депрессия...

лето, жара... и, как обычно, [%username%] не интересен [%(>---<)%]

устал делать всё ради себя...
устал, что никому не интересны мои увлечения...
устал, что никто не понимает меня...
устал, что никто не поддерживает меня...

мде... сплошное якание получилось... ну да ладно, мой же блог, не ваш, в котором вы не пишете ничего, ага.

опять этот кисловатый привкус бессмысленности в душе... что то идёт не туда и не так, как задумывалось... вот только что и куда... нет ответа пока что.

хотя скорее всего это лето, которое я ненавижу...
ненавижу за то, что становлюсь лишним везде.

п.с. и опять никаких комментариев, всё как обычно - уныло, однообразно и предсказуемо. ненавижу.

среда, 30 июня 2010 г.

новые идеи, новые мысли, новый взгляд на старое...

именно это в меня привнесла концепция функционального программирования.

она заставила меня мыслить шире и замечать более полно. меня удивляет то, что мои учителя в программировании не учили меня этому (за исключением Ольги Владиславовны, но и это было не полно и ограничивалось рекурсией простейшей).
а ведь парадигма ФП намного гибче нашего "алголовского" мышления в программировании...

всё это оч. интересно и похоже в ближайшем будущем балом будут править языки поддерживающие ФП и метапрограммирование... не зря же M$ выпустили F# и поддерживают Nemerle...

воскресенье, 27 июня 2010 г.

время... прошлое... настоящее...

да.... сижу я сейчас перед монитором, по щекам текут редкие слёзы...
сижу на диване, смотрю на галактики, которые меняются у меня на заставках... тоскую о том времени, когда я был маленьким и ещё не испортил себе зрение, и видел звёзды...
они всегда меня завораживали... как же я любил лежать на мокрой от росы траве и смотреть на них...

потом я уехал в город и перестал на них смотреть... а потом у меня испортилось зрение...

и теперь я их не вижу, могу только мечтать о них... так же и ты... теперь я могу только мечтать о тебе, так как по своей глупости не смог сотворить чудо... дурак я, слепой дурак...

если бы можно было вернуться и сделать всё по другому, я бы многое сделал иначе, но одно я знаю точно...
"ты самый дорогой человек для меня" я бы сказал обязательно...

и, наверно, это даже хорошо, что никто это всё равно  не прочитает...

п.с. хотел бф написать ещё много о чём, но... это не имеет смысла... всё равно это никому не нужно теперь... да и всё, что я делаю... я не знаю зачем и ради кого я всё делаю... наверно чтобы заглушить боль ибо больше мне делать нечего...
слишком сильно я напортачил...

понедельник, 21 июня 2010 г.

ммм...

настроение было не на высоте и чтобы немного взбодриться написал небольшой файлик для раскраски .gdl файлов в vim(сочетание цветов отвратительное, так что его нужно бы поменять... да и сам скрипт далеко не совершенен)):


if exists("b:current_syntax")
finish
endif

let b:current_syntax="gdl"

syntax match Keyword /graph:/
syntax match Keyword /node/
syntax match Keyword /edge/
syntax match Keyword /source/
syntax match Keyword /target/
syntax match Keyword /title/
highlight Keyword ctermbg=Blue guifg=Blue

syntax match variable /polar/
syntax match variable /yes/
"syntax match variable /no/
highlight variable ctermbg=Red guifg=Red

syntax region Statement start=/"/ end=/"/
highlight Statement ctermbg=Yellow guifg=Yellow

"syntax region Set start=/{/ end=/}/
"highlight Set ctermbg=Green guifg=Green
а вот скриншот того, что получилось в итоге:
Черный цвет-цвет смерти, печали и боли. Сейчас Вашей душе просто необходимо снять с себя оковы с помощью светлых и приятных цветов: светло-серый - сейчас лучший Вам помощник.
http://aeterna.ru/test.php?link=tests:95483
image
Печальная, часто несчастна. Иногда кажется, что она может приносить только боль и страдания и уж лучше быть одному. Удалить все чувства. Просто забыть их. Начать бороться с ними. Но все-таки понимать, что без них нельзя. Впрочем, серой любовь бывает просто из-за нехватки чувств, эмоций. Нужно не бояться своих чувств и все будет хорошо! imageЧто такое любовь? Это горечь и боль. Что такое любовь? Поединок с собой. Что такое любовь? Это стоны души. Что такое любовь? Это слезы в тиши. Что такое любовь? Это светлое чувство. Что такое любовь? Это то, когда грустно


http://aeterna.ru/test.php?link=tests:96940

понедельник, 14 июня 2010 г.

воскресенье, 6 июня 2010 г.

пятница, 4 июня 2010 г.

Кто вы из мультфильма Спанч Боб?

Вы  Планктон!

Хаааа! Вы - Планктон! Вы со всей отдачей добиваетесь поставленных целей и не остановитесь ни перед чем. Возможно, вы будите править миром!
Мистер Крабс
80 %
Гери
70 %
Спанч Боб
55 %
Сенди
50 %
Патрик
45 %
Скидвард
30 %

Пройти тест
Ajama.ru - прикольные тесты для LiveJornal еще: игры для девочек винкс тесты для девочек

четверг, 3 июня 2010 г.

четверг, 27 мая 2010 г.

ssh-agent в PowerShell

для начала нужно установить MinGW, я это сделал устанавливая Git указав при установке интеграцию Unix команд в консоль виндовс.

далее либо генерируем ключи через ssh-keygen, либо засовываем их в папку $HOME/.ssh

дальнейшая последовательность действий на скриншоте:

воскресенье, 23 мая 2010 г.

курсовая...

выложил наработанный код на gitorious.org чтобы не затерялся, ибо планирую в скором будущем глобальную переделку систем на компе... а это чревато сносами всего и вся... ибо не жалко мне))

ах да, вот оно http://gitorious.org/fds/fds


п.с. репозиторий с этим же кодом благополучно удален с http://git.toiit.sgu.ru

суббота, 22 мая 2010 г.

Qt::QWidget::PaintEvent

от оно что...

ОТРАЖЕНИЕ ТВОЕЙ ДУШИ


ПИСАТЕЛЬ

Ты умный, может даже мудрый, вдумчивый, любознательный. На людях стараешься не показывать сильных эмоций, в душе довольно раним, но никогда не показываешь это окружающим. Со стороны ты выглядишь прочной, многовековой, нерушимой стеной древнего замка. Никогда быстро не меняешь своих позиций, перед принятием важного решения долго взвешиваешь все "за" и "против". Своим друзьям открываешься полностью не всегда. Ты верный; если любишь то неизмеримо и всепоглощающе, но редко это видно со стороны. Иметь такого друга как ты - настоящий подарок.


http://aeterna.ru/test.php?link=tests:92232

п.с. позволил себе сменить род в результате