(* The Zelus compiler, version 2.2-dev
  (2025-06-16-15:24) *)
open Common
open Ztypes
open Solvers
(* open Zls *)

type ('f , 'e , 'd , 'c , 'b , 'a) _sin_1_x =
  { mutable major_22 : 'f ;
    mutable i_29 : 'e ;
    mutable x_28 : 'd ;
    mutable result_27 : 'c ; mutable o_26 : 'b ; mutable t0_23 : 'a }

let sin_1_x (cstate_30:Ztypes.cstate) =

  let sin_1_x_alloc _ =
    cstate_30.cmax <- (+) cstate_30.cmax  2 ;
    cstate_30.zmax <- (+) cstate_30.zmax  1;
    { major_22 = false ;
      i_29 = (false:bool) ;
      x_28 = { zin = false; zout = 1. } ;
      result_27 = (42.:float) ;
      o_26 = { pos = 42.; der = 0. } ; t0_23 = { pos = 42.; der = 0. } } in
  let sin_1_x_step self ((_time_21:float) , ()) =
    ((let (cindex_31:int) = cstate_30.cindex in
      let cpos_33 = ref (cindex_31:int) in
      let (zindex_32:int) = cstate_30.zindex in
      let zpos_34 = ref (zindex_32:int) in
      cstate_30.cindex <- (+) cstate_30.cindex  2 ;
      cstate_30.zindex <- (+) cstate_30.zindex  1 ;
      self.major_22 <- cstate_30.major ;
      (if cstate_30.major then
       for i_1 = cindex_31 to 1 do Zls.set cstate_30.dvec  i_1  0. done
       else ((self.o_26.pos <- Zls.get cstate_30.cvec  !cpos_33 ;
              cpos_33 := (+) !cpos_33  1) ;
             (self.t0_23.pos <- Zls.get cstate_30.cvec  !cpos_33 ;
              cpos_33 := (+) !cpos_33  1))) ;
      (let (result_35:(float  * float)) =
           (if self.i_29 then
            self.o_26.pos <- ( *. ) ((~-.) 0.6)
                                    (( ** ) (sin ((/.) 1.  ((~-.) 0.6)))  2.))
           ;
           self.i_29 <- false ;
           self.t0_23.der <- 1. ;
           (let (t_25:float) = (-.) self.t0_23.pos  0.6 in
            self.o_26.der <- ( *. ) (sin ((/.) 1.  t_25))
                                    ((-.) (sin ((/.) 1.  t_25))
                                          ((/.) (( *. ) 2.
                                                        (cos ((/.) 1.  t_25)))
                                                 t_25)) ;
            self.x_28.zout <- self.o_26.pos ;
            (begin match self.x_28.zin with
                   | true -> self.result_27 <- 1.
                   | _ -> self.result_27 <- 0.  end) ;
            (self.result_27 , self.o_26.pos)) in
       cpos_33 := cindex_31 ;
       (if cstate_30.major then
        (((Zls.set cstate_30.cvec  !cpos_33  self.o_26.pos ;
           cpos_33 := (+) !cpos_33  1) ;
          (Zls.set cstate_30.cvec  !cpos_33  self.t0_23.pos ;
           cpos_33 := (+) !cpos_33  1)) ; ((self.x_28.zin <- false)))
        else (((self.x_28.zin <- Zls.get_zin cstate_30.zinvec  !zpos_34 ;
                zpos_34 := (+) !zpos_34  1)) ;
              zpos_34 := zindex_32 ;
              ((Zls.set cstate_30.zoutvec  !zpos_34  self.x_28.zout ;
                zpos_34 := (+) !zpos_34  1)) ;
              ((Zls.set cstate_30.dvec  !cpos_33  self.o_26.der ;
                cpos_33 := (+) !cpos_33  1) ;
               (Zls.set cstate_30.dvec  !cpos_33  self.t0_23.der ;
                cpos_33 := (+) !cpos_33  1)))) ; result_35)):float * float) in

  let sin_1_x_reset self  =
    ((self.i_29 <- true ; self.t0_23.pos <- 0.):unit) in
  Node { alloc = sin_1_x_alloc; step = sin_1_x_step ; reset = sin_1_x_reset }