package owl-ode

You can search for identifiers within the package.

in-package search v0.2.0

package owl-ode

owl-ode
- Owl_ode
  - Common
    
    Make
    
    M
    
    Scalar
  - Native
    
    D
    
    S
  - Native_d
    
    Euler
    
    Midpoint
    
    RK23
    
    RK4
    
    RK45
  - Native_generic
    
    Make
    
    M
    
    Scalar
  - Native_s
    
    Euler
    
    Midpoint
    
    RK23
    
    RK4
    
    RK45
  - Ode
  - Symplectic
    
    D
    
    S
  - Symplectic_d
    
    Leapfrog
    
    PseudoLeapfrog
    
    Ruth3
    
    Ruth4
    
    Symplectic_Euler
  - Symplectic_generic
    
    Make
    
    M
    
    Scalar
  - Symplectic_s
    
    Leapfrog
    
    PseudoLeapfrog
    
    Ruth3
    
    Ruth4
    
    Symplectic_Euler
  - Types
    
    Solver

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Symplectic_s end

type mat = Owl_dense_matrix_s.mat

module Symplectic_Euler = Symplectic_s.Symplectic_Euler

module PseudoLeapfrog = Symplectic_s.PseudoLeapfrog

module Leapfrog = Symplectic_s.Leapfrog

module Ruth3 = Symplectic_s.Ruth3

module Ruth4 = Symplectic_s.Ruth4

val symplectic_euler : 
  (module Types.Solver
  with type f = (mat * mat) -> float -> mat
   and type solve_output = mat * mat * mat
   and type state = mat * mat
   and type step_output = (mat * mat) * float)

val leapfrog : 
  (module Types.Solver
  with type f = (mat * mat) -> float -> mat
   and type solve_output = mat * mat * mat
   and type state = mat * mat
   and type step_output = (mat * mat) * float)

val pseudoleapfrog : 
  (module Types.Solver
  with type f = (mat * mat) -> float -> mat
   and type solve_output = mat * mat * mat
   and type state = mat * mat
   and type step_output = (mat * mat) * float)

val ruth3 : 
  (module Types.Solver
  with type f = (mat * mat) -> float -> mat
   and type solve_output = mat * mat * mat
   and type state = mat * mat
   and type step_output = (mat * mat) * float)

val ruth4 : 
  (module Types.Solver
  with type f = (mat * mat) -> float -> mat
   and type solve_output = mat * mat * mat
   and type state = mat * mat
   and type step_output = (mat * mat) * float)

val to_state_array : 
  ?axis:int ->
  (int * int) ->
  mat ->
  mat ->
  mat array * mat array