(*
open Hsim.Types
open Hsim.Solver
open Zls

module Functional : Csolver.Csolver =
  struct
    type ('state, 'vec) state = { state : 'state; vec : 'vec }
    type session = (Sundials_RealArray.t, Nvector_serial.kind) Cvode.session
    type vec = carray

    let csolve : ((session, vec) state, carray, carray) csolver =
      let open Cvode in

      let init { size; fder=_; _ } =
        let vec = cmake size in
        let state = init Adams default_tolerances (fun _ _ _ -> ()) 0.
                         (Nvector_serial.wrap vec) in
        set_stop_time state 1.0;
        { state; vec } in

      let reset { init=i; fder; stop; _ } { vec; _ } =
        let fder t cvec dvec =
          let dvec' = fder t cvec in blit dvec' dvec in
        let state =
          Cvode.init Adams default_tolerances fder 0. (Nvector_serial.wrap i) in
        set_stop_time state stop;
        { state; vec } in

      let step ({ state; vec } as s) h =
        let y = Nvector_serial.wrap vec in
        let h, _ = solve_one_step state h y in
        let f t = get_dky state y t 0; Nvector_serial.unwrap y in
        (h, f), s in

      DNode { init; reset; step }
  end

module InPlace : Csolver.Csolver =
  struct
    type ('state, 'vec) state = { mutable state: 'state; mutable vec : 'vec }

    type session = (Sundials_RealArray.t, Nvector_serial.kind) Cvode.session
    type vec = carray

    let csolve : ((session, vec) state, carray, carray) csolver =
      let open Cvode in

      let init { size; fder=_; _ } =
        let vec = cmake size in
        let state = init Adams default_tolerances (fun _ _ _ -> ()) 0.
                         (Nvector_serial.wrap vec) in
        set_stop_time state 1.0;
        { state; vec } in

      let reset { init=i; fder; _ } s =
        let fder t cvec dvec =
          let dvec' = fder t cvec in blit dvec' dvec in
        let state =
          Cvode.init Adams default_tolerances fder 0. (Nvector_serial.wrap i) in
        set_stop_time state 1.0; s.state <- state; s.vec <- i; s in

      let step s h =
        let y = Nvector_serial.wrap s.vec in
        let h, _ = solve_one_step s.state h y in
        let f t = get_dky s.state y t 0; Nvector_serial.unwrap y in
        (h, f), s in 

      DNode { init; reset; step }
  end
*)