sig
type arkstep = Arkode_impl.arkstep
type erkstep = Arkode_impl.erkstep
type mristep = Arkode_impl.mristep
module Common :
sig
type solver_result = Success | RootsFound | StopTimeReached
type step_stats = {
num_steps : int;
actual_init_step : float;
last_step : float;
current_step : float;
current_time : float;
}
type interpolant_type = Hermite | Lagrange
type linearity = Linear of bool | Nonlinear
type 'data error_weight_fun = 'data -> 'data -> unit
type ('data, 'kind) tolerance =
SStolerances of float * float
| SVtolerances of float * ('data, 'kind) Nvector.t
| WFtolerances of 'data Arkode.Common.error_weight_fun
val default_tolerances : ('data, 'kind) Arkode.Common.tolerance
type predictor_method =
TrivialPredictor
| MaximumOrderPredictor
| VariableOrderPredictor
| CutoffOrderPredictor
type 'd nonlin_system_data = {
tcur : float;
zpred : 'd;
zi : 'd;
fi : 'd;
gamma : float;
sdata : 'd;
}
type 'd rootsfn = float -> 'd -> Sundials.RealArray.t -> unit
val no_roots : int * 'd Arkode.Common.rootsfn
type adaptivity_args = {
h1 : float;
h2 : float;
h3 : float;
e1 : float;
e2 : float;
e3 : float;
q : int;
p : int;
}
type 'd adaptivity_fn =
float -> 'd -> Arkode.Common.adaptivity_args -> float
type adaptivity_params = {
ks : (float * float * float) option;
method_order : bool;
}
type 'd adaptivity_method =
PIDcontroller of Arkode.Common.adaptivity_params
| PIcontroller of Arkode.Common.adaptivity_params
| Icontroller of Arkode.Common.adaptivity_params
| ExplicitGustafsson of Arkode.Common.adaptivity_params
| ImplicitGustafsson of Arkode.Common.adaptivity_params
| ImExGustafsson of Arkode.Common.adaptivity_params
| AdaptivityFn of 'd Arkode.Common.adaptivity_fn
type 'd rhsfn = float -> 'd -> 'd -> unit
type 'd stability_fn = float -> 'd -> float
type 'd resize_fn = 'd -> 'd -> unit
type 'd postprocess_step_fn = float -> 'd -> unit
type 'd triple = 'd * 'd * 'd
type ('t, 'd) jacobian_arg =
('t, 'd) Arkode_impl.jacobian_arg = {
jac_t : float;
jac_y : 'd;
jac_fy : 'd;
jac_tmp : 't;
}
end
module Dls :
sig
type 'm jac_fn =
(Sundials.RealArray.t Arkode.Common.triple, Sundials.RealArray.t)
Arkode.Common.jacobian_arg -> 'm -> unit
type 'm linsys_fn =
(Sundials.RealArray.t Arkode.Common.triple, Sundials.RealArray.t)
Arkode.Common.jacobian_arg ->
'm -> 'm option -> bool -> float -> bool
end
module Spils :
sig
type 'd prec_solve_arg = {
rhs : 'd;
gamma : float;
delta : float;
left : bool;
}
type 'd prec_solve_fn =
(unit, 'd) Arkode.Common.jacobian_arg ->
'd Arkode.Spils.prec_solve_arg -> 'd -> unit
type 'd prec_setup_fn =
(unit, 'd) Arkode.Common.jacobian_arg -> bool -> float -> bool
type ('d, 'k, 's) preconditioner =
('d, 'k, 's) Arkode_impl.SpilsTypes.preconditioner
module Banded :
sig
type bandrange = { mupper : int; mlower : int; }
val prec_left :
Arkode.Spils.Banded.bandrange ->
(Nvector_serial.data, [> Nvector_serial.kind ], 's)
Arkode.Spils.preconditioner
val prec_right :
Arkode.Spils.Banded.bandrange ->
(Nvector_serial.data, [> Nvector_serial.kind ], 's)
Arkode.Spils.preconditioner
val prec_both :
Arkode.Spils.Banded.bandrange ->
(Nvector_serial.data, [> Nvector_serial.kind ], 's)
Arkode.Spils.preconditioner
type ('a, 'b) serial_session =
(Nvector_serial.data, 'a, 'b) Arkode_impl.session
constraint 'a = [> Nvector_serial.kind ]
constraint 'b = [< `ARKStep | `MRIStep ]
val get_work_space :
([> Nvector_serial.kind ], [< `ARKStep | `MRIStep ])
Arkode.Spils.Banded.serial_session -> int * int
val get_num_rhs_evals :
([> Nvector_serial.kind ], [< `ARKStep | `MRIStep ])
Arkode.Spils.Banded.serial_session -> int
end
type 'd jac_times_setup_fn =
(unit, 'd) Arkode.Common.jacobian_arg -> unit
type 'd jac_times_vec_fn =
('d, 'd) Arkode.Common.jacobian_arg -> 'd -> 'd -> unit
end
module ButcherTable :
sig
type t = {
method_order : int;
stages : int;
stage_values : Sundials.RealArray2.t;
stage_times : Sundials.RealArray.t;
coefficients : Sundials.RealArray.t;
embedding : (int * Sundials.RealArray.t) option;
}
type erk_table =
HeunEuler_2_1_2
| BogackiShampine_4_2_3
| ARK324L2SA_ERK_4_2_3
| Zonneveld_5_3_4
| ARK436L2SA_ERK_6_3_4
| SayfyAburub_6_3_4
| CashKarp_6_4_5
| Fehlberg_6_4_5
| DormandPrince_7_4_5
| ARK548L2SA_ERK_8_4_5
| Verner_8_5_6
| Fehlberg_13_7_8
| Knoth_Wolke_3_3
| ARK437L2SA_ERK_7_3_4
| ARK548L2SAb_ERK_8_4_5
type dirk_table =
SDIRK_2_1_2
| Billington_3_3_2
| TRBDF2_3_3_2
| Kvaerno_4_2_3
| ARK324L2SA_DIRK_4_2_3
| Cash_5_2_4
| Cash_5_3_4
| SDIRK_5_3_4
| Kvaerno_5_3_4
| ARK436L2SA_DIRK_6_3_4
| Kvaerno_7_4_5
| ARK548L2SA_DIRK_8_4_5
| ARK437L2SA_DIRK_7_3_4
| ARK548L2SAb_DIRK_8_4_5
type ark_table = ARK_4_2_3 | ARK_6_3_4 | ARK_8_4_5
val load_erk : Arkode.ButcherTable.erk_table -> Arkode.ButcherTable.t
val load_dirk : Arkode.ButcherTable.dirk_table -> Arkode.ButcherTable.t
val write :
?logfile:Sundials.Logfile.t -> Arkode.ButcherTable.t -> unit
exception ButcherTableCheckFailed
val check_order :
?outfile:Sundials.Logfile.t ->
Arkode.ButcherTable.t -> int * int option * bool
val check_ark_order :
?outfile:Sundials.Logfile.t ->
Arkode.ButcherTable.t ->
Arkode.ButcherTable.t -> int * int option * bool
end
module ARKStep :
sig
type solver_result = Success | RootsFound | StopTimeReached
type step_stats = {
num_steps : int;
actual_init_step : float;
last_step : float;
current_step : float;
current_time : float;
}
type interpolant_type = Hermite | Lagrange
type linearity = Linear of bool | Nonlinear
type 'data error_weight_fun = 'data -> 'data -> unit
type ('data, 'kind) tolerance =
SStolerances of float * float
| SVtolerances of float * ('data, 'kind) Nvector.t
| WFtolerances of 'data error_weight_fun
val default_tolerances : ('data, 'kind) tolerance
type predictor_method =
TrivialPredictor
| MaximumOrderPredictor
| VariableOrderPredictor
| CutoffOrderPredictor
type 'd nonlin_system_data = {
tcur : float;
zpred : 'd;
zi : 'd;
fi : 'd;
gamma : float;
sdata : 'd;
}
type 'd rootsfn = float -> 'd -> Sundials.RealArray.t -> unit
val no_roots : int * 'd rootsfn
type adaptivity_args = {
h1 : float;
h2 : float;
h3 : float;
e1 : float;
e2 : float;
e3 : float;
q : int;
p : int;
}
type 'd adaptivity_fn = float -> 'd -> adaptivity_args -> float
type adaptivity_params = {
ks : (float * float * float) option;
method_order : bool;
}
type 'd adaptivity_method =
PIDcontroller of adaptivity_params
| PIcontroller of adaptivity_params
| Icontroller of adaptivity_params
| ExplicitGustafsson of adaptivity_params
| ImplicitGustafsson of adaptivity_params
| ImExGustafsson of adaptivity_params
| AdaptivityFn of 'd adaptivity_fn
type 'd rhsfn = float -> 'd -> 'd -> unit
type 'd stability_fn = float -> 'd -> float
type 'd resize_fn = 'd -> 'd -> unit
type 'd postprocess_step_fn = float -> 'd -> unit
type 'd triple = 'd * 'd * 'd
type ('t, 'd) jacobian_arg =
('t, 'd) Arkode_impl.jacobian_arg = {
jac_t : float;
jac_y : 'd;
jac_fy : 'd;
jac_tmp : 't;
}
type ('d, 'k) session = ('d, 'k, Arkode.arkstep) Arkode_impl.session
type 'a serial_session =
(Nvector_serial.data, 'a) Arkode.ARKStep.session
constraint 'a = [> Nvector_serial.kind ]
type ('data, 'kind) linear_solver =
('data, 'kind, Arkode.arkstep) Arkode_impl.lin_solver
type 'a serial_linear_solver =
(Nvector_serial.data, 'a) Arkode.ARKStep.linear_solver
constraint 'a = [> Nvector_serial.kind ]
module Dls :
sig
val dense :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.dense ->
(Sundials.Matrix.Dense.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
val lapack_dense :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.dense ->
(Sundials.Matrix.Dense.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
val band :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.band ->
(Sundials.Matrix.Band.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
val lapack_band :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.band ->
(Sundials.Matrix.Band.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
module Klu :
sig
type ordering =
Sundials_LinearSolver_impl.Klu.ordering =
Amd
| ColAmd
| Natural
val make :
?context:Sundials.Context.t ->
?ordering:ordering ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [ `Dls | `Klu ])
Sundials_LinearSolver.serial_t
val reinit :
('s Sundials.Matrix.Sparse.t, [> Nvector_serial.kind ] as 'a,
[> `Klu ])
Sundials_LinearSolver.serial_t ->
('s, 'a) Sundials.Matrix.sparse -> ?nnz:int -> unit -> unit
val set_ordering :
('s Sundials.Matrix.Sparse.t, [> Nvector_serial.kind ],
[> `Klu ])
Sundials_LinearSolver.serial_t -> ordering -> unit
end
val klu :
?context:Sundials.Context.t ->
?ordering:Klu.ordering ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [ `Dls | `Klu ])
Sundials_LinearSolver.serial_t
module Superlumt :
sig
type ordering =
Sundials_LinearSolver_impl.Superlumt.ordering =
Natural
| MinDegreeProd
| MinDegreeSum
| ColAmd
val make :
?context:Sundials.Context.t ->
?ordering:ordering ->
nthreads:int ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [ `Dls | `Slu ])
Sundials_LinearSolver.serial_t
val set_ordering :
('s Sundials.Matrix.Sparse.t, [> Nvector_serial.kind ],
[> `Slu ])
Sundials_LinearSolver.serial_t -> ordering -> unit
end
val superlumt :
?context:Sundials.Context.t ->
?ordering:Superlumt.ordering ->
nthreads:int ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [> `Dls | `Slu ])
Sundials_LinearSolver.serial_t
type 'm jac_fn =
(Sundials.RealArray.t Common.triple, Sundials.RealArray.t)
Common.jacobian_arg -> 'm -> unit
type 'm linsys_fn =
(Sundials.RealArray.t Common.triple, Sundials.RealArray.t)
Common.jacobian_arg -> 'm -> 'm option -> bool -> float -> bool
val solver :
?jac:'m jac_fn ->
?linsys:'m linsys_fn ->
('m, Sundials.RealArray.t, [> Nvector_serial.kind ] as 'a,
[> `Dls ])
Sundials.LinearSolver.t -> 'a Arkode.ARKStep.serial_linear_solver
val get_work_space :
[> Nvector_serial.kind ] Arkode.ARKStep.serial_session ->
int * int
val get_num_jac_evals :
[> Nvector_serial.kind ] Arkode.ARKStep.serial_session -> int
val get_num_lin_rhs_evals :
[> Nvector_serial.kind ] Arkode.ARKStep.serial_session -> int
end
module Spils :
sig
type gramschmidt_type =
Sundials_LinearSolver_impl.Iterative.gramschmidt_type =
ModifiedGS
| ClassicalGS
val spbcgs :
?context:Sundials.Context.t ->
?maxl:int ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Spbcgs ]) Sundials_LinearSolver.t
val spfgmr :
?context:Sundials.Context.t ->
?maxl:int ->
?max_restarts:int ->
?gs_type:gramschmidt_type ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Spfgmr ]) Sundials_LinearSolver.t
val spgmr :
?context:Sundials.Context.t ->
?maxl:int ->
?max_restarts:int ->
?gs_type:gramschmidt_type ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Spgmr ]) Sundials_LinearSolver.t
val sptfqmr :
?context:Sundials.Context.t ->
?maxl:int ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Sptfqmr ]) Sundials_LinearSolver.t
val pcg :
?context:Sundials.Context.t ->
?maxl:int ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Pcg ]) Sundials_LinearSolver.t
module Algorithms :
sig
val qr_fact :
int ->
Sundials.RealArray2.t -> Sundials.RealArray.t -> bool -> unit
val qr_sol :
int ->
Sundials.RealArray2.t ->
Sundials.RealArray.t -> Sundials.RealArray.t -> unit
val modified_gs :
('d, 'k) Nvector.t array ->
Sundials.RealArray2.t -> int -> int -> float
val classical_gs :
('d, 'k) Nvector.t array ->
Sundials.RealArray2.t ->
int ->
int ->
Sundials.RealArray.t -> ('d, 'k) Nvector.t array -> float
end
val set_maxl :
('m, 'd, 'k, [< `Iter | `Pcg | `Spbcgs | `Sptfqmr ])
Sundials_LinearSolver.t -> int -> unit
val set_gs_type :
('m, 'd, 'k, [< `Iter | `Spfgmr | `Spgmr ])
Sundials_LinearSolver.t -> gramschmidt_type -> unit
val set_max_restarts :
('m, 'd, 'k, [< `Iter | `Spfgmr | `Spgmr ])
Sundials_LinearSolver.t -> int -> unit
type preconditioning_type =
Sundials_LinearSolver_impl.Iterative.preconditioning_type =
PrecNone
| PrecLeft
| PrecRight
| PrecBoth
val set_prec_type :
('m, 'd, 'k, [> `Iter ]) Sundials_LinearSolver.t ->
preconditioning_type -> unit
val set_info_file :
('m, 'd, 'k, [> `Iter ]) Sundials_LinearSolver.t ->
?print_level:bool -> Sundials.Logfile.t -> unit
val set_print_level :
('m, 'd, 'k, [> `Iter ]) Sundials_LinearSolver.t -> bool -> unit
type 'd prec_solve_arg = {
rhs : 'd;
gamma : float;
delta : float;
left : bool;
}
type 'd prec_solve_fn =
(unit, 'd) Common.jacobian_arg ->
'd prec_solve_arg -> 'd -> unit
type 'd prec_setup_fn =
(unit, 'd) Common.jacobian_arg -> bool -> float -> bool
type ('d, 'k, 's) preconditioner =
('d, 'k, 's) Arkode_impl.SpilsTypes.preconditioner
module Banded :
sig
type bandrange = { mupper : int; mlower : int; }
val prec_left :
bandrange ->
(Nvector_serial.data, [> Nvector_serial.kind ], 's)
preconditioner
val prec_right :
bandrange ->
(Nvector_serial.data, [> Nvector_serial.kind ], 's)
preconditioner
val prec_both :
bandrange ->
(Nvector_serial.data, [> Nvector_serial.kind ], 's)
preconditioner
type ('a, 'b) serial_session =
(Nvector_serial.data, 'a, 'b) Arkode_impl.session
constraint 'a = [> Nvector_serial.kind ]
constraint 'b = [< `ARKStep | `MRIStep ]
val get_work_space :
([> Nvector_serial.kind ], [< `ARKStep | `MRIStep ])
serial_session -> int * int
val get_num_rhs_evals :
([> Nvector_serial.kind ], [< `ARKStep | `MRIStep ])
serial_session -> int
end
type 'd jac_times_setup_fn = (unit, 'd) Common.jacobian_arg -> unit
type 'd jac_times_vec_fn =
('d, 'd) Common.jacobian_arg -> 'd -> 'd -> unit
val prec_none : ('d, 'k, Arkode.arkstep) preconditioner
val prec_left :
?setup:'d prec_setup_fn ->
'd prec_solve_fn -> ('d, 'k, Arkode.arkstep) preconditioner
val prec_right :
?setup:'d prec_setup_fn ->
'd prec_solve_fn -> ('d, 'k, Arkode.arkstep) preconditioner
val prec_both :
?setup:'d prec_setup_fn ->
'd prec_solve_fn -> ('d, 'k, Arkode.arkstep) preconditioner
val solver :
('m, 'd, 'k, [> `Iter ]) Sundials.LinearSolver.t ->
?jac_times_vec:'d jac_times_setup_fn option * 'd jac_times_vec_fn ->
?jac_times_rhs:'d rhsfn ->
('d, 'k, Arkode.arkstep) preconditioner ->
('d, 'k) Arkode.ARKStep.linear_solver
val set_jac_eval_frequency :
('d, 'k) Arkode.ARKStep.session -> int -> unit
val set_linear_solution_scaling :
('d, 'k) Arkode.ARKStep.session -> bool -> unit
val set_eps_lin : ('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_ls_norm_factor :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val get_work_space : ('d, 'k) Arkode.ARKStep.session -> int * int
val get_num_lin_iters : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_lin_conv_fails : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_prec_evals : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_prec_solves : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_jtsetup_evals : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_jtimes_evals : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_lin_rhs_evals : ('d, 'k) Arkode.ARKStep.session -> int
val set_preconditioner :
('d, 'k) Arkode.ARKStep.session ->
?setup:'d prec_setup_fn -> 'd prec_solve_fn -> unit
val set_jac_times :
('d, 'k) Arkode.ARKStep.session ->
?jac_times_setup:'d jac_times_setup_fn ->
'd jac_times_vec_fn -> unit
val clear_jac_times : ('d, 'k) Arkode.ARKStep.session -> unit
end
val matrix_embedded_solver :
(unit, 'data, 'kind, [> `MatE ]) Sundials.LinearSolver.t ->
('data, 'kind) Arkode.ARKStep.linear_solver
module Mass :
sig
type ('data, 'kind) solver
type 'a serial_solver =
(Nvector_serial.data, 'a) Arkode.ARKStep.Mass.solver
constraint 'a = [> Nvector_serial.kind ]
module Dls :
sig
val dense :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.dense ->
(Sundials.Matrix.Dense.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
val lapack_dense :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.dense ->
(Sundials.Matrix.Dense.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
val band :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.band ->
(Sundials.Matrix.Band.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
val lapack_band :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.band ->
(Sundials.Matrix.Band.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
module Klu :
sig
type ordering =
Sundials_LinearSolver_impl.Klu.ordering =
Amd
| ColAmd
| Natural
val make :
?context:Sundials.Context.t ->
?ordering:ordering ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [ `Dls | `Klu ])
Sundials_LinearSolver.serial_t
val reinit :
('s Sundials.Matrix.Sparse.t,
[> Nvector_serial.kind ] as 'a, [> `Klu ])
Sundials_LinearSolver.serial_t ->
('s, 'a) Sundials.Matrix.sparse ->
?nnz:int -> unit -> unit
val set_ordering :
('s Sundials.Matrix.Sparse.t, [> Nvector_serial.kind ],
[> `Klu ])
Sundials_LinearSolver.serial_t -> ordering -> unit
end
val klu :
?context:Sundials.Context.t ->
?ordering:Klu.ordering ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [ `Dls | `Klu ])
Sundials_LinearSolver.serial_t
module Superlumt :
sig
type ordering =
Sundials_LinearSolver_impl.Superlumt.ordering =
Natural
| MinDegreeProd
| MinDegreeSum
| ColAmd
val make :
?context:Sundials.Context.t ->
?ordering:ordering ->
nthreads:int ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [ `Dls | `Slu ])
Sundials_LinearSolver.serial_t
val set_ordering :
('s Sundials.Matrix.Sparse.t, [> Nvector_serial.kind ],
[> `Slu ])
Sundials_LinearSolver.serial_t -> ordering -> unit
end
val superlumt :
?context:Sundials.Context.t ->
?ordering:Superlumt.ordering ->
nthreads:int ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [> `Dls | `Slu ])
Sundials_LinearSolver.serial_t
type 'm mass_fn =
float -> Sundials.RealArray.t triple -> 'm -> unit
val solver :
'm Arkode.ARKStep.Mass.Dls.mass_fn ->
bool ->
('m, Sundials.RealArray.t, [> Nvector_serial.kind ] as 'a,
[> `Dls ])
Sundials.LinearSolver.t ->
'a Arkode.ARKStep.Mass.serial_solver
val get_work_space :
[> Nvector_serial.kind ] Arkode.ARKStep.serial_session ->
int * int
val get_num_setups :
[> Nvector_serial.kind ] Arkode.ARKStep.serial_session -> int
val get_num_mult_setups :
[> Nvector_serial.kind ] Arkode.ARKStep.serial_session -> int
val get_num_solves :
[> Nvector_serial.kind ] Arkode.ARKStep.serial_session -> int
val get_num_mult :
[> Nvector_serial.kind ] Arkode.ARKStep.serial_session -> int
end
module Spils :
sig
type gramschmidt_type =
Sundials_LinearSolver_impl.Iterative.gramschmidt_type =
ModifiedGS
| ClassicalGS
val spbcgs :
?context:Sundials.Context.t ->
?maxl:int ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Spbcgs ]) Sundials_LinearSolver.t
val spfgmr :
?context:Sundials.Context.t ->
?maxl:int ->
?max_restarts:int ->
?gs_type:gramschmidt_type ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Spfgmr ]) Sundials_LinearSolver.t
val spgmr :
?context:Sundials.Context.t ->
?maxl:int ->
?max_restarts:int ->
?gs_type:gramschmidt_type ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Spgmr ]) Sundials_LinearSolver.t
val sptfqmr :
?context:Sundials.Context.t ->
?maxl:int ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Sptfqmr ]) Sundials_LinearSolver.t
val pcg :
?context:Sundials.Context.t ->
?maxl:int ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Pcg ]) Sundials_LinearSolver.t
module Algorithms :
sig
val qr_fact :
int ->
Sundials.RealArray2.t ->
Sundials.RealArray.t -> bool -> unit
val qr_sol :
int ->
Sundials.RealArray2.t ->
Sundials.RealArray.t -> Sundials.RealArray.t -> unit
val modified_gs :
('d, 'k) Nvector.t array ->
Sundials.RealArray2.t -> int -> int -> float
val classical_gs :
('d, 'k) Nvector.t array ->
Sundials.RealArray2.t ->
int ->
int ->
Sundials.RealArray.t -> ('d, 'k) Nvector.t array -> float
end
val set_maxl :
('m, 'd, 'k, [< `Iter | `Pcg | `Spbcgs | `Sptfqmr ])
Sundials_LinearSolver.t -> int -> unit
val set_gs_type :
('m, 'd, 'k, [< `Iter | `Spfgmr | `Spgmr ])
Sundials_LinearSolver.t -> gramschmidt_type -> unit
val set_max_restarts :
('m, 'd, 'k, [< `Iter | `Spfgmr | `Spgmr ])
Sundials_LinearSolver.t -> int -> unit
type preconditioning_type =
Sundials_LinearSolver_impl.Iterative.preconditioning_type =
PrecNone
| PrecLeft
| PrecRight
| PrecBoth
val set_prec_type :
('m, 'd, 'k, [> `Iter ]) Sundials_LinearSolver.t ->
preconditioning_type -> unit
val set_info_file :
('m, 'd, 'k, [> `Iter ]) Sundials_LinearSolver.t ->
?print_level:bool -> Sundials.Logfile.t -> unit
val set_print_level :
('m, 'd, 'k, [> `Iter ]) Sundials_LinearSolver.t ->
bool -> unit
type 'd prec_solve_arg = {
rhs : 'd;
delta : float;
left : bool;
}
type 'd prec_solve_fn =
float ->
'd Arkode.ARKStep.Mass.Spils.prec_solve_arg -> 'd -> unit
type 'd prec_setup_fn = float -> unit
type ('d, 'k) preconditioner
val prec_none :
('d, 'k) Arkode.ARKStep.Mass.Spils.preconditioner
val prec_left :
?setup:'d Arkode.ARKStep.Mass.Spils.prec_setup_fn ->
'd Arkode.ARKStep.Mass.Spils.prec_solve_fn ->
('d, 'k) Arkode.ARKStep.Mass.Spils.preconditioner
val prec_right :
?setup:'d Arkode.ARKStep.Mass.Spils.prec_setup_fn ->
'd Arkode.ARKStep.Mass.Spils.prec_solve_fn ->
('d, 'k) Arkode.ARKStep.Mass.Spils.preconditioner
val prec_both :
?setup:'d Arkode.ARKStep.Mass.Spils.prec_setup_fn ->
'd Arkode.ARKStep.Mass.Spils.prec_solve_fn ->
('d, 'k) Arkode.ARKStep.Mass.Spils.preconditioner
type mass_times_setup_fn = float -> unit
type 'd mass_times_vec_fn = float -> 'd -> 'd -> unit
val solver :
('m, 'd, 'k, [> `Iter ]) Sundials.LinearSolver.t ->
?mass_times_setup:Arkode.ARKStep.Mass.Spils.mass_times_setup_fn ->
'd Arkode.ARKStep.Mass.Spils.mass_times_vec_fn ->
bool ->
('d, 'k) Arkode.ARKStep.Mass.Spils.preconditioner ->
('d, 'k) Arkode.ARKStep.Mass.solver
val set_eps_lin :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_ls_norm_factor :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val get_work_space :
('d, 'k) Arkode.ARKStep.session -> int * int
val get_num_lin_iters : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_conv_fails : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_mtsetups : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_mass_mult : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_prec_evals : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_prec_solves :
('d, 'k) Arkode.ARKStep.session -> int
val set_preconditioner :
('d, 'k) Arkode.ARKStep.session ->
?setup:'d Arkode.ARKStep.Mass.Spils.prec_setup_fn ->
'd Arkode.ARKStep.Mass.Spils.prec_solve_fn -> unit
val set_times :
('d, 'k) Arkode.ARKStep.session ->
?mass_times_setup:Arkode.ARKStep.Mass.Spils.mass_times_setup_fn ->
'd Arkode.ARKStep.Mass.Spils.mass_times_vec_fn -> unit
end
val matrix_embedded_solver :
(unit, 'data, 'kind, [> `MatE ]) Sundials.LinearSolver.t ->
('data, 'kind) Arkode.ARKStep.linear_solver
end
type 'data res_weight_fun = 'data -> 'data -> unit
type ('data, 'kind) res_tolerance =
ResStolerance of float
| ResVtolerance of ('data, 'kind) Nvector.t
| ResFtolerance of 'data Arkode.ARKStep.res_weight_fun
type ('d, 'k) problem
val implicit :
?nlsolver:('data, 'kind, ('data, 'kind) Arkode.ARKStep.session,
[ `Nvec ])
Sundials_NonlinearSolver.t ->
?nlsrhsfn:'data rhsfn ->
?lsolver:('data, 'kind) Arkode.ARKStep.linear_solver ->
?linearity:linearity ->
'data rhsfn -> ('data, 'kind) Arkode.ARKStep.problem
val explicit : 'data rhsfn -> ('data, 'kind) Arkode.ARKStep.problem
val imex :
?nlsolver:('data, 'kind, ('data, 'kind) Arkode.ARKStep.session,
[ `Nvec ])
Sundials_NonlinearSolver.t ->
?nlsrhsfn:'data rhsfn ->
?lsolver:('data, 'kind) Arkode.ARKStep.linear_solver ->
?linearity:linearity ->
fsi:'data rhsfn ->
fse:'data rhsfn -> unit -> ('data, 'kind) Arkode.ARKStep.problem
val init :
?context:Sundials.Context.t ->
('data, 'kind) Arkode.ARKStep.problem ->
('data, 'kind) tolerance ->
?restol:('data, 'kind) Arkode.ARKStep.res_tolerance ->
?order:int ->
?mass:('data, 'kind) Arkode.ARKStep.Mass.solver ->
?roots:int * 'data rootsfn ->
float ->
('data, 'kind) Nvector.t -> ('data, 'kind) Arkode.ARKStep.session
val evolve_normal :
('d, 'k) Arkode.ARKStep.session ->
float -> ('d, 'k) Nvector.t -> float * solver_result
val evolve_one_step :
('d, 'k) Arkode.ARKStep.session ->
float -> ('d, 'k) Nvector.t -> float * solver_result
val get_dky :
('d, 'k) Arkode.ARKStep.session ->
('d, 'k) Nvector.t -> float -> int -> unit
val reinit :
('d, 'k) Arkode.ARKStep.session ->
?problem:('d, 'k) Arkode.ARKStep.problem ->
?order:int ->
?mass:('d, 'k) Arkode.ARKStep.Mass.solver ->
?roots:int * 'd rootsfn -> float -> ('d, 'k) Nvector.t -> unit
val reset :
('d, 'k) Arkode.ARKStep.session -> float -> ('d, 'k) Nvector.t
val resize :
('d, 'k) Arkode.ARKStep.session ->
?resize_nvec:'d resize_fn ->
?lsolver:('d, 'k) Arkode.ARKStep.linear_solver ->
?mass:('d, 'k) Arkode.ARKStep.Mass.solver ->
('d, 'k) tolerance ->
?restol:('d, 'k) Arkode.ARKStep.res_tolerance ->
float -> ('d, 'k) Nvector.t -> float -> unit
val set_tolerances :
('d, 'k) Arkode.ARKStep.session -> ('d, 'k) tolerance -> unit
val set_res_tolerance :
('d, 'k) Arkode.ARKStep.session ->
('d, 'k) Arkode.ARKStep.res_tolerance -> unit
val set_defaults : ('d, 'k) Arkode.ARKStep.session -> unit
val set_diagnostics :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.ARKStep.session -> unit
val set_interpolant_type :
('d, 'k) Arkode.ARKStep.session -> interpolant_type -> unit
val set_interpolant_degree :
('d, 'k) Arkode.ARKStep.session -> int -> unit
val clear_diagnostics : ('d, 'k) Arkode.ARKStep.session -> unit
val set_error_file :
('d, 'k) Arkode.ARKStep.session -> Sundials.Logfile.t -> unit
val set_err_handler_fn :
('d, 'k) Arkode.ARKStep.session ->
(Sundials.Util.error_details -> unit) -> unit
val clear_err_handler_fn : ('d, 'k) Arkode.ARKStep.session -> unit
val set_init_step : ('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_fixed_step :
('d, 'k) Arkode.ARKStep.session -> float option -> unit
val set_max_num_constr_fails :
('d, 'k) Arkode.ARKStep.session -> int -> unit
val set_max_hnil_warns : ('d, 'k) Arkode.ARKStep.session -> int -> unit
val set_max_num_steps : ('d, 'k) Arkode.ARKStep.session -> int -> unit
val set_max_err_test_fails :
('d, 'k) Arkode.ARKStep.session -> int -> unit
val set_min_step : ('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_max_step : ('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_optimal_params : ('d, 'k) Arkode.ARKStep.session -> unit
val set_stop_time : ('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_imex : ('d, 'k) Arkode.ARKStep.session -> unit
val set_explicit : ('d, 'k) Arkode.ARKStep.session -> unit
val set_implicit : ('d, 'k) Arkode.ARKStep.session -> unit
val set_tables :
('d, 'k) Arkode.ARKStep.session ->
?global_method_order:int ->
?global_embedding_order:int ->
?implicit_table:Arkode.ButcherTable.t ->
?explicit_table:Arkode.ButcherTable.t -> unit -> unit
val set_ark_table_num :
('d, 'k) Arkode.ARKStep.session ->
Arkode.ButcherTable.ark_table -> unit
val set_erk_table_num :
('d, 'k) Arkode.ARKStep.session ->
Arkode.ButcherTable.erk_table -> unit
val set_dirk_table_num :
('d, 'k) Arkode.ARKStep.session ->
Arkode.ButcherTable.dirk_table -> unit
val set_adaptivity_method :
('d, 'k) Arkode.ARKStep.session -> 'd adaptivity_method -> unit
val set_cfl_fraction : ('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_error_bias : ('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_fixed_step_bounds :
('d, 'k) Arkode.ARKStep.session -> float -> float -> unit
val set_max_cfail_growth :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_max_efail_growth :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_max_first_growth :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_max_growth : ('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_min_reduction :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_safety_factor :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_small_num_efails :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_stability_fn :
('d, 'k) Arkode.ARKStep.session -> 'd stability_fn -> unit
val clear_stability_fn : ('d, 'k) Arkode.ARKStep.session -> unit
val set_linear : ('d, 'k) Arkode.ARKStep.session -> bool -> unit
val set_nonlinear : ('d, 'k) Arkode.ARKStep.session -> unit
val set_predictor_method :
('d, 'k) Arkode.ARKStep.session -> predictor_method -> unit
val set_max_nonlin_iters :
('d, 'k) Arkode.ARKStep.session -> int -> unit
val set_max_conv_fails : ('d, 'k) Arkode.ARKStep.session -> int -> unit
type 'd stage_predict_fn = float -> 'd -> unit
val set_stage_predict_fn :
('d, 'k) Arkode.ARKStep.session ->
'd Arkode.ARKStep.stage_predict_fn -> unit
val clear_stage_predict_fn : ('d, 'k) Arkode.ARKStep.session -> unit
val set_nonlin_conv_coef :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_constraints :
('d, 'k) Arkode.ARKStep.session -> ('d, 'k) Nvector.t -> unit
val set_nonlin_crdown :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_nonlin_rdiv : ('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_delta_gamma_max :
('d, 'k) Arkode.ARKStep.session -> float -> unit
val set_lsetup_frequency :
('d, 'k) Arkode.ARKStep.session -> int -> unit
val set_postprocess_step_fn :
('d, 'k) Arkode.ARKStep.session -> 'd postprocess_step_fn -> unit
val clear_postprocess_step_fn : ('d, 'k) Arkode.ARKStep.session -> unit
val get_work_space : ('d, 'k) Arkode.ARKStep.session -> int * int
val get_num_steps : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_exp_steps : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_acc_steps : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_step_attempts : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_rhs_evals : ('d, 'k) Arkode.ARKStep.session -> int * int
val get_num_err_test_fails : ('d, 'k) Arkode.ARKStep.session -> int
val get_last_step : ('d, 'k) Arkode.ARKStep.session -> float
val get_current_step : ('d, 'k) Arkode.ARKStep.session -> float
val get_actual_init_step : ('d, 'k) Arkode.ARKStep.session -> float
val get_current_time : ('d, 'k) Arkode.ARKStep.session -> float
val get_current_state : ('d, 'k) Arkode.ARKStep.session -> 'd
val get_nonlin_system_data :
('d, 'k) Arkode.ARKStep.session -> 'd nonlin_system_data
val compute_state :
('d, 'k) Arkode.ARKStep.session ->
('d, 'k) Nvector.t -> ('d, 'k) Nvector.t -> unit
val get_current_gamma : ('d, 'k) Arkode.ARKStep.session -> float
val get_current_butcher_tables :
('d, 'k) Arkode.ARKStep.session ->
Arkode.ButcherTable.t option * Arkode.ButcherTable.t option
val get_tol_scale_factor : ('d, 'k) Arkode.ARKStep.session -> float
val get_err_weights :
('d, 'k) Arkode.ARKStep.session -> ('d, 'k) Nvector.t -> unit
val get_res_weights :
('d, 'k) Arkode.ARKStep.session -> ('d, 'k) Nvector.t -> unit
val get_est_local_errors :
('d, 'k) Arkode.ARKStep.session -> ('d, 'k) Nvector.t -> unit
type timestepper_stats = {
exp_steps : int;
acc_steps : int;
step_attempts : int;
num_nfe_evals : int;
num_nfi_evals : int;
num_lin_solv_setups : int;
num_err_test_fails : int;
}
val get_timestepper_stats :
('d, 'k) Arkode.ARKStep.session -> Arkode.ARKStep.timestepper_stats
val get_step_stats : ('d, 'k) Arkode.ARKStep.session -> step_stats
val print_timestepper_stats :
('d, 'k) Arkode.ARKStep.session -> Stdlib.out_channel -> unit
val print_step_stats :
('d, 'k) Arkode.ARKStep.session -> Stdlib.out_channel -> unit
val write_session :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.ARKStep.session -> unit
val get_num_lin_solv_setups : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_nonlin_solv_iters : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_nonlin_solv_conv_fails :
('d, 'k) Arkode.ARKStep.session -> int
val get_nonlin_solv_stats :
('d, 'k) Arkode.ARKStep.session -> int * int
val set_root_direction :
('d, 'k) Arkode.ARKStep.session -> Sundials.RootDirs.d array -> unit
val set_all_root_directions :
('d, 'k) Arkode.ARKStep.session -> Sundials.RootDirs.d -> unit
val set_no_inactive_root_warn : ('d, 'k) Arkode.ARKStep.session -> unit
val get_num_roots : ('d, 'k) Arkode.ARKStep.session -> int
val get_root_info :
('d, 'k) Arkode.ARKStep.session -> Sundials.Roots.t -> unit
val get_num_g_evals : ('d, 'k) Arkode.ARKStep.session -> int
val get_num_constr_fails : ('d, 'k) Arkode.ARKStep.session -> int
val write_parameters :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.ARKStep.session -> unit
val write_butcher :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.ARKStep.session -> unit
end
module ERKStep :
sig
type solver_result = Success | RootsFound | StopTimeReached
type step_stats = {
num_steps : int;
actual_init_step : float;
last_step : float;
current_step : float;
current_time : float;
}
type interpolant_type = Hermite | Lagrange
type linearity = Linear of bool | Nonlinear
type 'data error_weight_fun = 'data -> 'data -> unit
type ('data, 'kind) tolerance =
SStolerances of float * float
| SVtolerances of float * ('data, 'kind) Nvector.t
| WFtolerances of 'data error_weight_fun
val default_tolerances : ('data, 'kind) tolerance
type predictor_method =
TrivialPredictor
| MaximumOrderPredictor
| VariableOrderPredictor
| CutoffOrderPredictor
type 'd nonlin_system_data = {
tcur : float;
zpred : 'd;
zi : 'd;
fi : 'd;
gamma : float;
sdata : 'd;
}
type 'd rootsfn = float -> 'd -> Sundials.RealArray.t -> unit
val no_roots : int * 'd rootsfn
type adaptivity_args = {
h1 : float;
h2 : float;
h3 : float;
e1 : float;
e2 : float;
e3 : float;
q : int;
p : int;
}
type 'd adaptivity_fn = float -> 'd -> adaptivity_args -> float
type adaptivity_params = {
ks : (float * float * float) option;
method_order : bool;
}
type 'd adaptivity_method =
PIDcontroller of adaptivity_params
| PIcontroller of adaptivity_params
| Icontroller of adaptivity_params
| ExplicitGustafsson of adaptivity_params
| ImplicitGustafsson of adaptivity_params
| ImExGustafsson of adaptivity_params
| AdaptivityFn of 'd adaptivity_fn
type 'd rhsfn = float -> 'd -> 'd -> unit
type 'd stability_fn = float -> 'd -> float
type 'd resize_fn = 'd -> 'd -> unit
type 'd postprocess_step_fn = float -> 'd -> unit
type 'd triple = 'd * 'd * 'd
type ('t, 'd) jacobian_arg =
('t, 'd) Arkode_impl.jacobian_arg = {
jac_t : float;
jac_y : 'd;
jac_fy : 'd;
jac_tmp : 't;
}
type ('d, 'k) session = ('d, 'k, Arkode.erkstep) Arkode_impl.session
val init :
?context:Sundials.Context.t ->
('data, 'kind) tolerance ->
?order:int ->
'data rhsfn ->
?roots:int * 'data rootsfn ->
float ->
('data, 'kind) Nvector.t -> ('data, 'kind) Arkode.ERKStep.session
val evolve_normal :
('d, 'k) Arkode.ERKStep.session ->
float -> ('d, 'k) Nvector.t -> float * solver_result
val evolve_one_step :
('d, 'k) Arkode.ERKStep.session ->
float -> ('d, 'k) Nvector.t -> float * solver_result
val get_dky :
('d, 'k) Arkode.ERKStep.session ->
('d, 'k) Nvector.t -> float -> int -> unit
val reinit :
('d, 'k) Arkode.ERKStep.session ->
?order:int ->
?roots:int * 'd rootsfn -> float -> ('d, 'k) Nvector.t -> unit
val reset :
('d, 'k) Arkode.ERKStep.session -> float -> ('d, 'k) Nvector.t
val resize :
('d, 'k) Arkode.ERKStep.session ->
?resize_nvec:'d resize_fn ->
('d, 'k) tolerance -> float -> ('d, 'k) Nvector.t -> float -> unit
val set_tolerances :
('d, 'k) Arkode.ERKStep.session -> ('d, 'k) tolerance -> unit
val set_defaults : ('d, 'k) Arkode.ERKStep.session -> unit
val set_diagnostics :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.ERKStep.session -> unit
val set_interpolant_type :
('d, 'k) Arkode.ERKStep.session -> interpolant_type -> unit
val set_interpolant_degree :
('d, 'k) Arkode.ERKStep.session -> int -> unit
val clear_diagnostics : ('d, 'k) Arkode.ERKStep.session -> unit
val set_error_file :
('d, 'k) Arkode.ERKStep.session -> Sundials.Logfile.t -> unit
val set_err_handler_fn :
('d, 'k) Arkode.ERKStep.session ->
(Sundials.Util.error_details -> unit) -> unit
val clear_err_handler_fn : ('d, 'k) Arkode.ERKStep.session -> unit
val set_init_step : ('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_fixed_step :
('d, 'k) Arkode.ERKStep.session -> float option -> unit
val set_max_num_constr_fails :
('d, 'k) Arkode.ERKStep.session -> int -> unit
val set_max_hnil_warns : ('d, 'k) Arkode.ERKStep.session -> int -> unit
val set_max_num_steps : ('d, 'k) Arkode.ERKStep.session -> int -> unit
val set_max_err_test_fails :
('d, 'k) Arkode.ERKStep.session -> int -> unit
val set_min_step : ('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_max_step : ('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_stop_time : ('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_table :
('d, 'k) Arkode.ERKStep.session -> Arkode.ButcherTable.t -> unit
val set_table_num :
('d, 'k) Arkode.ERKStep.session ->
Arkode.ButcherTable.erk_table -> unit
val set_adaptivity_method :
('d, 'k) Arkode.ERKStep.session -> 'd adaptivity_method -> unit
val set_cfl_fraction : ('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_error_bias : ('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_fixed_step_bounds :
('d, 'k) Arkode.ERKStep.session -> float -> float -> unit
val set_max_efail_growth :
('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_max_first_growth :
('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_max_growth : ('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_min_reduction :
('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_safety_factor :
('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_small_num_efails :
('d, 'k) Arkode.ERKStep.session -> float -> unit
val set_stability_fn :
('d, 'k) Arkode.ERKStep.session -> 'd stability_fn -> unit
val clear_stability_fn : ('d, 'k) Arkode.ERKStep.session -> unit
val set_postprocess_step_fn :
('d, 'k) Arkode.ERKStep.session -> 'd postprocess_step_fn -> unit
val clear_postprocess_step_fn : ('d, 'k) Arkode.ERKStep.session -> unit
val set_constraints :
('d, 'k) Arkode.ERKStep.session -> ('d, 'k) Nvector.t -> unit
val get_work_space : ('d, 'k) Arkode.ERKStep.session -> int * int
val get_num_steps : ('d, 'k) Arkode.ERKStep.session -> int
val get_num_exp_steps : ('d, 'k) Arkode.ERKStep.session -> int
val get_num_acc_steps : ('d, 'k) Arkode.ERKStep.session -> int
val get_num_step_attempts : ('d, 'k) Arkode.ERKStep.session -> int
val get_num_rhs_evals : ('d, 'k) Arkode.ERKStep.session -> int
val get_num_err_test_fails : ('d, 'k) Arkode.ERKStep.session -> int
val get_last_step : ('d, 'k) Arkode.ERKStep.session -> float
val get_current_step : ('d, 'k) Arkode.ERKStep.session -> float
val get_actual_init_step : ('d, 'k) Arkode.ERKStep.session -> float
val get_current_time : ('d, 'k) Arkode.ERKStep.session -> float
val get_current_butcher_table :
('d, 'k) Arkode.ERKStep.session -> Arkode.ButcherTable.t
val get_tol_scale_factor : ('d, 'k) Arkode.ERKStep.session -> float
val get_err_weights :
('d, 'k) Arkode.ERKStep.session -> ('d, 'k) Nvector.t -> unit
val get_est_local_errors :
('d, 'k) Arkode.ERKStep.session -> ('d, 'k) Nvector.t -> unit
type timestepper_stats = {
exp_steps : int;
acc_steps : int;
step_attempts : int;
num_nf_evals : int;
num_err_test_fails : int;
}
val get_timestepper_stats :
('d, 'k) Arkode.ERKStep.session -> Arkode.ERKStep.timestepper_stats
val get_step_stats : ('d, 'k) Arkode.ERKStep.session -> step_stats
val print_timestepper_stats :
('d, 'k) Arkode.ERKStep.session -> Stdlib.out_channel -> unit
val print_step_stats :
('d, 'k) Arkode.ERKStep.session -> Stdlib.out_channel -> unit
val write_session :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.ERKStep.session -> unit
val set_root_direction :
('d, 'k) Arkode.ERKStep.session -> Sundials.RootDirs.d array -> unit
val set_all_root_directions :
('d, 'k) Arkode.ERKStep.session -> Sundials.RootDirs.d -> unit
val set_no_inactive_root_warn : ('d, 'k) Arkode.ERKStep.session -> unit
val get_num_roots : ('d, 'k) Arkode.ERKStep.session -> int
val get_root_info :
('d, 'k) Arkode.ERKStep.session -> Sundials.Roots.t -> unit
val get_num_g_evals : ('d, 'k) Arkode.ERKStep.session -> int
val get_num_constr_fails : ('d, 'k) Arkode.ERKStep.session -> int
val write_parameters :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.ERKStep.session -> unit
val write_butcher :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.ERKStep.session -> unit
end
module MRIStep :
sig
type solver_result = Success | RootsFound | StopTimeReached
type step_stats = {
num_steps : int;
actual_init_step : float;
last_step : float;
current_step : float;
current_time : float;
}
type interpolant_type = Hermite | Lagrange
type linearity = Linear of bool | Nonlinear
type 'data error_weight_fun = 'data -> 'data -> unit
type ('data, 'kind) tolerance =
SStolerances of float * float
| SVtolerances of float * ('data, 'kind) Nvector.t
| WFtolerances of 'data error_weight_fun
val default_tolerances : ('data, 'kind) tolerance
type predictor_method =
TrivialPredictor
| MaximumOrderPredictor
| VariableOrderPredictor
| CutoffOrderPredictor
type 'd nonlin_system_data = {
tcur : float;
zpred : 'd;
zi : 'd;
fi : 'd;
gamma : float;
sdata : 'd;
}
type 'd rootsfn = float -> 'd -> Sundials.RealArray.t -> unit
val no_roots : int * 'd rootsfn
type adaptivity_args = {
h1 : float;
h2 : float;
h3 : float;
e1 : float;
e2 : float;
e3 : float;
q : int;
p : int;
}
type 'd adaptivity_fn = float -> 'd -> adaptivity_args -> float
type adaptivity_params = {
ks : (float * float * float) option;
method_order : bool;
}
type 'd adaptivity_method =
PIDcontroller of adaptivity_params
| PIcontroller of adaptivity_params
| Icontroller of adaptivity_params
| ExplicitGustafsson of adaptivity_params
| ImplicitGustafsson of adaptivity_params
| ImExGustafsson of adaptivity_params
| AdaptivityFn of 'd adaptivity_fn
type 'd rhsfn = float -> 'd -> 'd -> unit
type 'd stability_fn = float -> 'd -> float
type 'd resize_fn = 'd -> 'd -> unit
type 'd postprocess_step_fn = float -> 'd -> unit
type 'd triple = 'd * 'd * 'd
type ('t, 'd) jacobian_arg =
('t, 'd) Arkode_impl.jacobian_arg = {
jac_t : float;
jac_y : 'd;
jac_fy : 'd;
jac_tmp : 't;
}
type ('d, 'k) session = ('d, 'k, Arkode.mristep) Arkode_impl.session
type 'a serial_session =
(Nvector_serial.data, 'a) Arkode.MRIStep.session
constraint 'a = [> Nvector_serial.kind ]
type ('data, 'kind) linear_solver
type 'a serial_linear_solver =
(Nvector_serial.data, 'a) Arkode.MRIStep.linear_solver
constraint 'a = [> Nvector_serial.kind ]
module Dls :
sig
val dense :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.dense ->
(Sundials.Matrix.Dense.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
val lapack_dense :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.dense ->
(Sundials.Matrix.Dense.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
val band :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.band ->
(Sundials.Matrix.Band.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
val lapack_band :
?context:Sundials.Context.t ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
'a Sundials.Matrix.band ->
(Sundials.Matrix.Band.t, 'a, [ `Dls ])
Sundials_LinearSolver.serial_t
module Klu :
sig
type ordering =
Sundials_LinearSolver_impl.Klu.ordering =
Amd
| ColAmd
| Natural
val make :
?context:Sundials.Context.t ->
?ordering:ordering ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [ `Dls | `Klu ])
Sundials_LinearSolver.serial_t
val reinit :
('s Sundials.Matrix.Sparse.t, [> Nvector_serial.kind ] as 'a,
[> `Klu ])
Sundials_LinearSolver.serial_t ->
('s, 'a) Sundials.Matrix.sparse -> ?nnz:int -> unit -> unit
val set_ordering :
('s Sundials.Matrix.Sparse.t, [> Nvector_serial.kind ],
[> `Klu ])
Sundials_LinearSolver.serial_t -> ordering -> unit
end
val klu :
?context:Sundials.Context.t ->
?ordering:Klu.ordering ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [ `Dls | `Klu ])
Sundials_LinearSolver.serial_t
module Superlumt :
sig
type ordering =
Sundials_LinearSolver_impl.Superlumt.ordering =
Natural
| MinDegreeProd
| MinDegreeSum
| ColAmd
val make :
?context:Sundials.Context.t ->
?ordering:ordering ->
nthreads:int ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [ `Dls | `Slu ])
Sundials_LinearSolver.serial_t
val set_ordering :
('s Sundials.Matrix.Sparse.t, [> Nvector_serial.kind ],
[> `Slu ])
Sundials_LinearSolver.serial_t -> ordering -> unit
end
val superlumt :
?context:Sundials.Context.t ->
?ordering:Superlumt.ordering ->
nthreads:int ->
([> Nvector_serial.kind ] as 'a) Nvector.serial ->
('s, 'a) Sundials.Matrix.sparse ->
('s Sundials.Matrix.Sparse.t, 'a, [> `Dls | `Slu ])
Sundials_LinearSolver.serial_t
type 'm jac_fn =
(Sundials.RealArray.t Common.triple, Sundials.RealArray.t)
Common.jacobian_arg -> 'm -> unit
type 'm linsys_fn =
(Sundials.RealArray.t Common.triple, Sundials.RealArray.t)
Common.jacobian_arg -> 'm -> 'm option -> bool -> float -> bool
val solver :
?jac:'m jac_fn ->
?linsys:'m linsys_fn ->
('m, Sundials.RealArray.t, [> Nvector_serial.kind ] as 'a,
[> `Dls ])
Sundials.LinearSolver.t -> 'a Arkode.MRIStep.serial_linear_solver
val get_work_space :
[> Nvector_serial.kind ] Arkode.MRIStep.serial_session ->
int * int
val get_num_jac_evals :
[> Nvector_serial.kind ] Arkode.MRIStep.serial_session -> int
val get_num_lin_rhs_evals :
[> Nvector_serial.kind ] Arkode.MRIStep.serial_session -> int
end
module Spils :
sig
type gramschmidt_type =
Sundials_LinearSolver_impl.Iterative.gramschmidt_type =
ModifiedGS
| ClassicalGS
val spbcgs :
?context:Sundials.Context.t ->
?maxl:int ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Spbcgs ]) Sundials_LinearSolver.t
val spfgmr :
?context:Sundials.Context.t ->
?maxl:int ->
?max_restarts:int ->
?gs_type:gramschmidt_type ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Spfgmr ]) Sundials_LinearSolver.t
val spgmr :
?context:Sundials.Context.t ->
?maxl:int ->
?max_restarts:int ->
?gs_type:gramschmidt_type ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Spgmr ]) Sundials_LinearSolver.t
val sptfqmr :
?context:Sundials.Context.t ->
?maxl:int ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Sptfqmr ]) Sundials_LinearSolver.t
val pcg :
?context:Sundials.Context.t ->
?maxl:int ->
('d, 'k) Nvector.t ->
('m, 'd, 'k, [ `Iter | `Pcg ]) Sundials_LinearSolver.t
module Algorithms :
sig
val qr_fact :
int ->
Sundials.RealArray2.t -> Sundials.RealArray.t -> bool -> unit
val qr_sol :
int ->
Sundials.RealArray2.t ->
Sundials.RealArray.t -> Sundials.RealArray.t -> unit
val modified_gs :
('d, 'k) Nvector.t array ->
Sundials.RealArray2.t -> int -> int -> float
val classical_gs :
('d, 'k) Nvector.t array ->
Sundials.RealArray2.t ->
int ->
int ->
Sundials.RealArray.t -> ('d, 'k) Nvector.t array -> float
end
val set_maxl :
('m, 'd, 'k, [< `Iter | `Pcg | `Spbcgs | `Sptfqmr ])
Sundials_LinearSolver.t -> int -> unit
val set_gs_type :
('m, 'd, 'k, [< `Iter | `Spfgmr | `Spgmr ])
Sundials_LinearSolver.t -> gramschmidt_type -> unit
val set_max_restarts :
('m, 'd, 'k, [< `Iter | `Spfgmr | `Spgmr ])
Sundials_LinearSolver.t -> int -> unit
type preconditioning_type =
Sundials_LinearSolver_impl.Iterative.preconditioning_type =
PrecNone
| PrecLeft
| PrecRight
| PrecBoth
val set_prec_type :
('m, 'd, 'k, [> `Iter ]) Sundials_LinearSolver.t ->
preconditioning_type -> unit
val set_info_file :
('m, 'd, 'k, [> `Iter ]) Sundials_LinearSolver.t ->
?print_level:bool -> Sundials.Logfile.t -> unit
val set_print_level :
('m, 'd, 'k, [> `Iter ]) Sundials_LinearSolver.t -> bool -> unit
type 'd prec_solve_arg = {
rhs : 'd;
gamma : float;
delta : float;
left : bool;
}
type 'd prec_solve_fn =
(unit, 'd) Common.jacobian_arg ->
'd prec_solve_arg -> 'd -> unit
type 'd prec_setup_fn =
(unit, 'd) Common.jacobian_arg -> bool -> float -> bool
type ('d, 'k, 's) preconditioner =
('d, 'k, 's) Arkode_impl.SpilsTypes.preconditioner
module Banded :
sig
type bandrange = { mupper : int; mlower : int; }
val prec_left :
bandrange ->
(Nvector_serial.data, [> Nvector_serial.kind ], 's)
preconditioner
val prec_right :
bandrange ->
(Nvector_serial.data, [> Nvector_serial.kind ], 's)
preconditioner
val prec_both :
bandrange ->
(Nvector_serial.data, [> Nvector_serial.kind ], 's)
preconditioner
type ('a, 'b) serial_session =
(Nvector_serial.data, 'a, 'b) Arkode_impl.session
constraint 'a = [> Nvector_serial.kind ]
constraint 'b = [< `ARKStep | `MRIStep ]
val get_work_space :
([> Nvector_serial.kind ], [< `ARKStep | `MRIStep ])
serial_session -> int * int
val get_num_rhs_evals :
([> Nvector_serial.kind ], [< `ARKStep | `MRIStep ])
serial_session -> int
end
type 'd jac_times_setup_fn = (unit, 'd) Common.jacobian_arg -> unit
type 'd jac_times_vec_fn =
('d, 'd) Common.jacobian_arg -> 'd -> 'd -> unit
val prec_none : ('d, 'k, Arkode.mristep) preconditioner
val prec_left :
?setup:'d prec_setup_fn ->
'd prec_solve_fn -> ('d, 'k, Arkode.mristep) preconditioner
val prec_right :
?setup:'d prec_setup_fn ->
'd prec_solve_fn -> ('d, 'k, Arkode.mristep) preconditioner
val prec_both :
?setup:'d prec_setup_fn ->
'd prec_solve_fn -> ('d, 'k, Arkode.mristep) preconditioner
val solver :
('m, 'd, 'k, [> `Iter ]) Sundials.LinearSolver.t ->
?jac_times_vec:'d jac_times_setup_fn option * 'd jac_times_vec_fn ->
?jac_times_rhs:'d rhsfn ->
('d, 'k, Arkode.mristep) preconditioner ->
('d, 'k) Arkode.MRIStep.linear_solver
val set_jac_eval_frequency :
('d, 'k) Arkode.MRIStep.session -> int -> unit
val set_linear_solution_scaling :
('d, 'k) Arkode.MRIStep.session -> bool -> unit
val set_eps_lin : ('d, 'k) Arkode.MRIStep.session -> float -> unit
val set_ls_norm_factor :
('d, 'k) Arkode.MRIStep.session -> float -> unit
val get_work_space : ('d, 'k) Arkode.MRIStep.session -> int * int
val get_num_lin_iters : ('d, 'k) Arkode.MRIStep.session -> int
val get_num_lin_conv_fails : ('d, 'k) Arkode.MRIStep.session -> int
val get_num_prec_evals : ('d, 'k) Arkode.MRIStep.session -> int
val get_num_prec_solves : ('d, 'k) Arkode.MRIStep.session -> int
val get_num_jtsetup_evals : ('d, 'k) Arkode.MRIStep.session -> int
val get_num_jtimes_evals : ('d, 'k) Arkode.MRIStep.session -> int
val get_num_lin_rhs_evals : ('d, 'k) Arkode.MRIStep.session -> int
val set_preconditioner :
('d, 'k) Arkode.MRIStep.session ->
?setup:'d prec_setup_fn -> 'd prec_solve_fn -> unit
val set_jac_times :
('d, 'k) Arkode.MRIStep.session ->
?jac_times_setup:'d jac_times_setup_fn ->
'd jac_times_vec_fn -> unit
val clear_jac_times : ('d, 'k) Arkode.MRIStep.session -> unit
end
val matrix_embedded_solver :
(unit, 'data, 'kind, [> `MatE ]) Sundials.LinearSolver.t ->
('data, 'kind) Arkode.MRIStep.linear_solver
module InnerStepper :
sig
type ('d, 'k) t = ('d, 'k) Arkode_impl.inner_stepper
val from_arkstep :
('d, 'k) Arkode.ARKStep.session ->
('d, 'k) Arkode.MRIStep.InnerStepper.t
type 'd evolvefn = float -> float -> 'd -> unit
type fullrhs_mode = Arkode_impl.fullrhs_mode = Start | End | Other
type 'd full_rhsfn =
float ->
'd -> 'd -> Arkode.MRIStep.InnerStepper.fullrhs_mode -> unit
type 'd resetfn = float -> 'd -> unit
val make :
?context:Sundials.Context.t ->
evolve_fn:'d Arkode.MRIStep.InnerStepper.evolvefn ->
full_rhs_fn:'d Arkode.MRIStep.InnerStepper.full_rhsfn ->
?reset_fn:'d Arkode.MRIStep.InnerStepper.resetfn ->
unit -> ('d, 'k) Arkode.MRIStep.InnerStepper.t
val add_forcing :
('d, 'k) Arkode.MRIStep.InnerStepper.t ->
float -> ('d, 'k) Nvector.t -> unit
type 'd forcing_data = {
tshift : float;
tscale : float;
forcing : 'd array;
}
val get_forcing_data :
('d, 'k) Arkode.MRIStep.InnerStepper.t ->
'd Arkode.MRIStep.InnerStepper.forcing_data
end
module Coupling :
sig
type t
val nmat : Arkode.MRIStep.Coupling.t -> int
val stages : Arkode.MRIStep.Coupling.t -> int
val method_order : Arkode.MRIStep.Coupling.t -> int
val embedding_order : Arkode.MRIStep.Coupling.t -> int
val explicit_coupling_matrices :
Arkode.MRIStep.Coupling.t ->
Sundials.RealArray.t array array option
val implicit_coupling_matrices :
Arkode.MRIStep.Coupling.t ->
Sundials.RealArray.t array array option
val abscissae : Arkode.MRIStep.Coupling.t -> Sundials.RealArray.t
val make :
method_order:int ->
embedding_order:int ->
?explicit:Sundials.RealArray.t array array ->
?implicit:Sundials.RealArray.t array array ->
Sundials.RealArray.t -> Arkode.MRIStep.Coupling.t
type coupling_table =
KW3
| GARK_ERK33a
| GARK_ERK45a
| GARK_IRK21a
| GARK_ESDIRK34a
| GARK_ESDIRK46a
| IMEX_GARK3a
| IMEX_GARK3b
| IMEX_GARK4
val load_table :
Arkode.MRIStep.Coupling.coupling_table ->
Arkode.MRIStep.Coupling.t
val mis_to_mri :
method_order:int ->
embedding_order:int ->
Arkode.ButcherTable.t -> Arkode.MRIStep.Coupling.t
val copy : Arkode.MRIStep.Coupling.t -> Arkode.MRIStep.Coupling.t
val space : Arkode.MRIStep.Coupling.t -> int * int
val write :
?logfile:Sundials.Logfile.t -> Arkode.MRIStep.Coupling.t -> unit
end
type ('d, 'k) problem
val implicit :
?nlsolver:('data, 'kind, ('data, 'kind) Arkode.MRIStep.session,
[ `Nvec ])
Sundials_NonlinearSolver.t ->
?nlsrhsfn:'data rhsfn ->
?lsolver:('data, 'kind) Arkode.MRIStep.linear_solver ->
?linearity:linearity ->
'data rhsfn -> ('data, 'kind) Arkode.MRIStep.problem
val explicit : 'data rhsfn -> ('data, 'kind) Arkode.MRIStep.problem
val imex :
?nlsolver:('data, 'kind, ('data, 'kind) Arkode.MRIStep.session,
[ `Nvec ])
Sundials_NonlinearSolver.t ->
?nlsrhsfn:'data rhsfn ->
?lsolver:('data, 'kind) Arkode.MRIStep.linear_solver ->
?linearity:linearity ->
fsi:'data rhsfn ->
fse:'data rhsfn -> unit -> ('data, 'kind) Arkode.MRIStep.problem
val init :
?context:Sundials.Context.t ->
('data, 'kind) Arkode.MRIStep.problem ->
('data, 'kind) tolerance ->
('data, 'kind) Arkode.MRIStep.InnerStepper.t ->
?coupling:Arkode.MRIStep.Coupling.t ->
slowstep:float ->
?roots:int * 'data rootsfn ->
float ->
('data, 'kind) Nvector.t -> ('data, 'kind) Arkode.MRIStep.session
val evolve_normal :
('d, 'k) Arkode.MRIStep.session ->
float -> ('d, 'k) Nvector.t -> float * solver_result
val evolve_one_step :
('d, 'k) Arkode.MRIStep.session ->
float -> ('d, 'k) Nvector.t -> float * solver_result
val get_dky :
('d, 'k) Arkode.MRIStep.session ->
('d, 'k) Nvector.t -> float -> int -> unit
val reinit :
('d, 'k) Arkode.MRIStep.session ->
?problem:('d, 'k) Arkode.MRIStep.problem ->
?roots:int * 'd rootsfn -> float -> ('d, 'k) Nvector.t -> unit
val reset :
('d, 'k) Arkode.MRIStep.session -> float -> ('d, 'k) Nvector.t
val resize :
('d, 'k) Arkode.MRIStep.session ->
?resize_nvec:'d resize_fn -> ('d, 'k) Nvector.t -> float -> unit
val set_defaults : ('d, 'k) Arkode.MRIStep.session -> unit
val set_interpolant_type :
('d, 'k) Arkode.MRIStep.session -> interpolant_type -> unit
val set_interpolant_degree :
('d, 'k) Arkode.MRIStep.session -> int -> unit
val set_diagnostics :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.MRIStep.session -> unit
val clear_diagnostics : ('d, 'k) Arkode.MRIStep.session -> unit
val set_error_file :
('d, 'k) Arkode.MRIStep.session -> Sundials.Logfile.t -> unit
val set_err_handler_fn :
('d, 'k) Arkode.MRIStep.session ->
(Sundials.Util.error_details -> unit) -> unit
val clear_err_handler_fn : ('d, 'k) Arkode.MRIStep.session -> unit
val set_fixed_step : ('d, 'k) Arkode.MRIStep.session -> float -> unit
val set_max_hnil_warns : ('d, 'k) Arkode.MRIStep.session -> int -> unit
val set_max_num_steps : ('d, 'k) Arkode.MRIStep.session -> int -> unit
val set_stop_time : ('d, 'k) Arkode.MRIStep.session -> float -> unit
type 'd pre_inner_fn = float -> 'd array -> unit
val set_pre_inner_fn :
('d, 'k) Arkode.MRIStep.session ->
'd Arkode.MRIStep.pre_inner_fn -> unit
val clear_pre_inner_fn : ('d, 'k) Arkode.MRIStep.session -> unit
type 'd post_inner_fn = float -> 'd -> unit
val set_post_inner_fn :
('d, 'k) Arkode.MRIStep.session ->
'd Arkode.MRIStep.post_inner_fn -> unit
val clear_post_inner_fn : ('d, 'k) Arkode.MRIStep.session -> unit
val set_postprocess_step_fn :
('d, 'k) Arkode.MRIStep.session -> 'd postprocess_step_fn -> unit
val clear_postprocess_step_fn : ('d, 'k) Arkode.MRIStep.session -> unit
type 'd stage_predict_fn = float -> 'd -> unit
val set_stage_predict_fn :
('d, 'k) Arkode.MRIStep.session ->
'd Arkode.MRIStep.stage_predict_fn -> unit
val clear_stage_predict_fn : ('d, 'k) Arkode.MRIStep.session -> unit
val set_nonlin_conv_coef :
('d, 'k) Arkode.MRIStep.session -> float -> unit
val set_nonlin_crdown :
('d, 'k) Arkode.MRIStep.session -> float -> unit
val set_nonlin_rdiv : ('d, 'k) Arkode.MRIStep.session -> float -> unit
val set_delta_gamma_max :
('d, 'k) Arkode.MRIStep.session -> float -> unit
val set_lsetup_frequency :
('d, 'k) Arkode.MRIStep.session -> int -> unit
val set_linear : ('d, 'k) Arkode.MRIStep.session -> bool -> unit
val set_nonlinear : ('d, 'k) Arkode.MRIStep.session -> unit
val set_predictor_method :
('d, 'k) Arkode.MRIStep.session -> predictor_method -> unit
val set_max_nonlin_iters :
('d, 'k) Arkode.MRIStep.session -> int -> unit
val get_work_space : ('d, 'k) Arkode.MRIStep.session -> int * int
val get_num_steps : ('d, 'k) Arkode.MRIStep.session -> int
val get_last_step : ('d, 'k) Arkode.MRIStep.session -> float
val get_num_rhs_evals : ('d, 'k) Arkode.MRIStep.session -> int * int
val get_current_time : ('d, 'k) Arkode.MRIStep.session -> float
val get_current_state : ('d, 'k) Arkode.MRIStep.session -> 'd
val get_current_coupling :
('d, 'k) Arkode.MRIStep.session -> Arkode.MRIStep.Coupling.t
val write_coupling :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.MRIStep.session -> unit
val get_nonlin_system_data :
('d, 'k) Arkode.MRIStep.session -> 'd nonlin_system_data
val compute_state :
('d, 'k) Arkode.MRIStep.session ->
('d, 'k) Nvector.t -> ('d, 'k) Nvector.t -> unit
val get_current_gamma : ('d, 'k) Arkode.MRIStep.session -> float
val get_tol_scale_factor : ('d, 'k) Arkode.MRIStep.session -> float
val get_err_weights :
('d, 'k) Arkode.MRIStep.session -> ('d, 'k) Nvector.t -> unit
val get_num_lin_solv_setups : ('d, 'k) Arkode.MRIStep.session -> int
val get_num_nonlin_solv_iters : ('d, 'k) Arkode.MRIStep.session -> int
val get_num_nonlin_solv_conv_fails :
('d, 'k) Arkode.MRIStep.session -> int
val get_nonlin_solv_stats :
('d, 'k) Arkode.MRIStep.session -> int * int
val write_session :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.MRIStep.session -> unit
val set_root_direction :
('d, 'k) Arkode.MRIStep.session -> Sundials.RootDirs.d array -> unit
val set_all_root_directions :
('d, 'k) Arkode.MRIStep.session -> Sundials.RootDirs.d -> unit
val set_no_inactive_root_warn : ('d, 'k) Arkode.MRIStep.session -> unit
val get_num_roots : ('d, 'k) Arkode.MRIStep.session -> int
val get_root_info :
('d, 'k) Arkode.MRIStep.session -> Sundials.Roots.t -> unit
val get_num_g_evals : ('d, 'k) Arkode.MRIStep.session -> int
val write_parameters :
?logfile:Sundials.Logfile.t ->
('d, 'k) Arkode.MRIStep.session -> unit
end
exception IllInput
exception TooClose
exception TooMuchWork
exception TooMuchAccuracy
exception InnerStepFail of exn option
exception ErrFailure
exception ConvergenceFailure
exception LinearInitFailure
exception LinearSetupFailure of exn option
exception LinearSolveFailure of exn option
exception MassInitFailure
exception MassSetupFailure of exn option
exception MassSolveFailure of exn option
exception MassMultFailure
exception RhsFuncFailure
exception FirstRhsFuncFailure
exception RepeatedRhsFuncFailure
exception UnrecoverableRhsFuncFailure
exception NonlinearInitFailure
exception NonlinearSetupFailure
exception NonlinearSetupRecoverable
exception NonlinearOperationError
exception RootFuncFailure
exception PostprocStepFailure
exception BadK
exception BadT
exception VectorOpErr
end