Source file dump.ml

(* The Zelus compiler, version %%NAME%%-%%VERSION%%
  (2026-03-25-20:45) *)
open Ztypes
open Basics
let piecewise = ()

let square = ()

let linear = ()

let points (x_348:'a2520) =
  ()

let getName ((n_349:'a2523) , _ , _) =
  n_349

let getValue (_ , _ , (v_350:'a2530)) =
  v_350

type ('b , 'a) _scopen =
  { mutable i_355 : 'b ; mutable names_354 : 'a }

let scopen  = 
  
  let scopen_alloc _ =
    ();{ i_355 = (false:bool) ; names_354 = (Obj.magic ():'a list) } in
  let scopen_reset self  =
    (self.i_355 <- true:unit) in 
  let scopen_step self ((yl_352:'a2538) ,
                        (yu_353:'a2539) ,
                        (l_351:(('a2553  * 'a2554  * 'a2555))list)) =
    (((if self.i_355 then self.names_354 <- List.map getName  l_351) ;
      self.i_355 <- false ; (self.names_354 , (List.map getValue  l_351))):
    'a list * 'b list) in
  Node { alloc = scopen_alloc; reset = scopen_reset ; step = scopen_step }
type ('b , 'a) _scope =
  { mutable i_362 : 'b ; mutable names_361 : 'a }

let scope  = 
  
  let scope_alloc _ =
    ();{ i_362 = (false:bool) ; names_361 = (Obj.magic ():'c list) } in
  let scope_reset self  =
    (self.i_362 <- true:unit) in 
  let scope_step self ((yl_359:'a2575) ,
                       (yu_360:'a2576) ,
                       ((n1_356:'a2592) , (t1_357:'a2573) , (v1_358:'a2600))) =
    (((if self.i_362 then self.names_361 <- (::) (n1_356 , ([]))) ;
      self.i_362 <- false ; (self.names_361 , ((::) (v1_358 , ([]))))):
    'c list * 'd list) in
  Node { alloc = scope_alloc; reset = scope_reset ; step = scope_step }
type ('b , 'a) _scope2 =
  { mutable i_372 : 'b ; mutable names_371 : 'a }

let scope2  = 
  
  let scope2_alloc _ =
    ();{ i_372 = (false:bool) ; names_371 = (Obj.magic ():'e list) } in
  let scope2_reset self  =
    (self.i_372 <- true:unit) in 
  let scope2_step self ((yl_369:'a2611) ,
                        (yu_370:'a2612) ,
                        ((n1_363:'a2638) , (t1_365:'a2607) , (v1_367:'a2652))
                        ,
                        ((n2_364:'a2638) , (t2_366:'a2608) , (v2_368:'a2652))) =
    (((if self.i_372 then
       self.names_371 <- (::) (n1_363 , ((::) (n2_364 , ([]))))) ;
      self.i_372 <- false ;
      (self.names_371 , ((::) (v1_367 , ((::) (v2_368 , ([]))))))):'e list *
                                                                   'f list) in
  Node { alloc = scope2_alloc; reset = scope2_reset ; step = scope2_step }
type ('b , 'a) _scope3 =
  { mutable i_385 : 'b ; mutable names_384 : 'a }

let scope3  = 
  
  let scope3_alloc _ =
    ();{ i_385 = (false:bool) ; names_384 = (Obj.magic ():'g list) } in
  let scope3_reset self  =
    (self.i_385 <- true:unit) in 
  let scope3_step self ((yl_382:'a2667) ,
                        (yu_383:'a2668) ,
                        ((n1_373:'a2704) , (t1_376:'a2661) , (v1_379:'a2724))
                        ,
                        ((n2_374:'a2704) , (t2_377:'a2662) , (v2_380:'a2724))
                        ,
                        ((n3_375:'a2704) , (t3_378:'a2663) , (v3_381:'a2724))) =
    (((if self.i_385 then
       self.names_384 <- (::) (n1_373 ,
                               ((::) (n2_374 , ((::) (n3_375 , ([]))))))) ;
      self.i_385 <- false ;
      (self.names_384 ,
       ((::) (v1_379 , ((::) (v2_380 , ((::) (v3_381 , ([]))))))))):'g list *
                                                                    'h list) in
  Node { alloc = scope3_alloc; reset = scope3_reset ; step = scope3_step }
type ('b , 'a) _scope4 =
  { mutable i_401 : 'b ; mutable names_400 : 'a }

let scope4  = 
  
  let scope4_alloc _ =
    ();{ i_401 = (false:bool) ; names_400 = (Obj.magic ():'i list) } in
  let scope4_reset self  =
    (self.i_401 <- true:unit) in 
  let scope4_step self ((yl_398:'a2743) ,
                        (yu_399:'a2744) ,
                        ((n1_386:'a2790) , (t1_390:'a2735) , (v1_394:'a2816))
                        ,
                        ((n2_387:'a2790) , (t2_391:'a2736) , (v2_395:'a2816))
                        ,
                        ((n3_388:'a2790) , (t3_392:'a2737) , (v3_396:'a2816))
                        ,
                        ((n4_389:'a2790) , (t4_393:'a2738) , (v4_397:'a2816))) =
    (((if self.i_401 then
       self.names_400 <- (::) (n1_386 ,
                               ((::) (n2_387 ,
                                      ((::) (n3_388 , ((::) (n4_389 , ([])))))))))
      ;
      self.i_401 <- false ;
      (self.names_400 ,
       ((::) (v1_394 ,
              ((::) (v2_395 , ((::) (v3_396 , ((::) (v4_397 , ([]))))))))))):
    'i list * 'j list) in
  Node { alloc = scope4_alloc; reset = scope4_reset ; step = scope4_step }
type ('e , 'd , 'c , 'b , 'a) _windown =
  { mutable i_410 : 'e ;
    mutable x_409 : 'd ;
    mutable v_408 : 'c ; mutable n_407 : 'b ; mutable f_406 : 'a }

let windown  = 
  
  let windown_alloc _ =
    ();
    { i_410 = (false:bool) ;
      x_409 = (():unit) ;
      v_408 = (Obj.magic ():float list) ;
      n_407 = (Obj.magic ():string list) ;
      f_406 = (Obj.magic ():Stdlib.out_channel) } in
  let windown_reset self  =
    (self.i_410 <- true:unit) in 
  let windown_step self ((title_405:string) ,
                         (imaxt_402:'a2824) ,
                         (t_404:float) ,
                         (l_403:(((string)list  * (float)list))list)) =
    (((if self.i_410 then
       self.v_408 <- List.fold_left List.append 
                                    ([])  (snd (List.split l_403))) ;
      (if self.i_410 then
       self.n_407 <- List.fold_left List.append 
                                    ([])  (fst (List.split l_403))) ;
      (if self.i_410 then self.f_406 <- open_out ((^) title_405  ".out")) ;
      (if self.i_410 then
       self.x_409 <- Basics.output_quoted_strings self.f_406 
                                                  ((::) ("t" , self.n_407)))
      ;
      self.i_410 <- false ;
      Basics.output_floats self.f_406  ((::) (t_404 , self.v_408))):unit) in
  Node { alloc = windown_alloc; reset = windown_reset ; step = windown_step }
type ('c , 'b , 'a) _window =
  { mutable i_418 : 'c ; mutable x_417 : 'b ; mutable f_416 : 'a }

let window  = 
  
  let window_alloc _ =
    ();
    { i_418 = (false:bool) ;
      x_417 = (():unit) ; f_416 = (Obj.magic ():Stdlib.out_channel) } in
  let window_reset self  =
    (self.i_418 <- true:unit) in 
  let window_step self ((title_414:string) ,
                        (imaxt_411:'a2927) ,
                        (t_413:float) ,
                        ((n1_412:(string)list) , (v1_415:(float)list))) =
    (((if self.i_418 then self.f_416 <- open_out ((^) title_414  ".out")) ;
      (if self.i_418 then
       self.x_417 <- Basics.output_quoted_strings self.f_416 
                                                  ((::) ("t" , n1_412))) ;
      self.i_418 <- false ;
      Basics.output_floats self.f_416  ((::) (t_413 , v1_415))):unit) in
  Node { alloc = window_alloc; reset = window_reset ; step = window_step }
type ('c , 'b , 'a) _window2 =
  { mutable i_428 : 'c ; mutable x_427 : 'b ; mutable f_426 : 'a }

let window2  = 
  
  let window2_alloc _ =
    ();
    { i_428 = (false:bool) ;
      x_427 = (():unit) ; f_426 = (Obj.magic ():Stdlib.out_channel) } in
  let window2_reset self  =
    (self.i_428 <- true:unit) in 
  let window2_step self ((title_423:string) ,
                         (imaxt_419:'a2976) ,
                         (t_422:float) ,
                         ((n1_420:(string)list) , (v1_424:(float)list)) ,
                         ((n2_421:(string)list) , (v2_425:(float)list))) =
    (((if self.i_428 then self.f_426 <- open_out ((^) title_423  ".out")) ;
      (if self.i_428 then
       self.x_427 <- Basics.output_quoted_strings self.f_426 
                                                  ((::) ("t" ,
                                                         (List.append 
                                                            n1_420  n2_421))))
      ;
      self.i_428 <- false ;
      Basics.output_floats self.f_426 
                           ((::) (t_422 , (List.append v1_424  v2_425)))):
    unit) in
  Node { alloc = window2_alloc; reset = window2_reset ; step = window2_step }
type ('c , 'b , 'a) _window3 =
  { mutable i_440 : 'c ; mutable x_439 : 'b ; mutable f_438 : 'a }

let window3  = 
  
  let window3_alloc _ =
    ();
    { i_440 = (false:bool) ;
      x_439 = (():unit) ; f_438 = (Obj.magic ():Stdlib.out_channel) } in
  let window3_reset self  =
    (self.i_440 <- true:unit) in 
  let window3_step self ((title_434:string) ,
                         (imaxt_429:'a3043) ,
                         (t_433:float) ,
                         ((n1_430:(string)list) , (v1_435:(float)list)) ,
                         ((n2_431:(string)list) , (v2_436:(float)list)) ,
                         ((n3_432:(string)list) , (v3_437:(float)list))) =
    (((if self.i_440 then self.f_438 <- open_out ((^) title_434  ".out")) ;
      (if self.i_440 then
       self.x_439 <- Basics.output_quoted_strings self.f_438 
                                                  ((::) ("t" ,
                                                         (List.append 
                                                            n1_430 
                                                            (List.append 
                                                               n2_431  n3_432)))))
      ;
      self.i_440 <- false ;
      Basics.output_floats self.f_438 
                           ((::) (t_433 ,
                                  (List.append v1_435 
                                               (List.append v2_436  v3_437))))):
    unit) in
  Node { alloc = window3_alloc; reset = window3_reset ; step = window3_step }
type ('c , 'b , 'a) _window4 =
  { mutable i_454 : 'c ; mutable x_453 : 'b ; mutable f_452 : 'a }

let window4  = 
  
  let window4_alloc _ =
    ();
    { i_454 = (false:bool) ;
      x_453 = (():unit) ; f_452 = (Obj.magic ():Stdlib.out_channel) } in
  let window4_reset self  =
    (self.i_454 <- true:unit) in 
  let window4_step self ((title_447:string) ,
                         (imaxt_441:'a3128) ,
                         (t_446:float) ,
                         ((n1_442:(string)list) , (v1_448:(float)list)) ,
                         ((n2_443:(string)list) , (v2_449:(float)list)) ,
                         ((n3_444:(string)list) , (v3_450:(float)list)) ,
                         ((n4_445:(string)list) , (v4_451:(float)list))) =
    (((if self.i_454 then self.f_452 <- open_out ((^) title_447  ".out")) ;
      (if self.i_454 then
       self.x_453 <- Basics.output_quoted_strings self.f_452 
                                                  ((::) ("t" ,
                                                         (List.append 
                                                            n1_442 
                                                            (List.append 
                                                               n2_443 
                                                               (List.append 
                                                                  n3_444 
                                                                  n4_445))))))
      ;
      self.i_454 <- false ;
      Basics.output_floats self.f_452 
                           ((::) (t_446 ,
                                  (List.append v1_448 
                                               (List.append v2_449 
                                                            (List.append 
                                                               v3_450  v4_451)))))):
    unit) in
  Node { alloc = window4_alloc; reset = window4_reset ; step = window4_step }
type _window5 = unit

let window5  = 
   let window5_alloc _ = () in
  let window5_reset self  =
    ((()):unit) in 
  let window5_step self ((title_462:string) ,
                         (imaxt_455:'a3231) ,
                         (t_461:float) ,
                         ((n1_456:(string)list) , (v1_463:(float)list)) ,
                         ((n2_457:(string)list) , (v2_464:(float)list)) ,
                         ((n3_458:(string)list) , (v3_465:(float)list)) ,
                         ((n4_459:(string)list) , (v4_466:(float)list)) ,
                         ((n5_460:(string)list) , (v5_467:(float)list))) =
    ((let (f_468:Stdlib.out_channel) = open_out ((^) title_462  ".out") in
      let (x_469:unit) =
          Basics.output_quoted_strings f_468 
                                       ((::) ("t" ,
                                              (List.append n1_456 
                                                           (List.append 
                                                              n2_457 
                                                              (List.append 
                                                                 n3_458 
                                                                 (List.append 
                                                                    n4_459 
                                                                    n5_460)))))) in
      Basics.output_floats f_468 
                           ((::) (t_461 ,
                                  (List.append v1_463 
                                               (List.append v2_464 
                                                            (List.append 
                                                               v3_465 
                                                               (List.append 
                                                                  v4_466 
                                                                  v5_467))))))):
    unit) in
  Node { alloc = window5_alloc; reset = window5_reset ; step = window5_step }