Objective Caml - Суббота, 26 июня 2010

Objective Caml

ocaml@conference.jabber.ru

Суббота, 26 июня 2010< ^ >

Конфигурация комнаты

Участники комнаты

GMT+4
[00:42:53] gds вышел(а) из комнаты
[01:36:02] ermine вышел(а) из комнаты
[02:23:38] vshender вышел(а) из комнаты
[07:33:53] digital_curse вошёл(а) в комнату
[10:32:16] gds вошёл(а) в комнату
[11:16:23] Kakadu вошёл(а) в комнату
[11:43:41] cf-ins вышел(а) из комнаты
[12:01:45] vshender вошёл(а) в комнату
[12:34:28] ermine вошёл(а) в комнату
[13:17:26] Kakadu вышел(а) из комнаты: Replaced by new connection
[13:17:27] Kakadu вошёл(а) в комнату
[13:17:34] Kakadu вышел(а) из комнаты
[14:41:39] Abyx вошёл(а) в комнату
[14:43:38] <Abyx> как сложить байты в F# чтоб получить int?
let (x:byte, y:byte) = 100uy, 200uy;;
x + y;; // выдает 9, а мне надо 300
int x + int y;; // - слишком длинно =\
[14:49:39] <vshender> Abyx: вряд ли тут кто-то работал с F#, к сожалению.
[14:50:12] <gds> let add_byte x y = int x + int y
и дальше будет весьма коротко.  можно ещё сделать какую-нибудь инфиксную операцию под это дело.
[14:51:07] <Abyx> gds: т.е. всеравно надо писать перед каждым использованием int ?
прост у меня их не 2 а 4 =\
[14:51:21] <Abyx> let bytes2dw (b: byte[]) = b.[0] + (b.[1] <<< 8) + (b.[1] <<< 16) + (b.[3] <<< 24)
[15:16:03] <gds> ну эта функция пишется один раз, не критично.  А типы -- разные, и где-то да надо их преобразовывать.
[15:34:04] <Abyx> как из последовательности брать по 4 элемента, пихать их в функцию, и получать другую последовательность?
[15:49:23] <gds> это уже F#-специфично.  В окамле как -- подсказал бы.
[15:51:58] <Abyx> gds: а как в окамле?
[15:52:41] <komar> wtf последовательность?
[15:53:06] <gds> если последовательность это Stream.t ( http://caml.inria.fr/pub/docs/manual-ocaml/libref/Stream.html ), то известно -- пишется "Stream.from (функция, которая возвращает что надо, получая байты из потока)".
[15:55:41] <Abyx> м.. "последовательность" - это я имел ввиду Seq (или Array или List)
[15:56:25] <gds> это уже F#-специфично.  Есть урл на описание данного Seq?  Может в ближайшее время посмотрел бы, слегка интересно для саморазвития.
[15:57:19] <Abyx> http://msdn.microsoft.com/en-us/library/ee353635.aspx
[15:58:08] <komar> > append : seq<'T> -> seq<'T> -> seq<'T>
[15:58:14] <komar> Это что, такой окамл для плюсплюсников?
[15:58:57] <Abyx> ага, <'T> == <typename T>
[16:01:13] <gds> я не понимаю описания collect -- может быть это и есть оно.
может windowed + map, что точно сработает (но надо смотреть, что будет, когда останется 1..3 элемента, вместо 0).
[16:02:08] <Abyx> windowed оно смещается на 1, а мне нада на N
[16:02:39] <gds> windowed : int -> seq<'T> -> seq<'T []>
а зачем там int тогда?
[16:03:08] <Abyx> размер окна
[16:03:28] <gds> 4?
[16:03:52] <Abyx> Initial sequence:
1.0 1.5 2.0 1.5 1.0 1.5
Windows of length 3:
[|1.0; 1.5; 2.0|] [|1.5; 2.0; 1.5|] [|2.0; 1.5; 1.0|] [|1.5; 1.0; 1.5|]
[16:04:07] <Abyx> т.е. окно длиной 4 смещается на 1 элемент
[16:04:29] <Abyx> а мне нада чтоб окно длиной 4 смещалось на 4
[16:05:01] <Abyx> (в примере выше длина - 3)
[16:05:24] <gds> тьфуты, понял.
[16:08:01] <gds> можно руками, take чтобы брать, далее преобразовывать, далее через init создать новую Seq.  (кстати, если там спёрто с окамла, то тот инт, который дают в функцию-аргумент init'а, не требует от функции как-либо отслеживать соответствие ему, важна лишь последовательность вызовов).
[16:09:38] <Abyx> юзать take? оно же берет с начала, а из середины как?
[16:14:42] <gds> если спёрто с окамла, то достаточно сделать как-то так:
let dwords_of_bytes seq =
  let cur_seq = ref seq in
  Seq.init
    (fun _ -> let four_bytes = Seq.take 4 !cur_seq in (cur_seq := Seq.skip 4 cur_seq; преобразовать four_bytes и вернуть))
[16:16:09] <gds> ах нет, для init так: "The results of calling the function are not saved, that is, the function  is reapplied as necessary to regenerate the elements."
тогда надо смотреть на Seq.nth.
[16:20:07] <Abyx> тогда уж проще сначала в массив
[16:24:20] <gds> зависит от природы данных.  Если они есть все сразу, то императивный цикл будет хорош для этих целей.
Если же ввод-вывод, либо другая потоковая обработка, то в качестве зарядки для ума, можно посмотреть на iteratees, где обрабатывать всё кусками.
[16:24:27] <Abyx> так эта функциональщина какая-то мозговыносящая
        let bytes2dw (b: byte[]) = int b.[0] + (int b.[1] <<< 8) + (int b.[2] <<< 16) + (int b.[3] <<< 24)
        let keyN =
            Seq.initInfinite (fun i -> key.[i % key.Length])
            |> Seq.truncate (P.Length * 4)
            |> Seq.toArray
        let P =
            Array.init P.Length (fun i -> Array.rev keyN.[i*4..i*4+3] |> bytes2dw)
            |> Array.map2 (fun x y -> x ^^^ y) P
[16:25:48] <Abyx> наверное я что-то делаю не так %) код слишком страшен =\
[16:28:06] <Abyx> да, если заменить последний блок на императивщину, то будет лучше
        for i in 0..P.Length-1 do
            P.[i] <- P.[i] ^^^ (Array.rev keyN.[i*4..i*4+3] |> bytes2dw)
[17:02:09] <gds> тут проще всё сделать императивно, если есть массив на входе и нужен массив на выходе.
[17:04:27] <Abyx> ооо! я придумал как это переписать функционально
        let bytes2dw (b: byte[]) = int b.[0] + (int b.[1] <<< 8) + (int b.[2] <<< 16) + (int b.[3] <<< 24)
        for i in 0..P.Length-1 do
            P.[i] <- P.[i] ^^^ (
                Seq.initInfinite (fun i -> key.[i % key.Length])
                |> Seq.truncate (P.Length * 4)
                |> Seq.toArray
                |> (fun v -> Array.sub v (i*4) 4)
                |> Array.rev
                |> bytes2dw)
[17:04:44] <Abyx> правда у меня сомнения в оптимальности этой штуки
[17:08:40] <Abyx> там вся фича в том, что key: byte[] надо зациклить и сгруппировать в перевернутые (big endian) int32
[17:20:14] <Abyx> м.. на самом деле, императивщины там не надо, т.к. в начале я делаю
let P = Array.copy PArray
а потом сразу идет
for i in 0..P.Length-1 do P.[i] <- P.[i] ^^^ ...
что не есть хорошо
[17:26:50] <Abyx> так что
    let P = PArray |> Array.mapi (fun i p -> p ^^^ (
            Seq.initInfinite (fun i -> key.[i % key.Length])
            |> Seq.truncate (PArray.Length * 4)
            |> Seq.toArray
            |> (fun v -> Array.sub v (i*4) 4)
            |> Array.rev
            |> (fun b -> int b.[0] + (int b.[1] <<< 8) + (int b.[2] <<< 16) + (int b.[3] <<< 24))
            )
        )
[18:11:23] cf-ins вошёл(а) в комнату
[20:41:12] fffetish вошёл(а) в комнату
[20:43:00] fffetish вышел(а) из комнаты: Logged out