feat: solvers and ball example

exm/ball.ml

@@ -0,0 +1,54 @@
+
+open Hsim.Types
+open Solvers
+
+(* let hybrid bouncing () = (x, y) where
+     rec der y  = y' init y0
+     and der y' = -g init y'0
+     and der x  = x' init x0
+     and der x' = .0 init x'0 *)
+
+let of_array = Bigarray.Array1.of_array Bigarray.Float64 Bigarray.c_layout
+
+type state =
+  { zin : Zls.zarray;
+    l_x : Zls.carray; (* [h';h;x';x] *)
+    i   : bool }
+
+let g   = -9.81
+let y0  = 50.0
+let y'0 = 0.0
+let x0  = 0.0
+let x'0 = 1.0
+
+let bouncing_ball () =
+  let zfalse = Zls.zmake 1 in
+  let fder _ (y: Zls.carray) (yd: Zls.carray) =
+    if true (* y.{1} >= 0.0 *) then
+      begin yd.{0} <- g; yd.{1} <- y.{0}; yd.{2} <- 0.0; yd.{3} <- y.{2} end
+    else
+      begin yd.{0} <- 0.0; yd.{1} <- 0.0; yd.{2} <- 0.0; yd.{3} <- 0.0 end in
+  let fzer _ (y: Zls.carray) (zout: Zls.carray) = zout.{0} <- -. y.{1} in
+  let fout _ (y: Zls.carray): Zls.carray = of_array [| y.{1} |] in
+  let step ({ zin; l_x; _ } as s) _ : Zls.carray * state =
+    let l_x = if zin.{0} = 1l then
+      of_array [| -. 0.8 *. l_x.{0}; 0.0; l_x.{2}; l_x.{3} |] else l_x in
+    of_array [| s.l_x.{1} |], { zin = zfalse; l_x; i = false } in
+  let cget s = s.l_x in
+  let cset s l_x = { s with l_x } in
+  let zset s zin = { s with zin } in
+  let yd    = Zls.cmake 4 in
+  let zout  = Zls.cmake 1 in
+  let state = { zin = zfalse; l_x = of_array [|y'0;y0;x'0;x0|]; i = true } in
+  let reset _ _ = state in
+  let jump _ = true in
+  let zsize = 1 in
+  HNode
+  { state = state;
+    fder = (fun _ _ y -> fder 0.0 y yd; yd);
+    fzer = (fun _ _ y -> fzer 0.0 y zout; zout);
+    fout = (fun s _ y -> fout s y);
+    step;
+    horizon = (fun _ -> max_float);
+    cset; cget; zset; reset; jump; zsize }
+