feat: a LOT of stuff (final report, examples, simulation of a single assert, move from node instances to node definitions, etc.)

exm/zelus/ballcos/ball.zls

@@ -0,0 +1,41 @@
+(* Ball rolling on a cosine curve.                          *)
+(* Illustrates the impact of an observer on the simulation. *)
+
+let g  = 9.81
+let mu = 0.5  (* Friction coefficient. *)
+
+let hybrid ball(v0) = (x, v) where
+  rec der x = v init 0.0
+  and der v = a *. (cos x) init v0
+  and     a = g *. (sin x) -. mu *. v /. (cos x)
+
+let hybrid vdp_c(mu) = (x, y) where
+  rec der x = y init 1.0
+  and der y = (mu *. (1.0 -. (x *. x)) *. y) -. x init 1.0
+
+let hybrid print(p)(t, x, v, x', y) = () where
+  present(period(p)) -> do
+    () = print_endline(String.concat ",\t\t" (List.map string_of_float [t;x;v;x';y]))
+  done
+
+(* Changing the period for [print] changes the result. *)
+let hybrid main () = () where
+  rec der t  = 1.0 init 0.0
+  and (x, v) = ball(2.953)
+  and (x', y) = vdp_c(0.5)
+  and ()     = print(0.5)(t, x, v, x', y)
+
+(*
+let input _ = 2.953
+
+let node print_discrete (now, (x, v)) =
+  print_endline (String.concat ",\t\t" (List.map string_of_float [now;x;v]))
+
+let ball_discrete = Solve.solve_sundials(ball)
+
+let node main_discrete () =
+  let input = Some (Solve.make(30.0, input)) fby None in
+  let o = run ball_discrete input in
+  Solve.period'_t 1.0 print_discrete o
+*)
+

exm/zelus/ballcos/dune

@@ -0,0 +1,17 @@
+(env
+ (dev
+  (flags
+   (:standard -w -a))))
+
+(rule
+ (targets ball.ml ball.zci)
+ (deps
+  (:zl ball.zls)
+  (:zli solve.zli))
+ (action
+  (run zeluc %{zli} %{zl})))
+
+(executable
+ (public_name ballcos.exe)
+ (name main)
+ (libraries std))

exm/zelus/ballcos/main.ml

@@ -0,0 +1,4 @@
+
+open Std
+
+let () = Runtime.go_discrete ignore Ball.main_discrete ignore

exm/zelus/ballcos/solve.zli

@@ -0,0 +1,27 @@
+
+type time = float
+type 'a value
+type 'a signal = 'a value option
+type 'a signal_t = ('a value * time) option
+
+val horizon : 'a value -> time
+val make    : time * (time -> 'a) -> 'a value
+val apply   : 'a value * time -> 'a
+val sustain : 'a -> 'a value
+
+val solve_ode45    : ('a -C-> 'b) -S-> 'a signal -D-> 'b signal_t
+val solve_sundials : ('a -C-> 'b) -S-> 'a signal -D-> 'b signal_t
+
+val synchr :
+  ('a signal -D-> 'b signal_t) -S->
+  ('a signal -D-> 'c signal_t) -S->
+  'a signal -D-> ('b * 'c) signal_t
+
+val iter      : int   -S-> ('a        -D-> unit) -S-> 'a signal_t -D-> unit
+val iter_t    : int   -S-> (time * 'a -D-> unit) -S-> 'a signal_t -D-> unit
+
+val check     : int   -S-> ('a        -D-> bool) -S-> 'a signal_t -D-> unit
+val check_t   : int   -S-> (time * 'a -D-> bool) -S-> 'a signal_t -D-> unit
+
+val period'   : float -S-> ('a        -D-> unit) -S-> 'a signal_t -D-> unit
+val period'_t : float -S-> (time * 'a -D-> unit) -S-> 'a signal_t -D-> unit

exm/zelus/ballcos/tmp/ball.ml

@@ -0,0 +1,172 @@
+(* The Zelus compiler, version 2.2-dev
+  (2025-08-14-22:1) *)
+open Ztypes
+let g = 9.81
+
+let mu = 0.5
+
+type ('d , 'c , 'b , 'a) _ball =
+  { mutable major_68 : 'd ;
+    mutable i_72 : 'c ; mutable x_71 : 'b ; mutable v_70 : 'a }
+
+let ball (cstate_97:Ztypes.cstate) = 
+  
+  let ball_alloc _ =
+    cstate_97.cmax <- (+) cstate_97.cmax  2;
+    { major_68 = false ;
+      i_72 = (false:bool) ;
+      x_71 = { pos = 42.; der = 0. } ; v_70 = { pos = 42.; der = 0. } } in
+  let ball_step self ((time_67:float) , (v0_66:float)) =
+    ((let (cindex_98:int) = cstate_97.cindex in
+      let cpos_100 = ref (cindex_98:int) in
+      cstate_97.cindex <- (+) cstate_97.cindex  2 ;
+      self.major_68 <- cstate_97.major ;
+      (if cstate_97.major then
+       for i_1 = cindex_98 to 1 do Zls.set cstate_97.dvec  i_1  0. done
+       else ((self.x_71.pos <- Zls.get cstate_97.cvec  !cpos_100 ;
+              cpos_100 := (+) !cpos_100  1) ;
+             (self.v_70.pos <- Zls.get cstate_97.cvec  !cpos_100 ;
+              cpos_100 := (+) !cpos_100  1))) ;
+      (let (result_102:(float  * float)) =
+           (if self.i_72 then self.v_70.pos <- v0_66) ;
+           self.i_72 <- false ;
+           (let (a_69:float) =
+                (-.) (( *. ) g  (sin self.x_71.pos)) 
+                     ((/.) (( *. ) mu  self.v_70.pos)  (cos self.x_71.pos)) in
+            self.v_70.der <- ( *. ) a_69  (cos self.x_71.pos) ;
+            self.x_71.der <- self.v_70.pos ; (self.x_71.pos , self.v_70.pos)) in
+       cpos_100 := cindex_98 ;
+       (if cstate_97.major then
+        (((Zls.set cstate_97.cvec  !cpos_100  self.x_71.pos ;
+           cpos_100 := (+) !cpos_100  1) ;
+          (Zls.set cstate_97.cvec  !cpos_100  self.v_70.pos ;
+           cpos_100 := (+) !cpos_100  1)))
+        else (((Zls.set cstate_97.dvec  !cpos_100  self.x_71.der ;
+                cpos_100 := (+) !cpos_100  1) ;
+               (Zls.set cstate_97.dvec  !cpos_100  self.v_70.der ;
+                cpos_100 := (+) !cpos_100  1)))) ; result_102)):float * float) in
+   let ball_reset self  =
+     ((self.i_72 <- true ; self.x_71.pos <- 0.):unit) in
+  Node { alloc = ball_alloc; step = ball_step ; reset = ball_reset }
+type ('c , 'b , 'a) _vdp_c =
+  { mutable major_75 : 'c ; mutable y_77 : 'b ; mutable x_76 : 'a }
+
+let vdp_c (cstate_103:Ztypes.cstate) = 
+  
+  let vdp_c_alloc _ =
+    cstate_103.cmax <- (+) cstate_103.cmax  2;
+    { major_75 = false ;
+      y_77 = { pos = 42.; der = 0. } ; x_76 = { pos = 42.; der = 0. } } in
+  let vdp_c_step self ((time_74:float) , (mu_73:float)) =
+    ((let (cindex_104:int) = cstate_103.cindex in
+      let cpos_106 = ref (cindex_104:int) in
+      cstate_103.cindex <- (+) cstate_103.cindex  2 ;
+      self.major_75 <- cstate_103.major ;
+      (if cstate_103.major then
+       for i_1 = cindex_104 to 1 do Zls.set cstate_103.dvec  i_1  0. done
+       else ((self.y_77.pos <- Zls.get cstate_103.cvec  !cpos_106 ;
+              cpos_106 := (+) !cpos_106  1) ;
+             (self.x_76.pos <- Zls.get cstate_103.cvec  !cpos_106 ;
+              cpos_106 := (+) !cpos_106  1))) ;
+      (let (result_108:(float  * float)) =
+           self.y_77.der <- (-.) (( *. ) (( *. ) mu_73 
+                                                 ((-.) 1. 
+                                                       (( *. ) self.x_76.pos 
+                                                               self.x_76.pos)))
+                                          self.y_77.pos)  self.x_76.pos ;
+           self.x_76.der <- self.y_77.pos ; (self.x_76.pos , self.y_77.pos) in
+       cpos_106 := cindex_104 ;
+       (if cstate_103.major then
+        (((Zls.set cstate_103.cvec  !cpos_106  self.y_77.pos ;
+           cpos_106 := (+) !cpos_106  1) ;
+          (Zls.set cstate_103.cvec  !cpos_106  self.x_76.pos ;
+           cpos_106 := (+) !cpos_106  1)))
+        else (((Zls.set cstate_103.dvec  !cpos_106  self.y_77.der ;
+                cpos_106 := (+) !cpos_106  1) ;
+               (Zls.set cstate_103.dvec  !cpos_106  self.x_76.der ;
+                cpos_106 := (+) !cpos_106  1)))) ; result_108)):float * float) in
+  
+  let vdp_c_reset self  =
+    ((self.y_77.pos <- 1. ; self.x_76.pos <- 1.):unit) in
+  Node { alloc = vdp_c_alloc; step = vdp_c_step ; reset = vdp_c_reset }
+type ('g , 'f , 'e , 'd , 'c , 'b , 'a) _main =
+  { mutable i_96 : 'g ;
+    mutable i_95 : 'f ;
+    mutable major_79 : 'e ;
+    mutable h_94 : 'd ;
+    mutable i_92 : 'c ; mutable h_90 : 'b ; mutable t_80 : 'a }
+
+let main (cstate_109:Ztypes.cstate) = 
+  let Node { alloc = i_96_alloc; step = i_96_step ; reset = i_96_reset } = ball 
+  cstate_109 in 
+  let Node { alloc = i_95_alloc; step = i_95_step ; reset = i_95_reset } = vdp_c 
+  cstate_109 in
+  let main_alloc _ =
+    cstate_109.cmax <- (+) cstate_109.cmax  1;
+    { major_79 = false ;
+      h_94 = 42. ;
+      i_92 = (false:bool) ;
+      h_90 = (42.:float) ; t_80 = { pos = 42.; der = 0. };
+      i_96 = i_96_alloc () (* continuous *)  ;
+      i_95 = i_95_alloc () (* continuous *)  } in
+  let main_step self ((time_78:float) , ()) =
+    ((let (cindex_110:int) = cstate_109.cindex in
+      let cpos_112 = ref (cindex_110:int) in
+      cstate_109.cindex <- (+) cstate_109.cindex  1 ;
+      self.major_79 <- cstate_109.major ;
+      (if cstate_109.major then
+       for i_1 = cindex_110 to 0 do Zls.set cstate_109.dvec  i_1  0. done
+       else ((self.t_80.pos <- Zls.get cstate_109.cvec  !cpos_112 ;
+              cpos_112 := (+) !cpos_112  1))) ;
+      (let (result_114:unit) =
+           let h_93 = ref (infinity:float) in
+           (if self.i_92 then self.h_90 <- (+.) time_78  0.) ;
+           (let (z_91:bool) = (&&) self.major_79  ((>=) time_78  self.h_90) in
+            self.h_90 <- (if z_91 then (+.) self.h_90  0.01 else self.h_90) ;
+            h_93 := min !h_93  self.h_90 ;
+            self.h_94 <- !h_93 ;
+            self.i_92 <- false ;
+            (let ((x_82:float) , (v_81:float)) =
+                 i_96_step self.i_96 (time_78 , 2.953) in
+             let ((x'_83:float) , (y_84:float)) =
+                 i_95_step self.i_95 (time_78 , 0.0000000000000001) in
+             (begin match z_91 with
+                    | true ->
+                        let () =
+                            print_endline (String.concat ",\t\t" 
+                                                         (List.map string_of_float
+                                                                   
+                                                                   ((::) 
+                                                                    (
+                                                                    self.t_80.pos
+                                                                    ,
+                                                                    (
+                                                                    (::) 
+                                                                    (
+                                                                    x_82 ,
+                                                                    (
+                                                                    (::) 
+                                                                    (
+                                                                    v_81 ,
+                                                                    (
+                                                                    (::) 
+                                                                    (
+                                                                    x'_83 ,
+                                                                    (
+                                                                    (::) 
+                                                                    (
+                                                                    y_84 ,
+                                                                    ([]))))))))))))) in
+                        () | _ -> ()  end) ; self.t_80.der <- 1. ; ())) in
+       cstate_109.horizon <- min cstate_109.horizon  self.h_94 ;
+       cpos_112 := cindex_110 ;
+       (if cstate_109.major then
+        (((Zls.set cstate_109.cvec  !cpos_112  self.t_80.pos ;
+           cpos_112 := (+) !cpos_112  1)))
+        else (((Zls.set cstate_109.dvec  !cpos_112  self.t_80.der ;
+                cpos_112 := (+) !cpos_112  1)))) ; result_114)):unit) in 
+  let main_reset self  =
+    ((self.i_92 <- true ;
+      self.t_80.pos <- 0. ; i_96_reset self.i_96  ; i_95_reset self.i_95 ):
+    unit) in
+  Node { alloc = main_alloc; step = main_step ; reset = main_reset }

exm/zelus/ballcos/tmp/dune

@@ -0,0 +1,8 @@
+(env
+ (dev
+  (flags
+   (:standard -w -a))))
+
+(executable
+ (name main_b)
+ (libraries zelus))

exm/zelus/ballcos/tmp/main_b.ml

@@ -0,0 +1,31 @@
+open Ztypes
+open Zls
+
+(* simulation (continuous) function *)
+let main = 
+  let cstate = 
+    { dvec = cmake 0; cvec = cmake 0; zinvec = zmake 0; zoutvec = cmake 0; 
+      cindex = 0; zindex = 0; cend = 0; zend = 0; cmax = 0; zmax = 0; 
+      major = false; horizon = 0.0 } in 
+  let Node { alloc = alloc; step = hstep; reset = reset } = Ball.main cstate in 
+  let step mem cvec dvec zin t = 
+    cstate.major <- true; cstate.cvec <- cvec; cstate.dvec <- dvec; 
+    cstate.cindex <- 0; cstate.zindex <- 0; cstate.horizon <- infinity;  
+    hstep mem (t, ()) in
+  let derivative mem cvec dvec zin zout t = 
+    cstate.major <- false;  cstate.cvec <- cvec; cstate.dvec <- dvec; 
+    cstate.zinvec <- zin; cstate.zoutvec <- zout; cstate.cindex <- 0; 
+    cstate.zindex <- 0; ignore (hstep mem (t, ())) in
+  let crossings mem cvec zin zout t = 
+    cstate.major <- false;  cstate.cvec <- cvec; cstate.zinvec <- zin; 
+    cstate.zoutvec <- zout; cstate.cindex <- 0; cstate.zindex <- 0; 
+    ignore (hstep mem (t, ())) in
+  let maxsize mem = cstate.cmax, cstate.zmax in
+  let csize mem = cstate.cend in
+  let zsize mem = cstate.zend in
+  let horizon mem = cstate.horizon in
+  Hsim { alloc; step; reset; derivative; crossings; maxsize;  csize;  zsize; 
+         horizon };;
+(* instantiate a numeric solver *)
+module Runtime = Zlsrun.Make (Defaultsolver)
+let _ = Runtime.go main

exm/zelus/ballcos/ztypes.ml

@@ -0,0 +1,16 @@
+include Std
+include Ztypes
+include Solvers
+
+module type IGNORE = sig end
+module Defaultsolver : IGNORE = struct end
+
+module Zlsrun = struct
+  module Make (S : IGNORE) = struct
+    let go _ = ()
+  end
+end
+
+module Stdlib = struct
+  type nonrec 'a option = 'a option
+end