feat: greedy simulation

doc/notes.typ

@@ -300,6 +300,113 @@ Two possible options for the simulation reset:
   makes this impossible. We thus need reset parameters for both the model and 
   solver.
 
+=== Steps
+
+The _lazy simulation_'s step function is as follows:
+
+```ocaml
+let step s i =
+  let ms, ss = S.get_mstate s, S.get_sstate s in
+  match i, S.is_running s with
+  | Some i, _ ->
+      let mode, now, stop = Discrete, 0.0, i.length in
+      None, S.set_running ~mode ~input:i ~now ~stop s
+  | None, false -> None, s
+  | None, true ->
+      let i, now, stop = S.get_input s, S.get_now s, S.get_stop s in
+      match S.get_mode s with
+      | Discrete ->
+          let o, ms = model.step ms (i.u now) in
+          let s =
+            let h = model.horizon ms in
+            if h <= 0.0 then S.set_mstate ms s
+            else if now >= stop then S.set_idle s
+            else if model.jump ms then
+              let init   = model.cget ms in
+              let fder t = model.fder ms (Utils.offset i now t) in
+              let fzer t = model.fzer ms (Utils.offset i now t) in
+              let ivp    = { fder; stop = stop -. now; init } in
+              let zc     = { init ; fzer; size = model.zsize } in
+              let ss     = solver.reset (ivp, zc) ss in
+              let i      = { start=i.start +. now; length=i.length -. now;
+                             u=Utils.offset i now } in
+              let mode, stop, now = Continuous, i.length, 0.0 in
+              S.update ms ss (S.set_running ~mode ~input:i ~stop ~now s)
+            else S.set_running ~mode:Continuous s in
+          Some { start = i.start+. now; length = 0.0; u = fun _ -> o }, s
+      | Continuous ->
+          let (h, f, z), ss = solver.step ss stop in
+          let ms = model.cset ms (f h) in
+          let start = i.start +. now in
+          let fout t = model.fout ms (i.u (now +. t)) (f (now +. t)) in
+          let out = { start; length=h -. now; u=fout } in
+          let s = match z with
+          | None ->
+              let s = if h >= stop
+                then S.set_running ~mode:Discrete ~now:h s
+                else S.set_running ~now:h s in
+              S.update ms ss s
+          | Some z ->
+              let s = S.set_running ~mode:Discrete ~now:h s in
+              S.update (model.zset ms z) ss s in
+          Some out, s in
+```
+
+The _greedy simulation_'s step function is as follows:
+
+```ocaml
+let rec step s i =
+  let ms, ss = S.get_mstate s, S.get_sstate s in
+  if not (S.is_running s) then
+    let mode, now, stop = Discrete, 0.0, i.length in
+    step (S.set_running ~mode ~input:i ~now ~stop s) i
+  else let now, stop = S.get_now s, S.get_stop s in
+  match S.get_mode s with
+  | Discrete ->
+      let o, ms = model.step ms (i.u now) in
+      let h = model.horizon ms in
+      let rest, s =
+        if h <= 0.0 then step (S.set_mstate ms s) i
+        else if now >= stop then [], s
+        else if model.jump ms then
+          let init   = model.cget ms in
+          let fder t = model.fder ms (Utils.offset i now t) in
+          let fzer t = model.fzer ms (Utils.offset i now t) in
+          let ivp    = { fder; stop = stop -. now; init } in
+          let zc     = { init; fzer; size = model.zsize } in
+          let ss     = solver.reset (ivp, zc) ss in
+          let i      = { start=i.start +. now; length=i.length -. now; 
+                         u=Utils.offset i now } in
+          let mode, stop, now = Continuous, i.length, 0.0 in
+          let s = S.set_running ~mode ~input:i ~stop ~now s in
+          step (S.update ms ss s) i
+        else step (S.set_running ~mode:Continuous s) i in
+      { start = i.start +. now; length = 0.0; u = fun _ -> o }::rest, s
+  | Continuous ->
+      let (h, f, z), ss = solver.step ss stop in
+      let ss = solver.copy ss in
+      let ms = model.cset ms (f h) in
+      let fout t = model.fout ms (i.u (now +. t)) (f (now +. t)) in
+      let out = { start = i.start +. now; length = h -. now; u = fout } in
+      match z with
+      | None ->
+          if h >= stop then
+            let s = S.set_running ~mode:Discrete ~now:h s in
+            let rest, s = step (S.update ms ss s) i in
+            out::rest, s
+          else
+            let s = S.set_running ~now:h s in
+            let rest, s = step (S.update ms ss s) i in
+            (match rest with
+             | [] -> [out], s
+             | f::rest -> Utils.compose [out;f] :: rest, s)
+      | Some z ->
+          let s = S.set_running ~mode:Discrete ~now:h s in
+          let ms = model.zset ms z in
+          let rest, s = step (S.update ms ss s) i in
+          out::rest, s in
+```
+
 == Mathematical model
 
 #link("https://zelus.di.ens.fr/cc2015/fullpaper.pdf")[[CC'15]] defines the