17:02 <aegray> i'm stupid - I'm trying to write a function using only fold_right, fold_left, map, and possibly reverse that calculates the rolling sum [1; 3; 5]->[0; 1; 4; 9]. I try List.fold_right (fun x y -> (x + (List.fold_right (+) y 0))::y) [1;3;5] [];; but its backwards (which I can fix) and the numbers are [14 8 5] which isn't right (ie 14 = 8+5+1 instead of the result it should be: 5+3+1) - any help on what i'm doing wrong with fold_rig

17:02 <aegray> ht?

17:05 <mellum> aegray: the problem is that you are using fold_right. It's just not appropriate.

17:05 <aegray> What would be more appropriate?

17:05 <mellum> fold_left.

17:06 <aegray> i'm kinda lost on what the difference is other than that it goes the other direction

17:06 <mellum> well, that is about the difference.

17:07 <aegray> so would it be List.fold_left (fun x y -> (y + (List.fold_left (+) 0 x)::x) [] [1;3;5];;?

17:07 <mellum> Why can't you just pass the sum within the outer fold?

17:08 <aegray> how do you mean? (sorry i'm pretty confused with ocaml)

17:08 <pango> List.rev (List.fold_left (fun acc e -> List.hd acc + e :: acc) [0] list)

17:11 <mellum> Or that.

17:11 <aegray> so it would first be called with fun [0] list and at each step have the sum appended?

17:11 <aegray> erm nm i get it

17:11 <aegray> thanks

19:41 <aegray> god this is dumb - how do I take a number to a power? like x^y?

19:42 <smimou> **

19:43 <smimou> # 2. ** 3.;;

19:43 <smimou> - : float = 8.

19:43 <aegray> thanks

19:44 <gim> doesn't exists with 'int's, does it ?

19:45 <smimou> no

19:45 <smimou> but common you know how to program that in one line gim

19:46 <gim> one line and good performance ? tell me :)

19:46 <smimou> :p

19:47 <Snark> s/common/come on/

19:47 <smimou> tssss

19:49 <Snark> I was wondering what was meant...

19:50 <smimou> sorry, I guess we'd better create #ocaml-fr :)

19:50 <gim> took me some time also, but my english not better so i didn't say anything

19:53 <pango> let power a b =

19:53 <pango> let rec power_aux a b c = (* a^b * c *)

19:53 <pango> if b=0 then c

19:53 <pango> else power_aux (a * a) (b / 2) (if b mod 2 = 0 then c else c * a)

19:53 <pango> in power_aux a b 1 ;;

19:54 <smimou> heh

19:55 <gim> does it work with small values of a and b ?

19:55 <gim> if yes, that should work for any value :)

20:04 <pango> b land 1 may be slightly faster if the compiler isn't smart enough with b mod 2

20:08 <pango> that's the egyptian multiplication algorithm, adapted to power computation

20:08 <smimou> I call that modular exponentiation

20:09 <pango> http://faculty.ed.umuc.edu/~swalsh/Math%20Articles/EgyptMultiply.html

20:10 <smimou> http://en.wikipedia.org/wiki/Modular_exponentiation

20:10 <smimou> it's nice

20:11 <smimou> I didn't know that the egyptians already knew that

20:12 <pango> nothing new under the sun :)

20:12 <smimou> lol

20:13 <pango> well, they used it for multiplication, not power

20:13 <pango> at least, as far as I know :)

20:14 <beschmi> smimou: it's not modular exponentation (if you ignore Int overflow)

20:14 <smimou> oh am I wrong ?

20:14 <pango> but the correct answer is one link away from that page : binary exponentiation

20:15 <pango> http://en.wikipedia.org/wiki/Binary_exponentiation

20:15 <smimou> ok

20:15 <smimou> anyway it's quite the same idea

20:16 <beschmi> you can use the same algorithm for modular exponentation

20:17 <smimou> they're the same modulo the modulo :)

22:06 <KrispyKringle> Hey, so if I wish to call some existing C code from OCaml, I have to write a C wrapper function for it first that can be declared in my ocaml, right?

22:10 <KrispyKringle> aha.

22:11 <KrispyKringle> Dynamic linking still doesn't work on OSX?