(* functional solution without array mutation, could be made faster by using
* array mutation
*
* on AMD64,
* 3.1 secs for OCaml 3.11.1
* (-nodynlink -inline 100, with OCAMLRUNPARAM=h=70M to set the heap size)
* 8.3 secs for silly.java (java -Xms512m -server)
* Java HotSpot(TM) 64-Bit Server VM (build 10.0-b19, mixed mode)
* *)
open Printf
type point = { x : float; y : float; z : float }
let makePoint n =
let fn = float_of_int n in
let x = sin fn in
let y = 3.0 *. cos fn in
let z = let s = sin fn in s *. s /. 2.0 in
{x = x; y = y; z = z}
let toString p = sprintf "%f, %f, %f" p.x p.y p.z
let makePoints n = Array.init n makePoint
let pointNorm p = p.x *. p.x +. p.y *. p.y +. p.z *. p.z
let normalizePoint p =
let norm = pointNorm p in
{ x = p.x /. norm; y = p.y /. norm; z = p.z /. norm }
let normalizePoints arr = Array.map normalizePoint arr
let max (x : float) y = if x < y then y else x
let maxPoint p1 p2 = { x = max p1.x p2.x; y = max p1.y p2.y; z = max p1.z p2.z }
let maxPoints arr = Array.fold_left (fun max c -> maxPoint max c) arr.(0) arr
let benchmark n =
print_endline (toString (maxPoints (normalizePoints (makePoints n))))
let runBenchmark () =
Gc.compact ();
for n = 1 to 8 do
printf "Run #%d\n%!" n;
let t1 = Sys.time () in
benchmark 5000000;
let t2 = Sys.time () in
printf "Time: %f\n%!" (t2 -. t1)
done
let () = runBenchmark ()