chore: update

exm/main.zls

@@ -1,9 +1,26 @@
 
 
 
-(** Zélus
 
-    Synchronous language kernel _à la_ Lustre:
+
+
+(** Zélus: Hybrid system programming language
+
+    - Model discrete systems and their continuous environment
+    - Research language, design space for hybrid system modelers
+    - Compilation to OCaml, execution with an off-the-shelf ODE solver
+    - Developed by the Inria PARKAS team *)
+
+
+
+
+
+
+
+
+
+
+(** Synchronous language kernel _à la_ Lustre:
     - programs are Mealy machines (outputs on each transition)
     - variables represent streams of values in time *)
 
@@ -18,21 +35,22 @@ let node incr x = y where
 
 
 
-
-(** - we can use values of the previous instants (using [pre]) and
-      initialize streams (using [->]) *)
+(** - we can use values of the previous instants with [pre] and
+      initialize streams with [->] *)
 
 let node accumulate x = z where
-  rec w = pre x
-  and y = 0 -> pre x
-  and z = x -> (pre z) + x
+  rec z = x -> (pre z) + x
 
-(*   x │ 1  2  5  2  5  3  …
-    ───┼─────────────────────
-     w │    1  2  5  2  5  …
-     y │ 0  1  2  5  2  5  …
-     z │ 1  3  8 10 15 18  …   *)
+(*              x │ 1  2  5  2  5  3  …
+    ──────────────┼─────────────────────
+            pre x │    1  2  5  2  5  …
+           0 -> x │ 0  2  5  2  5  3  …
+     accumulate x │ 1  3  8 10 15 18  …   *)
 
+let node fib () = n where
+  rec n = 0 -> pre (1 -> pre(n) + n)
+
+(** - causality loops are forbidden ([rec x = x]) *)
 
 
 (** - we can reset streams at will *)
@@ -53,12 +71,32 @@ let node loop x = y where
      loop x │ 0  1  2  0  1  2  …   *)
 
 
+
+
+
+
+
+
+(** Math/physics reminder!
+
+    - Ordinary differential equations (ODEs), initial value problems
+    - Zero-crossing event basics
+    - Background on solvers *)
+
+
+
+
+
+
+
+
 (** Already able to model physical behaviours! *)
 
-let dt = 0.001                        (* Integration step                     *)
+let dt = 0.01                         (* Integration step                     *)
 let g  = 9.81                         (* Gravitational constant               *)
 let node f_integr (x0, x') = x where  (* Forward Euler integrator             *)
   rec x = x0 -> pre (x +. x' *. dt)
+
 let node b_integr (x0, x') = x where  (* Backward Euler integrator            *)
   rec x = x0 -> (pre x) +. x' *. dt
 
@@ -68,7 +106,21 @@ let node bouncing_ball (p0, v0) = p where
   and q = p0 -> 0.0 and w = v0 -> -0.8 *. (pre v)
   and z = false -> (pre p) < 0.0
 
-(** Quite cumbersome. *)
+
+
+
+
+
+
+
+(** Cumbersome, and error-prone! *)
+
+let node sincos () = (sin, cos) where
+  rec sin = f_integr(0.0, cos)
+  and cos = f_integr(1.0, -. sin)
+
+
+
 
 
 
@@ -81,6 +133,9 @@ let node bouncing_ball (p0, v0) = p where
 let hybrid integr (x0, x') = x where
   der x = x' init x0
 
+let hybrid time () = t where
+  der t = 1.0 init 0.0
+
 let hybrid position (p0, v0, a) = p where
   rec der p = v init p0
   and der v = a init v0
@@ -89,33 +144,28 @@ let hybrid position (p0, v0, a) = p where
 
 
 
-
-
-
-
-
-
-
-
-(** We can intermingle discrete and continuous behaviours: *)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-(** We can now express physical systems much more precisely: *)
+(** - mix discrete and continuous code with [up], [present], [reset]
+      and [last] *)
 
 let hybrid bouncing_ball (p0, v0) = p where
   rec der p = v    init p0 reset z -> 0.0
   and der v = -. g init v0 reset z -> -0.8 *. last v
   and     z = up(-. p)
+
+let hybrid time_bounces (p0, v0) = (p, b) where
+  rec      p = bouncing_ball (p0, v0)
+  and  der t = 1.0 init 0.0
+  and init b = 0.0
+  and present up(-. p) -> do
+    b = t -. last b
+  done
+
+
+
+
+
+
+
+
+
+(** - w FIXME e can mix discrete and continuous behaviours *)