module Infinitesimal: sig .. end

• calculate derivatives of functions and samples,

• calculate Serret-Frenet frames and multi-curvatures of whatever parameterized or sampled curves,

• calculate curvature of surfaces embedded in R^3,

• interpolate samples,

• calculate zeros of functions,

• calculate critical points of functions,

• calculate integrals of functions and samples,

• calculate transforms of functions and samples,

• solve ordinary differential equations,

• calculate the exponential of a real square matrix.

Conventions

Vectors are rows of scalars (float or int), of type float array or int array.

A (bidimensional) matrix is a row vector, each element of which being a row of the matrix. Matrices are of type float array array or int array array.

Warning

When using local inversion, an exception probably means that some process of local inversion passed through a critical point. The problem may arise during search of zeros or of critical points. In this case, the start point has to be changed, or some method of zero finding should differentiate up to a lower order, or some parameters have to be tuned. Sometimes diminishing the maximum number of steps might avoid the difficulty.

Sources

Most of the data and algorithms have been harvested on the internet. Among the sites, one may quote wikipedia.org about the derivatives, the ordinary differential equations, the miscellaneous transforms and http://people.sc.fsu.edu/~jburkardt and ACM algorithms http://www.netlib.org/toms/index.html about integration. For the differential calculus, much comes from E. Ramis, C. Deschamps, J. Odoux : Cours de mathématiques spéciales tome 5, Masson, Paris 1981 ; J Lelong_Ferrand, J.-M. Arnaudiès : Cours de mathématiques tome 3, Dunod, Paris. For elliptic integrals, the definitions follow V. Prasolov, Y. Solovyev : Elliptic functions and elliptic integrals, AMS mathematical monographs, Providence 1997. For the distributions, the curious reader will find a study of the links with the lambda-calculus in O. P. Misra : Distribution htoery in computer science, SCI TECH publishing, Houston 2002 ; nevertheless we limit ourselves to the definitions of L. Schwartz : Théorie des distributions, Hermann, Paris 1966.

This module is distributed under the same licence as Ocaml.

La mathématicienne ou le mathématicien trouvera dans ce module des méthodes pour :

• calculer des dérivées de fonctions et d'échantillons,

• calculer des repères de Serret-Frenet et multicourbures sur des courbes qu'elles soient paramétrées ou échantillonnées,

• interpoler des échantillons,

• calculer des points d'annulations de fonctions,

• calculer des points critiques de fonctions,

• calculer des intégrales de fonctions et d'échantillons,

• calculer des transformées de fonctions et d'échantillons,

• résoudre des équations différentielles ordinaires,

• calculer l'exponentielle d'une matrice carrée réelle.

Conventions

Les vecteurs sont des lignes de scalaires (float ou int), de type float array ou int array.

Une matrice (bidimensionnelle) est un vecteur ligne dont chaque élément est une ligne de la matrice. Les matrices sont de type float array array ou int array array.

Avertissement

En utilisant des inversions locales, une exception signifie probablement qu'un procédé d'inversion locale est passé par un point critique. Le problème peut se produire aussi pendant la recherhe d'un zéro ou d'un point critique. Dans ce cas, il faut changer le point de départ, ou prendre une méthode de recherche de zéro qui dérive moins, ou ajuster divers paramètres. Parfois, diminuer le nombre maximal de pas suffit à contourner la difficulté.

Sources

La plupart des données et algorithmes ont été glanés sur internet. Parmi les sites, on peut citer wikipedia.org concernant la dérivation, les équations différentielles ordinaires, les transformées diverses et http://people.sc.fsu.edu/~jburkardt concernant l'intégration. Pour le calcul différentiel, beaucoup provient de E. Ramis, C. Deschamps, J. Odoux : Cours de mathématiques spéciales tome 5, Masson, Paris 1981 ; J Lelong_Ferrand, J.-M. Arnaudiès : Cours de mathématiques tome 3, Dunod, Paris . Pour les intégrales elliptiques, les définitions suivent V. Prasolov, Y. Solovyev : Elliptic functions and elliptic integrals, AMS mathematical monographs, Providence 1997. Pour les distributions, le lecteur curieux trouvera une étude des liens avec le lambda-calcul dans O. P. Misra : Distribution htoery in computer science, SCI TECH publishing, Houston 2002 ; néanmoins nous nous limitons aux définitions de L. Schwartz : Théorie des distributions, Hermann, Paris 1966.

Ce module est distribué selon la même licence qu'Ocaml.

include Util

val sqrt_of_2 : float

val sqrt_of_3 : float

val sqrt_of_5 : float

val sqrt_of_6 : float

val sqrt_of_15 : float

val inv_sqrt_of_2 : float

val inv_sqrt_of_3 : float

val pi : float

val halfpi : float

val quarterpi : float

val doublepi : float

val inv_sqrt_pi : float

val inv_doublepi : float

val inv_sqrt_doublepi : float

val log_of_2 : float

val heaviside_step : float -> float

heaviside_step float

val unit_bowl_indic : float array -> float

unit_bowl_indic vector

val bowl_indic : float array -> float -> float array -> float

bowl_indic center radius vector

val float_sign : float -> float

float_sign float

val int_sign : int -> int

int_sign float

val low_stirling : float -> float

low_stirling real

val up_stirling : float -> float

up_stirling real

val stirling_bis : float -> float

stirling_bis

val half_unit_circle : float -> float

half_unit_circle float

val gauss_bell : float -> float

gauss_bell float

val sin_inv : float -> float

sin_inv float

val sinc : float -> float

sinc float

val nsinc : float -> float

nsinc float

val real_float_solve_degree_2 : float -> float -> float -> float array

real_float_solve_degree_2 a b c

val unit_circle : float -> float array

unit_circle angle

val ellipse : float -> float -> float -> float array

ellipse a b t

val hyperbola : float -> float -> float -> float array

hyperbola a b t

val polar_curve : (float -> float) -> float -> float array

polar_curve function angle

val polar_curve_bis : (float -> float) -> float -> float array

polar_curve_bis function angle

val rotating_frame : (float -> float array) -> float -> float array

rotating_frame function angle

val cycloid : float -> float -> float -> float array

cycloid rotating_radius drawing_radius time

val trochoid : float -> float -> float -> float -> float -> float -> float -> float array

trochoid big_radius signed_rotating_radius time

val epicycloid : float -> float -> float -> float array

epicycloid big_radius signed_rotating_radius time

val cardioid : float -> float array

cardioid time

val nephroid : float -> float array

nephroid time

val hypocycloid_3 : float -> float array

hypocycloid_3 time

val astroid : float -> float array

astroid time

val conic : float -> float -> float -> float array

conic excentricity parameter time

val tractrix : float -> float -> float array

tractrix parameter time

val helicoid : float -> float -> float -> float array

helicoid radius step float

val spherical_loxodromy : float -> float -> float -> float array

spherical_loxodromy radius parameter angle

val revolution_surface : (float -> float) -> float array -> float array

revolution_surface function parameters

val pseudo_sphere : float array -> float array

pseudo_sphere parameters

val cyl_coord_unit_sphere : float array -> float array

cyl_coord_unit_sphere parameters

val sph_coord_unit_sphere : float array -> float array

sph_coord_unit_sphere parameters

val cyl_coord_ellipsoid : float -> float -> float -> float array -> float array

cyl_coord_ellipsoid a b c parameters

val sph_coord_ellipsoid : float -> float -> float -> float array -> float array

sph_coord_ellipsoid a b c parameters

val graph_ellipsoid : float -> float -> float -> float array -> float

graph_ellipsoid a b c parameters

val ln : float -> float array

ln float

val log_bin : float -> float

log_bin float

f(0) = 0 ; f(0.5) = 0.5 ; |x| >= 1 ===> f( x ) = 0.

Les quatre fonctions régularisantes qui suivent sont paires. Leurs dérivées s'annulent en zéro jusqu'à l'ordre égal au nombre du nom moins un. Elles sont plates en x=1. Elles satisfont aux trois conditions précédentes.

val float_decay_16 : float -> float

float_decay_16 real

val float_decay_8 : float -> float

float_decay_8 real

val float_decay_4 : float -> float

float_decay_4 real

val float_decay_2 : float -> float

float_decay_2 real

val regular_truncature_right : (float -> float) -> float -> float -> float -> float

regular_truncature_right function cliff beach real

val regular_truncature_left : (float -> float) -> float -> float -> float -> float

regular_truncature_left function cliff beach real

val partition_of_1_table : (float -> float) -> float -> float -> float -> float -> float -> float

partition_of_1_table function left_foot left_cliff right_cliff right_foot

val partition_of_1_gap : (float -> float) -> float -> float -> float -> float -> float -> float

partition_of_1_gap function left_cliff left_bottom right_bottom right_cliff

val float_polynomial_1 : float array -> float -> float

float_polynomial_1 coefficients real

val float_polynomial_2 : float array array -> float -> float -> float

float_polynomial_2 coefficients x y

val float_rational_1 : float array -> float array -> float -> float

float_rational_1 coefficients_up coefficients_down real

val float_rational_2 : float array array -> float array array -> float -> float -> float

float_rational_2 coefficients_up coefficients_down real

val float_approx_deriv : float -> (float -> float) -> float -> float

float_approx_deriv step function float

val float_richardson_binary_deriv : int -> float -> (float -> float) -> float -> float

float_richardson_binary_deriv degree step function float

val compensated_float_richardson_binary_deriv : int -> float -> (float -> float) -> float -> float

compensated_float_richardson_binary_deriv degree step function float

val float_richardson_deriv : float -> int -> float -> (float -> float) -> float -> float

float_richardson_deriv radix degree step function real

val compensated_float_richardson_deriv : (float array -> 'a) ->
       float -> int -> float -> (float -> float) -> float -> 'a

compensated_float_richardson_deriv accelerator radix degree step function float

val vector_speed : ((float -> float) -> float -> 'a) ->
       (float -> float array) -> float -> 'a array

vector_speed methode function real

val matrix_speed : ((float -> float) -> float -> 'a) ->
       (float -> float array array) -> float -> 'a array array

matrix_speed methode function real

val acceleration : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float array

acceleration methode function float

val matrix_acceleration : ((float -> float) -> float -> float) ->
       (float -> float array array) -> float -> float array array

matrix_acceleration methode function real

val partial : int -> float array -> float -> float array

partial index vector float

val matrix_partial : int -> int -> float array array -> float -> unit

matrix_partial index vector float

val gradient : ((float -> float) -> float -> 'a) ->
       (float array -> float) -> float array -> 'a array

gradient methode function vector

val tlm : ((float -> float) -> float -> 'a) ->
       (float array -> float array) -> float array -> 'a array array

tlm methode function vector

val div : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float

div methode function vector

val det_jac : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float

det_jac methode function vector

val rot_curl : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float array

rot_curl methode function vector

val hess : ((float -> float) -> float -> float) ->
       (float array -> float) -> float array -> float array array

hess methode function vector

val float_jet : ((float -> float) -> float -> float) ->
       int -> (float -> float) -> float -> float array

float_jet methode order function

val float_poly_coeff : ((float -> float) -> float -> float) ->
       int -> (float -> float) -> float -> float array

float_poly_coeff methode order function

val vector_jet : ((float -> float) -> float -> float) ->
       int -> (float -> float array) -> float -> float array array

vector_jet methode order function real

val matrix_jet : ((float -> float) -> float -> float) ->
       int -> (float -> float array array) -> float -> float array array array

matrix_jet methode order function real

val graph_curvature : ((float -> float) -> float -> float) -> (float -> float) -> float -> float

graph_curvature methode function real

val curvature_2 : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float

curvature_2 methode function real

val developpee_2 : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float array

developpee_2 methode function real

val parallel_arc_2 : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float -> float array

parallel_arc_2 methode function real

val curvature : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float

curvature methode function real

val serret_frenet_3 : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float array array

serret_frenet_3 methode function real

val curvature_center_3 : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float array

curvature_center_3 methode function real

val parallel_arc_3 : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float -> float array

parallel_arc_3 methode function parameter real

val serret_frenet : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float array array array

serret_frenet methode function real

val curvature_center : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float array

curvature_center methode function real

val parallel_arc : ((float -> float) -> float -> float) ->
       (float -> float array) -> float -> float -> float array

parallel_arc methode function parameter real

val fond_form_I : ((float -> float) -> float -> float) ->
       (float array -> float array) ->
       float array -> float array -> float array -> float

fond_form_I methode function position vector1 vector2

val surface_normal_3 : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float array

surface_normal_3 methode f position

val surface_area_element_3 : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float

surface_area_element_3 methode f position

val surface_area_vector_3 : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float array

surface_area_vector_3 methode f position

val surface_weingarten_3 : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float array array

surface_weingarten_3 methode f position

val surface_fond_form_II_3 : ((float -> float) -> float -> float) ->
       (float array -> float array) ->
       float array -> float array -> float array -> float

surface_fond_form_II_3 methode function position vector1 vector2

val surface_principal_curvatures_3 : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float array

surface_principal_curvatures_3 methode function position

val surface_principal_curvatures_3_bis : float ->
       int ->
       ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float array

surface_principal_curvatures_3_bis threshold max_steps methode function position

val surface_ombilic_deviation_3 : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float

surface_ombilic_deviation_3 methode function position

val surface_ombilic_deviation_3_bis : float ->
       int ->
       ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float

surface_ombilic_deviation_3_bis threshold max_steps methode function position

val surface_mean_curvature_3 : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float

surface_mean_curvature_3 methode function position

val surface_mean_curvature_3_bis : float ->
       int ->
       ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float

surface_mean_curvature_3_bis threshold max_steps methode function position

val surface_gauss_curvature_3 : ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float

surface_gauss_curvature_3 methode function position

val surface_gauss_curvature_3_bis : float ->
       int ->
       ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> float

surface_gauss_curvature_3_bis threshold max_steps methode function position

val graph_surface_3 : (float array -> float) -> float array -> float array

graph_surface_3 function position

val graph_principal_curvatures_3 : ((float -> float) -> float -> float) ->
       (float array -> float) -> float array -> float array

graph_principal_curvatures_3 function position

val graph_principal_curvatures_3_bis : float ->
       int ->
       ((float -> float) -> float -> float) ->
       (float array -> float) -> float array -> float array

graph_principal_curvatures_3_bis threshold max_steps function position

val graph_mean_curvature_3 : ((float -> float) -> float -> float) ->
       (float array -> float) -> float array -> float

graph_mean_curvature_3 function position

val graph_mean_curvature_3_bis : ((float -> float) -> float -> float) ->
       float -> int -> (float array -> float) -> float array -> float

graph_mean_curvature_3_bis threshold max_steps function position

val graph_gauss_curvature_3 : ((float -> float) -> float -> float) ->
       (float array -> float) -> float array -> float

graph_gauss_curvature_3 function position

val graph_gauss_curvature_3_bis : float ->
       int ->
       ((float -> float) -> float -> float) ->
       (float array -> float) -> float array -> float

graph_gauss_curvature_3_bis threshold max_steps function position

val float_discrete_diff : float -> float array -> float array

float_discrete_diff scale vector

val float_discrete_richardson_binary_diff : int -> float -> float array -> float array

float_discrete_richardson_binary_diff degree scale vector

val float_discrete_richardson_diff : int -> float -> float array -> float array

float_discrete_richardson_diff radix scale vector

val mean_float_discrete_diff : float -> float array -> float array

mean_float_discrete_diff scale vector

val mean_float_discrete_richardson_binary_diff : float -> float array -> float array

mean_float_discrete_richardson_binary_diff scale vector

val discrete_trans_vector_speed : (float -> float array -> float array) ->
       float -> float array array -> float array array

discrete_trans_vector_speed methode scale position_matrix

val discrete_vector_speed : (float -> float array -> float array) ->
       float -> float array array -> float array array

discrete_vector_speed methode scale position_matrix

val discrete_trans_acceleration : (float -> float array -> float array) ->
       float -> float array array -> float array array

discrete_trans_acceleration methode scale position_matrix

val discrete_acceleration : (float -> float array -> float array) ->
       float -> float array array -> float array array

discrete_acceleration methode scale position_matrix

val discrete_trans_jet : (float -> float array -> float array) ->
       int -> float -> float array array -> float array array array

discrete_trans_jet methode order scale position_matrix

val discrete_jet : (float -> float array -> float array) ->
       int -> float -> float array array -> float array array array

discrete_jet methode order scale position_matrix

val discrete_graph_curvature : (float -> float array -> float array) -> float -> float array -> float array

discrete_graph_curvature methode scale vector

val discrete_trans_curvature_2 : (float -> float array -> float array) ->
       float -> float array array -> float array

discrete_trans_curvature_2 methode scale position_matrix

val discrete_curvature_2 : (float -> float array -> float array) ->
       float -> float array array -> float array

discrete_curvature_2 methode scale position_matrix

val discrete_curvature : (float -> float array -> float array) ->
       float -> float array array -> float array

discrete_curvature methode scale position_matrix

val discrete_trans_curvature : (float -> float array -> float array) ->
       float -> float array array -> float array

discrete_trans_curvature methode scale position_matrix

val discrete_trans_serret_frenet : (float -> float array -> float array) ->
       float -> float array array -> float array array array array

discrete_trans_serret_frenet methode scale position_matrix

val discrete_serret_frenet : (float -> float array -> float array) ->
       float -> float array array -> float array array array array

discrete_serret_frenet methode scale position_matrix

val discrete_partial_diff_x : (float array -> 'a) -> float array array -> 'a array

discrete_partial_diff_x methode matrix

val discrete_partial_diff_y : (float array -> float array) -> float array array -> float array array

discrete_partial_diff_y methode matrix

val discrete_area_element : (float array -> float array) -> float array array -> float array array

discrete_area_element methode matrix

val discrete_gauss_curvature : (float array -> float array) -> float array array -> float array array

discrete_gauss_curvature methode matrix

val discrete_mean_curvature : (float array -> float array) -> float array array -> float array array

discrete_mean_curvature methode matrix

val discrete_principal_curvatures : (float array -> float array) -> float array array -> float array array array

discrete_principal_curvatures methode matrix

val float_linear_interpol : float array -> float -> float

float_linear_interpol vector real

val float_regular_stair_interpol : (float -> float) -> float array -> float -> float

float_regular_stair_interpol function vector real

val float_medium_interpol : (float -> float) -> float array -> float -> float

float_medium_interpol function vector real

val float_fit_interpol : (float -> float array -> float array) ->
       (float -> float) -> float -> float array -> float -> float

float_fit_interpol methode function parameter vector real

val float_tune_interpol : (float -> float array -> float array) ->
       (float -> float) -> float array -> float -> float

float_tune_interpol methode function vector real

val vector_trans_interpol : (float array -> float -> float) -> float array array -> float -> float array

vector_trans_interpol methode vector_sample

val vector_interpol : (float array -> float -> float) -> float array array -> float -> float array

vector_interpol methode vector_sample

val matrix_trans_interpol : (float array -> float -> float) ->
       float array array array -> float -> float array array

matrix_trans_interpol methode matrix_sample

val matrix_interpol : (float array -> float -> float) ->
       float array array array -> float -> float array array

matrix_interpol methode matrix_sample

Les interpolations à plusieurs variables qui suivent sont polymorphes.

val interpol_2 : ('a array -> float -> 'a) -> 'a array array -> float -> float -> 'a

interpol_2 methode matrix abscissa ordinate

val interpol_3 : ('a array -> float -> 'a) ->
       'a array array array -> float -> float -> float -> 'a

interpol_3 methode matrix abscissa ordinate

val interpol : (float array -> float -> float) ->
       Spec_math.Matrix.float_or_array -> float array -> float

interpol methode multi_vector abscissa ordinate

val float_zero_secant : int -> (float -> float) -> float -> float

float_zero_secant maxstep function start

val float_zero_newton : ((float -> float) -> float -> float) ->
       int -> (float -> float) -> float -> float

float_zero_newton methode maxstep function start

val float_zero_halley : ((float -> float) -> float -> float) ->
       int -> (float -> float) -> float -> float

float_zero_halley methode maxstep function start

val float_zero_householder : ((float -> float) -> float -> float) ->
       int -> int -> (float -> float) -> float -> float

float_zero_householder methode order maxstep function start

val float_zero_pot_pourri : ((float -> float) -> float -> float) ->
       int -> int -> (float -> float) -> float -> float

float_zero_pot_pourri methode maxorder maxstep function start

val float_zero_pot_pourri_alea : ((float -> float) -> float -> float) ->
       int -> int -> (float -> float) -> float -> float

float_zero_pot_pourri_alea methode maxorder maxstep function start

val float_zero_general : ((float -> float) -> float -> float) ->
       int -> int -> (float -> float) -> float -> float

float_zero_general methode maxorder maxstep function start

val float_zero_general_alea : ((float -> float) -> float -> float) ->
       int -> int -> (float -> float) -> float -> float

float_zero_general_alea methode maxorder maxstep function start

val vector_float_zero_secant : int -> (float array -> float) -> float array -> float array

vector_float_zero_secant maxstep function start

val desc_grad_zero : ((float -> float) -> float -> float) ->
       int -> (float array -> float) -> float array -> float array

desc_grad_zero methode maxstep function start

val vector_float_halley_zero : (float array array -> float array array array) ->
       ((float -> float) -> float -> float) ->
       int -> (float array -> float) -> float array -> float array

vector_float_halley_zero methode_reduc methode maxstep function start

val vector_float_zero_general : ((float -> float) -> float -> float) ->
       int -> (float array -> float) -> float array -> float array

vector_float_zero_general methode maxstep function start

val vector_float_zero_general_alea : ((float -> float) -> float -> float) ->
       int -> (float array -> float) -> float array -> float array

vector_float_zero_general_alea methode maxstep function start

val vector_float_zero_general_2 : (float array array -> float array array array) ->
       ((float -> float) -> float -> float) ->
       int -> (float array -> float) -> float array -> float array

vector_float_zero_general_2 methode maxstep function start

val vector_float_zero_general_2_alea : (float array array -> float array array array) ->
       ((float -> float) -> float -> float) ->
       int -> (float array -> float) -> float array -> float array

vector_float_zero_general_2_alea methode_reduc methode maxstep function start

val vector_zero_newton : ((float -> float) -> float -> float) ->
       int -> (float array -> float array) -> float array -> float array

vector_zero_newton methode maxstep function start

val vector_zero_general : ((float -> float) -> float -> float) ->
       int -> (float array -> float array) -> float array -> float array

vector_zero_general methode maxstep function start

val vector_zero_general_alea : ((float -> float) -> float -> float) ->
       int -> (float array -> float array) -> float array -> float array

vector_zero_general_alea methode maxstep function start

val vector_zero_general_2 : (float array array -> float array array array) ->
       ((float -> float) -> float -> float) ->
       int -> (float array -> float array) -> float array -> float array

vector_zero_general_2 methode_reduc methode maxstep function start

val vector_zero_general_2_alea : (float array array -> float array array array) ->
       ((float -> float) -> float -> float) ->
       int -> (float array -> float array) -> float array -> float array

vector_zero_general_2_alea methode maxstep function start

val vector_matrix_zero_general : ((float -> float) -> float -> float) ->
       int -> (float array -> float array array) -> float array -> float array

vector_matrix_zero_general methode maxstep function start

val vector_matrix_zero_general_alea : ((float -> float) -> float -> float) ->
       int -> (float array -> float array array) -> float array -> float array

vector_matrix_zero_general_alea methode maxstep function start

val vector_matrix_zero_general_2 : (float array array -> float array array array) ->
       ((float -> float) -> float -> float) ->
       int -> (float array -> float array array) -> float array -> float array

vector_matrix_zero_general_2 methode maxstep function start

val vector_matrix_zero_general_2_alea : (float array array -> float array array array) ->
       ((float -> float) -> float -> float) ->
       int -> (float array -> float array array) -> float array -> float array

vector_matrix_zero_general_2_alea methode maxstep function start

val matrix_zero : ((float array -> float array array) -> float array -> float array) ->
       (float array array -> float array array) ->
       float array array -> float array array

matrix_zero methode function start

val matrix_vector_zero : ((float array -> float array) -> float array -> float array) ->
       (float array array -> float array) -> float array array -> float array array

matrix_vector_zero methode function start

val matrix_float_zero : ((float array -> float) -> float array -> float array) ->
       (float array array -> float) -> float array array -> float array array

matrix_float_zero methode function start

En cas de recherche de zéros sur des données discrètes via l'interpolation, se méfier de l'interpolation par escalier dérivable float_regular_stair_interpol et des autres méthodes d'interpolation qui l'utilisent.

val float_int_rect : int -> (float -> float) -> float -> float -> float

float_int_rect nintervals function a b

val float_int_incr_rect : float -> int -> (float -> float) -> float -> float -> float

float_int_incr_rect ratio nintervals function a b

val float_int_decr_rect : float -> int -> (float -> float) -> float -> float -> float

float_int_decr_rect ratio nintervals function a b

val float_int_trapez : int -> (float -> float) -> float -> float -> float

float_int_trapez nintervals function a b

val float_int_incr_trapez : float -> int -> (float -> float) -> float -> float -> float

float_int_incr_trapez ratio nintervals function a b

val float_int_decr_trapez : float -> int -> (float -> float) -> float -> float -> float

float_int_decr_trapez ratio nintervals function a b

val float_int_simpson : int -> (float -> float) -> float -> float -> float

float_int_simpson nintervals function a b

val float_int_romberg : int -> int -> (float -> float) -> float -> float -> float

float_int_romberg order degree function a b

val float_int : int -> int -> (float -> float) -> float -> float -> float

float_int order degree function a b

val float_int_monte_carlo : int -> (float -> float) -> float -> float -> float

float_int_monte_carlo nsamples function a b

val float_romberg_step_trapez : (float -> float) -> float -> float -> float

float_romberg_step_trapez function a b

val float_int_romberg_trapez_adapt : float -> (float -> float) -> float -> float -> float

float_int_romberg_trapez_adapt tolerance function a b

val float_int_romberg_trapez_bounded : int -> float -> (float -> float) -> float -> float -> float

float_int_romberg_trapez_bounded maxstages tolerance function a b

val float_romberg_step_simpson : (float -> float) -> float -> float -> float

float_romberg_step_simpson function a b

val float_int_romberg_simpson_adapt : float -> (float -> float) -> float -> float -> float

float_int_romberg_simpson_adapt tolerance function a b

val float_int_romberg_simpson_bounded : int -> float -> (float -> float) -> float -> float -> float

float_int_romberg_simpson_bounded maxstages tolerance function a b

val float_romberg_step_3_8 : (float -> float) -> float -> float -> float

float_romberg_step_3_8 function a b

val float_int_romberg_3_8_adapt : float -> (float -> float) -> float -> float -> float

float_int_romberg_3_8_adapt tolerance function a b

val float_int_romberg_3_8_bounded : int -> float -> (float -> float) -> float -> float -> float

float_int_romberg_3_8_bounded maxstages tolerance function a b

val float_romberg_step_milne : (float -> float) -> float -> float -> float

float_romberg_step_milne function a b

val float_int_romberg_milne_adapt : float -> (float -> float) -> float -> float -> float

float_int_romberg_milne_adapt tolerance function a b

val float_int_romberg_milne_bounded : int -> float -> (float -> float) -> float -> float -> float

float_int_romberg_milne_bounded maxstages tolerance function a b

Les vecteurs ci-dessous sont des coefficients pour float_simple_step_gauss_kronrod_generic et définissant float_romberg_step_gauss_kronrod.

val gauss_abscissae_7_bis : float array

val gauss_weights_7_bis : float array

val kronrod_abscissae_15_bis : float array

val kronrod_weights_15_bis : float array

val gauss_weights_7 : float array

val gauss_abscissae_7 : float array

val kronrod_abscissae_15 : float array

val kronrod_weights_15 : float array

val gauss_kronrod_abscissae_7 : float array

val gauss_kronrod_weights_7 : float array

val gauss_kronrod_weights_5to7 : float array

val gauss_kronrod_abscissae_9 : float array

val gauss_kronrod_weights_9 : float array

val gauss_kronrod_weights_7to9 : float array

val gauss_kronrod_abscissae_15 : float array

val gauss_kronrod_weights_15 : float array

val gauss_kronrod_abscissae_21 : float array

val gauss_kronrod_weights_21 : float array

val gauss_kronrod_weights_11to21 : float array

val gauss_kronrod_abscissae_31 : float array

val gauss_kronrod_weights_31 : float array

val gauss_kronrod_abscissae_41 : float array

val gauss_kronrod_weights_41 : float array

val float_romberg_step_gauss_kronrod : (float -> float) -> float -> float -> float array

float_romberg_step_gauss_kronrod function a b

val float_simple_step_gauss_kronrod_generic : float array -> float array -> (float -> float) -> float -> float -> float

float_simple_step_gauss_kronrod_generic abscissae weights function a b

val float_simple_step_gauss_kronrod : (float -> float) -> float -> float -> float

float_simple_step_gauss_kronrod function a b

val float_int_romberg_gauss_kronrod_adapt : float -> (float -> float) -> float -> float -> float

float_int_romberg_gauss_kronrod_adapt tolerance function a b

val float_int_romberg_gauss_kronrod_bounded : int -> float -> (float -> float) -> float -> float -> float

float_int_romberg_gauss_kronrod_bounded maxstages tolerance function a b

val float_int_tanh : int -> (float -> float) -> float -> float -> float

float_int_tanh nintervals function a b

val float_int_tanh_sinh : int -> (float -> float) -> float -> float -> float

float_int_tanh_sinh parameter function a b

Les vecteurs suivants servent à calculer la méthode d'intégration float_weighted_int_0_1.

val adams_bashforth_1_w : float array

val adams_bashforth_2_w : float array

val adams_bashforth_3_w : float array

val adams_bashforth_4_w : float array

val adams_bashforth_5_w : float array

val adams_bashforth_6_w : float array

val adams_bashforth_7_w : float array

val adams_bashforth_8_w : float array

val adams_bashforth_9_w : float array

val adams_bashforth_10_w : float array

val adams_bashforth_12_w : float array

val adams_bashforth_14_w : float array

val adams_bashforth_16_w : float array

val adams_bashforth_18_w : float array

val adams_bashforth_20_w : float array

val adams_bashforth_m : float array array

val adams_bashforth_x : int -> float array

val adams_moulton_x : int -> float array

val adams_moulton_1_w : float array

val adams_moulton_2_w : float array

val adams_moulton_3_w : float array

val adams_moulton_4_w : float array

val adams_moulton_5_w : float array

val adams_moulton_6_w : float array

val adams_moulton_7_w : float array

val adams_moulton_8_w : float array

val adams_moulton_9_w : float array

val adams_moulton_10_w : float array

val adams_moulton_12_w : float array

val adams_moulton_14_w : float array

val adams_moulton_16_w : float array

val adams_moulton_18_w : float array

val adams_moulton_20_w : float array

val gauss_legendre_0_1_1_x : float array

val gauss_legendre_0_1_1_w : float array

val gauss_legendre_0_1_2_x : float array

val gauss_legendre_0_1_2_w : float array

val gauss_legendre_0_1_3_x : float array

val gauss_legendre_0_1_3_w : float array

val gauss_legendre_0_1_4_x : float array

val gauss_legendre_0_1_4_w : float array

val gauss_legendre_0_1_5_x : float array

val gauss_legendre_0_1_5_w : float array

val gauss_legendre_0_1_6_x : float array

val gauss_legendre_0_1_6_w : float array

val gauss_legendre_0_1_7_x : float array

val gauss_legendre_0_1_7_w : float array

val gauss_legendre_0_1_8_x : float array

val gauss_legendre_0_1_8_w : float array

val float_weighted_int_0_1 : float array -> float array -> (float -> float) -> float

float_weighted_int_0_1 abscissae weights function

Les vecteurs suivants servent à calculer la méthode d'intégration float_weighted_int_minus1_1.

val clenshaw_curtis_1_x : float array

val clenshaw_curtis_1_w : float array

val clenshaw_curtis_2_x : float array

val clenshaw_curtis_2_w : float array

val clenshaw_curtis_3_x : float array

val clenshaw_curtis_3_w : float array

val clenshaw_curtis_4_x : float array

val clenshaw_curtis_4_w : float array

val clenshaw_curtis_x_5_x : float array

val clenshaw_curtis_5_w : float array

val clenshaw_curtis_6_x : float array

val clenshaw_curtis_6_w : float array

val clenshaw_curtis_7_x : float array

val clenshaw_curtis_7_w : float array

val clenshaw_curtis_8_x : float array

val clenshaw_curtis_8_w : float array

val clenshaw_curtis_9_x : float array

val clenshaw_curtis_9_w : float array

val clenshaw_curtis_10_x : float array

val clenshaw_curtis_10_w : float array

val clenshaw_curtis_11_x : float array

val clenshaw_curtis_11_w : float array

val clenshaw_curtis_12_x : float array

val clenshaw_curtis_12_w : float array

val clenshaw_curtis_13_x : float array

val clenshaw_curtis_13_w : float array

val clenshaw_curtis_14_x : float array

val clenshaw_curtis_14_w : float array

val clenshaw_curtis_15_x : float array

val clenshaw_curtis_15_w : float array

val clenshaw_curtis_16_x : float array

val clenshaw_curtis_16_w : float array

val clenshaw_curtis_17_x : float array

val clenshaw_curtis_17_w : float array

val clenshaw_curtis_33_x : float array

val clenshaw_curtis_33_w : float array

val clenshaw_curtis_65_x : float array

val clenshaw_curtis_65_w : float array

val clenshaw_curtis_129_x : float array

val clenshaw_curtis_129_w : float array

val gauss_legendre_1_x : float array

val gauss_legendre_1_w : float array

val gauss_legendre_2_x : float array

val gauss_legendre_2_w : float array

val gauss_legendre_3_x : float array

val gauss_legendre_3_w : float array

val gauss_legendre_4_x : float array

val gauss_legendre_4_w : float array

val gauss_legendre_5_x : float array

val gauss_legendre_5_w : float array

val gauss_legendre_6_x : float array

val gauss_legendre_6_w : float array

val gauss_legendre_7_x : float array

val gauss_legendre_7_w : float array

val gauss_legendre_8_x : float array

val gauss_legendre_8_w : float array

val gauss_legendre_9_x : float array

val gauss_legendre_9_w : float array

val gauss_legendre_10_x : float array

val gauss_legendre_10_w : float array

val gauss_legendre_11_x : float array

val gauss_legendre_11_w : float array

val gauss_legendre_12_x : float array

val gauss_legendre_12_w : float array

val gauss_legendre_13_x : float array

val gauss_legendre_13_w : float array

val gauss_legendre_14_x : float array

val gauss_legendre_14_w : float array

val gauss_legendre_15_x : float array

val gauss_legendre_15_w : float array

val gauss_legendre_16_x : float array

val gauss_legendre_16_w : float array

val gauss_legendre_17_x : float array

val gauss_legendre_17_w : float array

val gauss_legendre_18_x : float array

val gauss_legendre_18_w : float array

val gauss_legendre_19_x : float array

val gauss_legendre_19_w : float array

val gauss_legendre_20_x : float array

val gauss_legendre_20_w : float array

val gauss_legendre_21_x : float array

val gauss_legendre_21_w : float array

val gauss_legendre_22_x : float array

val gauss_legendre_22_w : float array

val gauss_legendre_23_x : float array

val gauss_legendre_23_w : float array

val gauss_legendre_24_x : float array

val gauss_legendre_24_w : float array

val gauss_legendre_25_x : float array

val gauss_legendre_25_w : float array

val gauss_legendre_26_x : float array

val gauss_legendre_26_w : float array

val gauss_legendre_27_x : float array

val gauss_legendre_27_w : float array

val gauss_legendre_28_x : float array

val gauss_legendre_28_w : float array

val gauss_legendre_29_x : float array

val gauss_legendre_29_w : float array

val gauss_legendre_30_x : float array

val gauss_legendre_30_w : float array

val gauss_legendre_31_x : float array

val gauss_legendre_31_w : float array

val gauss_legendre_32_x : float array

val gauss_legendre_32_w : float array

val gauss_legendre_33_x : float array

val gauss_legendre_33_w : float array

val gauss_legendre_63_x : float array

val gauss_legendre_63_w : float array

val gauss_legendre_64_x : float array

val gauss_legendre_64_w : float array

val gauss_legendre_65_x : float array

val gauss_legendre_65_w : float array

val gauss_legendre_127_x : float array

val gauss_legendre_127_w : float array

val gauss_legendre_128_x : float array

val gauss_legendre_128_w : float array

val gauss_legendre_129_x : float array

val gauss_legendre_129_w : float array

val gauss_legendre_255_x : float array

val gauss_legendre_255_w : float array

val gauss_legendre_256_x : float array

val gauss_legendre_256_w : float array

val gauss_legendre_257_x : float array

val gauss_legendre_257_w : float array

val gauss_patterson_1_x : float array

val gauss_patterson_1_w : float array

val gauss_patterson_3_x : float array

val gauss_patterson_3_w : float array

val gauss_patterson_7_x : float array

val gauss_patterson_7_w : float array

val gauss_patterson_15_x : float array

val gauss_patterson_15_w : float array

val gauss_patterson_31_x : float array

val gauss_patterson_31_w : float array

val gauss_patterson_63_x : float array

val gauss_patterson_63_w : float array

val gauss_patterson_127_x : float array

val gauss_patterson_127_w : float array

val gauss_patterson_255_x : float array

val gauss_patterson_255_w : float array

val lobatto_2_x : float array

val lobatto_2_w : float array

val lobatto_3_x : float array

val lobatto_3_w : float array

val lobatto_4_x : float array

val lobatto_4_w : float array

val lobatto_5_x : float array

val lobatto_5_w : float array

val lobatto_6_x : float array

val lobatto_6_w : float array

val lobatto_7_x : float array

val lobatto_7_w : float array

val lobatto_8_x : float array

val lobatto_8_w : float array

val lobatto_9_x : float array

val lobatto_9_w : float array

val lobatto_9_x : float array

val lobatto_10_w : float array

val lobatto_11_x : float array

val lobatto_11_w : float array

val lobatto_12_x : float array

val lobatto_12_w : float array

val lobatto_13_x : float array

val lobatto_13_w : float array

val lobatto_14_x : float array

val lobatto_14_w : float array

val lobatto_15_x : float array

val lobatto_15_w : float array

val lobatto_16_x : float array

val lobatto_16_w : float array

val lobatto_17_x : float array

val lobatto_17_w : float array

val lobatto_18_x : float array

val lobatto_18_w : float array

val lobatto_19_x : float array

val lobatto_19_w : float array

val lobatto_20_x : float array

val lobatto_20_w : float array

val newton_cotes_1_x : float array

val newton_cotes_1_w : float array

val newton_cotes_2_w : float array

val newton_cotes_2_x : float array

val newton_cotes_3_w : float array

val newton_cotes_3_x : float array

val newton_cotes_4_w : float array

val newton_cotes_4_x : float array

val newton_cotes_5_w : float array

val newton_cotes_5_x : float array

val newton_cotes_6_w : float array

val newton_cotes_6_x : float array

val newton_cotes_7_w : float array

val newton_cotes_7_x : float array

val newton_cotes_8_w : float array

val newton_cotes_8_x : float array

val newton_cotes_9_w : float array

val newton_cotes_9_x : float array

val newton_cotes_10_w : float array

val newton_cotes_10_x : float array

val newton_cotes_11_w : float array

val newton_cotes_11_x : float array

val newton_cotes_12_w : float array

val newton_cotes_12_x : float array

val newton_cotes_13_w : float array

val newton_cotes_13_x : float array

val newton_cotes_14_w : float array

val newton_cotes_14_x : float array

val newton_cotes_15_w : float array

val newton_cotes_15_x : float array

val newton_cotes_16_w : float array

val newton_cotes_16_x : float array

val newton_cotes_17_w : float array

val newton_cotes_17_x : float array

val newton_cotes_18_w : float array

val newton_cotes_18_x : float array

val newton_cotes_19_w : float array

val newton_cotes_19_x : float array

val newton_cotes_20_w : float array

val newton_cotes_20_x : float array

val newton_cotes_21_x : float array

val newton_cotes_21_w : float array

val radau_1_x : float array

val radau_1_w : float array

val radau_2_x : float array

val radau_2_w : float array

val radau_3_x : float array

val radau_3_w : float array

val radau_4_x : float array

val radau_4_w : float array

val radau_5_x : float array

val radau_5_w : float array

val radau_6_x : float array

val radau_6_w : float array

val radau_7_x : float array

val radau_7_w : float array

val radau_8_x : float array

val radau_8_w : float array

val radau_9_x : float array

val radau_9_w : float array

val radau_10_x : float array

val radau_10_w : float array

val radau_11_x : float array

val radau_11_w : float array

val radau_12_x : float array

val radau_12_w : float array

val radau_13_x : float array

val radau_13_w : float array

val radau_14_x : float array

val radau_14_w : float array

val radau_15_x : float array

val radau_15_w : float array

val float_weighted_int_minus1_1 : float array -> float array -> (float -> float) -> float -> float -> float

float_weighted_int_minus1_1 abscissae weights function a b

val float_int_dichot_adapt : ((float -> float) -> float -> float -> float) ->
       float -> (float -> float) -> float -> float -> float

float_int_dichot_adapt methode tolerance function a b

float_int_romberg 11 4

val float_int_dichot_bounded : int ->
       ((float -> float) -> float -> float -> float) ->
       float -> (float -> float) -> float -> float -> float

float_int_dichot_bounded maxstages methode tolerance function a b

float_int_romberg 11 4

val float_int_multi_adapt : ((float -> float) -> float -> float -> float) ->
       int -> float -> (float -> float) -> float -> float -> float

float_int_multi_adapt methode nslices tolerance function a b

float_int_romberg 11 4

val float_int_multi_bounded : int ->
       ((float -> float) -> float -> float -> float) ->
       int -> float -> (float -> float) -> float -> float -> float

float_int_multi_bounded maxstages methode nslices tolerance function a b

float_int_romberg 11 4

val float_int_adapt_trapez_simpson : int -> float -> (float -> float) -> float -> float -> float

float_int_adapt_trapez_simpson nintervals tolerance function a b

val float_int_adapt : ((float -> float) -> float -> float -> float) ->
       int -> float -> (float -> float) -> float -> float -> float

float_int_adapt methode nintervals tolerance function a b

float_int_simpson 100

Les intégrales multiples sont calculées sur des pavés.

val float_int_double : ((float -> float) -> float -> float -> float) ->
       (float array -> float) -> float array -> float array -> float

float_int_double methode function a b

val float_int_triple : ((float -> float) -> float -> float -> float) ->
       (float array -> float) -> float array -> float array -> float

float_int_triple methode function a b

val float_int_mult : ((float -> float) -> float -> float -> float) ->
       (float array -> float) -> float array -> float array -> float

float_int_mult methode function a b

val matrix_float_int_mult : ((float -> float) -> float -> float -> float) ->
       (float array array -> float) ->
       float array array -> float array array -> float

matrix_float_int_mult methode function a b

val float_vector_int : ((float -> float) -> float -> float -> float) ->
       (float -> float array) -> float -> float -> float array

float_vector_int methode function a b

val float_matrix_int : ((float -> float) -> float -> float -> float) ->
       (float -> float array array) -> float -> float -> float array array

float_matrix_int methode function a b

val vector_int_mult : ((float -> float) -> float -> float -> float) ->
       (float array -> float array) -> float array -> float array -> float array

vector_int_mult methode function a b

val vector_matrix_int_mult : ((float -> float) -> float -> float -> float) ->
       (float array -> float array array) ->
       float array -> float array -> float array array

vector_matrix_int_mult methode function a b

val matrix_vector_int_mult : ((float -> float) -> float -> float -> float) ->
       (float array array -> float array) ->
       float array array -> float array array -> float array

matrix_vector_int_mult methode function a b

val matrix_int_mult : ((float -> float) -> float -> float -> float) ->
       (float array array -> float array array) ->
       float array array -> float array array -> float array array

matrix_int_mult methode function a b

val float_int_mult_monte_carlo : int -> (float array -> float) -> float array -> float -> float

float_int_mult_monte_carlo samples function center range

val float_compensated_int_mult_monte_carlo : (float array -> 'a) ->
       int -> float -> int -> (float array -> float) -> float array -> float -> 'a

float_compensated_int_mult_monte_carlo accelerator samples function center range

val vector_int_mult_monte_carlo : int -> (float array -> float array) -> float array -> float -> float array

vector_int_mult_monte_carlo samples function center range

val vector_compensated_int_mult_monte_carlo : (float array array -> 'a) ->
       int ->
       float -> int -> (float array -> float array) -> float array -> float -> 'a

vector_compensated_int_mult_monte_carlo accelerator samples function center range

val vector_matrix_int_mult_monte_carlo : int ->
       (float array -> float array array) ->
       float array -> float -> float array array

vector_matrix_int_mult_monte_carlo samples function center range

val vector_matrix_compensated_int_mult_monte_carlo : (float array array array -> 'a) ->
       int ->
       float ->
       int -> (float array -> float array array) -> float array -> float -> 'a

vector_matrix_compensated_int_mult_monte_carlo accelerator samples function center range

val surface_int_3 : ((float -> float) -> float -> float) ->
       ((float array -> float) -> float array -> float array -> 'a) ->
       (float array -> float array) ->
       (float array -> float) -> float array -> float array -> 'a

surface_int_3 methode_diff methode_int f phi a b

val surface_int_2_3 : ((float -> float) -> float -> float) ->
       ((float array -> float) -> float array -> float array -> 'a) ->
       (float array -> float array) ->
       (float array -> float) -> float array -> float array -> 'a

surface_int_2_3 methode_diff methode_int f phi a b

val surface_vector_int_3 : ((float -> float) -> float -> float) ->
       ((float array -> float array) -> float array -> float array -> 'a) ->
       (float array -> float array) ->
       (float array -> float array) -> float array -> float array -> 'a

surface_vector_int_3 methode_diff methode_int f phi a b

val surface_vector_int_2_3 : ((float -> float) -> float -> float) ->
       ((float array -> float array) -> float array -> float array -> 'a) ->
       (float array -> float array) ->
       (float array -> float array) -> float array -> float array -> 'a

surface_vector_int_2_3 methode_diff methode_int f phi a b

val surface_matrix_int_3 : ((float -> float) -> float -> float) ->
       ((float array -> float array array) -> float array -> float array -> 'a) ->
       (float array -> float array) ->
       (float array -> float array array) -> float array -> float array -> 'a

surface_matrix_int_3 methode_diff methode_int f phi a b

val surface_matrix_int_2_3 : ((float -> float) -> float -> float) ->
       ((float array -> float array array) -> float array -> float array -> 'a) ->
       (float array -> float array) ->
       (float array -> float array array) -> float array -> float array -> 'a

surface_matrix_int_2_3 methode_diff methode_int f phi a b

val surface_vector_flux_3 : ((float -> float) -> float -> float) ->
       ((float array -> float) -> float array -> float array -> 'a) ->
       (float array -> float array) ->
       (float array -> float array) -> float array -> float array -> 'a

surface_vector_flux_3 methode_diff methode_int f phi a b

val surface_vector_flux_2_3 : ((float -> float) -> float -> float) ->
       ((float array -> float) -> float array -> float array -> 'a) ->
       (float array -> float array) ->
       (float array -> float array) -> float array -> float array -> 'a

surface_vector_flux_2_3 methode_diff methode_int f phi a b

val float_discrete_int_rect : float -> float array -> float

float_discrete_int_rect length vector

val float_discrete_int_trapez : float -> float array -> float

float_discrete_int_trapez length vector

val float_discrete_int_simpson : float -> float array -> float

float_discrete_int_simpson length vector

val float_discrete_int_interpol : (float array -> 'a) ->
       ('a -> float -> float -> float) -> float -> float array -> float

float_discrete_int_interpol methode_interp methode_int length vector

val vector_discrete_trans_int : (float array -> float) -> float -> float array array -> float array

vector_discrete_trans_int methode length matrix

val vector_discrete_int : (float array -> float) -> float -> float array array -> float array

vector_discrete_int methode length matrix

val float_discrete_int_double : (float -> float array -> float) ->
       float -> float -> float array array -> float

float_discrete_int_double methode length_x length_y vector

val vector_discrete_int_double : (float array -> float) ->
       float -> float -> float array array array -> float array

vector_discrete_int_double methode length_x length_y vector

val float_fourier_coefficient : ((float -> float) -> float -> float -> float) ->
       (float -> float) -> int -> float array

float_fourier_coefficient methode function pulsation

val float_fourier_coefficient_general : ((float -> float) -> float -> float -> float) ->
       float -> float -> (float -> float) -> int -> float array

float_fourier_coefficient_general methode beginning ending function pulsation

val float_fourier_series : float array array -> float -> float

float_fourier_series coefficients real

val float_fourier_transform : ((float -> float) -> float -> float -> float) ->
       float -> float -> (float -> float) -> float -> float array

float_fourier_transform methode beginning ending function pulsation

val float_inv_fourier_transform : ((float -> float) -> float -> float -> float) ->
       float -> float -> (float -> float array) -> float -> float

float_inv_fourier_transform methode beginning ending function pulsation

val float_laplace_complex : ((float -> float) -> float -> float -> 'a) ->
       float -> (float -> float) -> float array -> 'a array

float_laplace_complex methode ending function parameter

val float_laplace_real : ((float -> float) -> float -> float -> 'a) ->
       float -> (float -> float) -> float -> 'a

float_laplace_real methode ending function parameter

val float_inv_laplace_complex : ((float -> float) -> float -> float -> float) ->
       float -> float -> (float array -> float array) -> float -> float array

float_inv_laplace_complex methode abscissa ending function parameter

val float_sumudu_real : ((float -> float) -> float -> float -> 'a) ->
       float -> (float -> float) -> float -> 'a

float_sumudu_real methode ending function parameter

Ces transformées nécessitent une normalisation des variables et paramètres de la part de l'utilisateur.

val discrete_float_causal_z_sequence : float array -> float array -> float array array

discrete_float_causal_z_sequence vector complex

val discrete_float_symmetric_z_sequence : float array -> float array -> float array array

discrete_float_symmetric_z_sequence vector complex

val discrete_float_causal_z_transform : float array -> float array -> float array

discrete_float_causal_z_transform vector complex

val discrete_float_symmetric_z_transform : float array -> float array -> float array

discrete_float_symmetric_z_transform vector complex

val discrete_float_causal_fourier_sequence : float array -> float -> float array array

discrete_float_causal_fourier_sequence vector pulsation

val discrete_float_causal_fourier_transform : float array -> float -> float array

discrete_float_causal_fourier_transform vector pulsation

val discrete_float_symmetric_fourier_sequence : float array -> float -> float array array

discrete_float_symmetric_fourier_sequence vector pulsation

val discrete_float_symmetric_fourier_transform : float array -> float -> float array

discrete_float_symmetric_fourier_transform vector complex

Toute transformée définie sur des fonctions peut s'appliquer aux données discrètes via l'interpolation.

val discrete_float_transform_int : (float array -> 'a) -> ('a -> int -> 'b) -> float array -> int -> 'b

discrete_float_transform_int methode_interpol methode_transform vector integer

val discrete_float_transform_real : (float array -> 'a) -> ('a -> float -> 'b) -> float array -> float -> 'b

discrete_float_transform_real methode_interpol methode_transform vector real

val discrete_float_transform_complex : (float array -> 'a) ->
       ('a -> float array -> 'b) -> float array -> float array -> 'b

discrete_float_transform_complex methode_interpol methode_transform vector complex

val float_critical : ('a -> float -> 'b) ->
       ((float -> float) -> 'a) -> (float -> float) -> float -> 'b

float_critical methode_zero methode_diff function start

val vector_float_critical : ((float array -> 'a array) -> float array -> 'b) ->
       ((float -> float) -> float -> 'a) ->
       (float array -> float) -> float array -> 'b

vector_float_critical methode_zero methode_diff function start

val vector_critical : ((float array -> float) -> float array -> 'a) ->
       ((float -> float) -> float -> float) ->
       (float array -> float array) -> float array -> 'a

vector_critical methode_zero methode_diff function start

val float_local_inverse : ((float -> float) -> float -> 'a) -> float -> (float -> float) -> float -> 'a

float_local_inverse methode_zero guess function real

val vector_local_inverse : ((float array -> float array) -> float array -> 'a) ->
       float array -> (float array -> float array) -> float array -> 'a

vector_local_inverse methode_zero guess function real

val float_implicit_function : ((float -> float) -> float -> 'a) ->
       float -> (float -> float -> float) -> float -> 'a

float_implicit_function methode_zero guess function real

val vector_implicit_function : ((float array -> float array) -> float array -> 'a) ->
       float array ->
       (float array -> float array -> float array) -> float array -> 'a

vector_implicit_function methode_zero guess function real

val float_flat_search : ((float -> 'a) -> float -> 'b) ->
       ((float -> float) -> float -> float -> 'a) ->
       (float -> float) -> float -> float -> 'b

float_flat_search methode_zero methode_int function start length

val float_ode_euler : (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_euler function nsteps value beginning ending

val vector_ode_euler : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_euler function nsteps value beginning ending

val matrix_ode_euler : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_euler function nsteps value beginning ending

val float_end_ode_euler : (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_euler function nsteps value beginning ending

val vector_end_ode_euler : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_euler function nsteps value beginning ending

val matrix_end_ode_euler : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_euler function nsteps value beginning ending

val float_ode_adams_bashforth_2 : (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_adams_bashforth_2 function nsteps value beginning ending

val vector_ode_adams_bashforth_2 : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_adams_bashforth_2 function nsteps value beginning ending

val matrix_ode_adams_bashforth_2 : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_adams_bashforth_2 function nsteps value beginning ending

val float_end_ode_adams_bashforth_2 : (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_adams_bashforth_2 function nsteps value beginning ending

val vector_end_ode_adams_bashforth_2 : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_adams_bashforth_2 function nsteps value beginning ending

val matrix_end_ode_adams_bashforth_2 : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_adams_bashforth_2 function nsteps value beginning ending

val float_ode_adams_bashforth_3 : (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_adams_bashforth_3 function nsteps value beginning ending

val vector_ode_adams_bashforth_3 : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_adams_bashforth_3 function nsteps value beginning ending

val matrix_ode_adams_bashforth_3 : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_adams_bashforth_3 function nsteps value beginning ending

val float_end_ode_adams_bashforth_3 : (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_adams_bashforth_3 function nsteps value beginning ending

val vector_end_ode_adams_bashforth_3 : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_adams_bashforth_3 function nsteps value beginning ending

val matrix_end_ode_adams_bashforth_3 : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_adams_bashforth_3 function nsteps value beginning ending

val float_ode_adams_bashforth : int ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_adams_bashforth order function nsteps value beginning ending

val vector_ode_adams_bashforth : int ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_adams_bashforth order function nsteps value beginning ending

val matrix_ode_adams_bashforth : int ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_adams_bashforth order function nsteps value beginning ending

val float_end_ode_adams_bashforth : int -> (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_adams_bashforth order function nsteps value beginning ending

val vector_end_ode_adams_bashforth : int ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_adams_bashforth order function nsteps value beginning ending

val matrix_end_ode_adams_bashforth : int ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_adams_bashforth order function nsteps value beginning ending

val float_ode_nystroem_3 : (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_nystroem_3 function nsteps value beginning ending

val vector_ode_nystroem_3 : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_nystroem_3 function nsteps value beginning ending

val matrix_ode_nystroem_3 : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_nystroem_3 function nsteps value beginning ending

val float_end_ode_nystroem_3 : (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_nystroem_3 function nsteps value beginning ending

val vector_end_ode_nystroem_3 : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_nystroem_3 function nsteps value beginning ending

val matrix_end_ode_nystroem_3 : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_nystroem_3 function nsteps value beginning ending

val float_ode_mid_point : (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_mid_point function nsteps value beginning ending

val vector_ode_mid_point : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_mid_point function nsteps value beginning ending

val matrix_ode_mid_point : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_mid_point function nsteps value beginning ending

val float_end_ode_mid_point : (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_mid_point function nsteps value beginning ending

val vector_end_ode_mid_point : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_mid_point function nsteps value beginning ending

val matrix_end_ode_mid_point : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_mid_point function nsteps value beginning ending

val float_ode_rk4 : (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_rk4 function nsteps value beginning ending

val vector_ode_rk4 : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_rk4 function nsteps value beginning ending

val matrix_ode_rk4 : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_rk4 function nsteps value beginning ending

val float_end_ode_rk4 : (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_rk4 function nsteps value beginning ending

val vector_end_ode_rk4 : (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_rk4 function nsteps value beginning ending

val matrix_end_ode_rk4 : (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_rk4 function nsteps value beginning ending

val float_ode_runge_kutta : float array array ->
       float array ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_runge_kutta butcher_matrix butcher_vector function nsteps value beginning ending

val vector_ode_runge_kutta : float array array ->
       float array ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_runge_kutta butcher_matrix butcher_vector function nsteps value beginning ending

val matrix_ode_runge_kutta : float array array ->
       float array ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_runge_kutta butcher_matrix butcher_vector function nsteps value beginning ending

val float_end_ode_runge_kutta : float array array ->
       float array ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_runge_kutta butcher_matrix butcher_vector function nsteps value beginning ending

val vector_end_ode_runge_kutta : float array array ->
       float array ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_runge_kutta butcher_matrix butcher_vector function nsteps value beginning ending

val matrix_end_ode_runge_kutta : float array array ->
       float array ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_runge_kutta butcher_matrix butcher_vector function nsteps value beginning ending

Suivent quelques tableaux de Butcher. Ils ont été glanés sur internet. La matrice carrée doit être triangulaire inférieure au sens strict. Les tableaux des méthodes adaptatives explicites cités plus loin peuvent aussi être exploités.

val euler_a : float array array

val euler_b : float array

val mid_point_a : float array array

val mid_point_b : float array

val imex_ssp2_2_2_2_a : float array array

val imex_ssp2_2_2_2_b : float array

val heun_a : float array array

val heun_b : float array

val rk2_runge_a : float array array

val rk2_runge_b : float array

val imex_ssp2_3_2_2_a : float array array

val imex_ssp2_3_2_2_b : float array

val imex_ssp2_3_3_2_a : float array array

val imex_ssp2_3_3_2_b : float array

val imex_ssp3_3_3_2_a : float array array

val imex_ssp3_3_3_2_b : float array

val example_a : float array array

val example_b : float array

val imex_ssp3_4_3_3_a : float array array

val imex_ssp3_4_3_3_b : float array

val rk4_a : float array array

val rk4_b : float array

val rk4_3_8_a : float array array

val rk4_3_8_b : float array

val hem_4_5_a : float array array

val hem_4_5_b : float array

val rk5_kutta_first_a : float array array

val rk5_kutta_first_b : float array

val rk5_kutta_second_a : float array array

val rk5_kutta_second_b : float array

val rk5_cassity_a : float array array

val rk5_cassity_b : float array

val rk6_butcher_a : float array array

val rk6_butcher_b : float array

val float_ode_back_euler : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_back_euler methode function nsteps value beginning ending

 y' = f(x,y) float_zero_householder ( float_richardson_deriv 3. 4 1e-3 ) 3 100

val float_end_ode_back_euler : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_back_euler methode function nsteps value beginning ending

 y' = f(x,y) float_zero_householder ( float_richardson_deriv 3. 4 1e-3 ) 3 100

val float_ode_trapezoid : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_trapezoid methode function nsteps value beginning ending

float_zero_householder ( float_richardson_deriv 3. 4 1e-3 ) 3 100

val float_end_ode_trapezoid : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_trapezoid methode function nsteps value beginning ending

float_zero_householder ( float_richardson_deriv 3. 4 1e-3 ) 3 100

val float_ode_adams_moulton_2 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_adams_moulton_2 methode function nsteps value beginning ending

val float_end_ode_adams_moulton_2 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_adams_moulton_2 methode function nsteps value beginning ending

val float_ode_milne_simpson_2 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_milne_simpson_2 methode function nsteps value beginning ending

val float_end_ode_milne_simpson_2 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_milne_simpson_2 methode function nsteps value beginning ending

val float_ode_bdf_2 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_bdf_2 methode function nsteps value beginning ending

val float_end_ode_bdf_2 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_bdf_2 methode function nsteps value beginning ending

val float_ode_bdf_3 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_bdf_3 methode function nsteps value beginning ending

val float_end_ode_bdf_3 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_bdf_3 methode function nsteps value beginning ending

val float_ode_bdf_4 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_bdf_4 methode function nsteps value beginning ending

val float_end_ode_bdf_4 : ((float -> float) -> float -> float) ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_bdf_4 methode function nsteps value beginning ending

val float_ode_runge_kutta_impl : ((float -> float) -> float -> float) ->
       float array array ->
       float array ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_runge_kutta_impl methode butcher_matrix butcher_vector function nsteps value beginning ending

val float_end_ode_runge_kutta_impl : ((float -> float) -> float -> float) ->
       float array array ->
       float array ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_runge_kutta_impl methode butcher_matrix butcher_vector function nsteps value beginning ending

Suivent quelques tableaux de Butcher. Ils ont été glanés sur internet. La matrice carrée doit être triangulaire inférieure au sens large. (sauf dans le cas particulier de la méthode trapézoïdale). Certains tableaux cités dans les méthodes à résolution multidimansionnelle peuvent donc être utilisés s'ils répondent à la condition.

val backward_euler_a : float array array

val backward_euler_b : float array

val rk1_gauss_a : float array array

val rk1_gauss_b : float array

val rk2_burrage_a : float array array

val rk2_burrage_b : float array

val rk2_radauI_a : float array array

val rk2_radauI_b : float array

val rk2_radauII_a : float array array

val rk2_radauII_b : float array

val rk2_sdirk_2A_b : float array

val rk2_sdirk_2A_a : float array array

val rk2_sdirk_2B_b : float array

val rk2_sdirk_2B_a : float array array

val rk2_sdirk_3A_b : float array

val rk2_sdirk_3A_a : float array array

val rk3_example_a : float array array

val rk3_example_b : float array

val imex_ssp2_2_2_2_impl_a : float array array

val imex_ssp2_2_2_2_impl_b : float array

val imex_ssp2_3_2_2_impl_a : float array array

val imex_ssp2_3_2_2_impl_b : float array

val imex_ssp2_3_3_2_impl_a : float array array

val imex_ssp2_3_3_2_impl_b : float array

val imex_ssp3_3_3_2_impl_a : float array array

val imex_ssp3_3_3_2_impl_b : float array

val mod_ext_bdf_a : float array array

val mod_ext_bdf_b : float array

val lambda_example_start : float

val lambda_example_polynom : float -> float

val lambda_example : float

val lambda_example_b : float array

val lambda_example_a : float array array

val imex : float array

val imex_ssp3_4_3_3_impl_a : float array array

val imex_ssp3_4_3_3_impl_b : float array

val rk5_try_a : float array array

val rk5_try_b : float array

val float_ode_runge_kutta_impl_multi : ((float array -> float array) -> float array -> float array) ->
       float array array ->
       float array ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_runge_kutta_impl_multi methode butcher_matrix butcher_vector function nsteps value beginning ending

val float_end_ode_runge_kutta_impl_multi : ((float array -> float array) -> float array -> float array) ->
       float array array ->
       float array ->
       (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_runge_kutta_impl_multi methode butcher_matrix butcher_vector function nsteps value beginning ending

Suivent quelques tableaux de Butcher. Ils ont été glanés sur internet.

val trapezoid_a : float array array

val trapezoid_b : float array

val rk2_gauss_a : float array array

val rk2_gauss_b : float array

val rk2_radauIA_a : float array array

val rk2_radauIA_b : float array

val rk2_radauIIA_a : float array array

val rk2_radauIIA_b : float array

val rk3_gauss_a : float array array

val rk3_gauss_b : float array

val rk3_radauI_a : float array array

val rk3_radauI_b : float array

val rk5_radauIA_a : float array array

val rk5_radauIA_b : float array

val rk3_radauII_a : float array array

val rk3_radauII_b : float array

val rk3_radauIIA_b : float array

val rk3_radauIIA_a : float array array

val rk5_radauIIA_a : float array array

val rk5_radauIIA_a_inv : float array array

val rk5_radauIIA_b : float array

val rk9_radauIIA_b : float array

val rk9_radauIIA_a : float array array

val rk9_radauIIA_a_inv : float array array

val rk13_radauIIA_b : float array

val rk13_radauIIA_a : float array array

val rk13_radauIIA_a_inv : float array array

val rk2_lobattoIIIA_a : float array array

val rk2_lobattoIIIA_b : float array

val rk4_lobattoIIIA_a : float array array

val rk4_lobattoIIIA_b : float array

val rk6_lobattoIIIA_b : float array

val rk6_lobattoIIIA_a : float array array

val rk2_lobattoIIIB_a : float array array

val rk2_lobattoIIIB_b : float array

val rk4_lobattoIIIB_a : float array array

val rk4_lobattoIIIB_b : float array

val rk6_lobattoIIIB_b : float array

val rk6_lobattoIIIB_a : float array array

val rk2_lobattoIIIC_a : float array array

val rk2_lobattoIIIC_b : float array

val rk4_lobattoIIIC_a : float array array

val rk4_lobattoIIIC_b : float array

val rk2_lobattoIIICstar_a : float array array

val rk2_lobattoIIICstar_b : float array

val rk4_lobattoIIICstar_a : float array array

val rk4_lobattoIIICstar_b : float array

val rk2_lobattoIIID_a : float array array

val rk2_lobattoIIID_b : float array

val rk4_lobattoIIID_a : float array array

val rk4_lobattoIIID_b : float array

val example_DESIRE_b : float array

val example_DESIRE_a : float array array

val float_ode_runge_kutta_simple_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_runge_kutta_simple_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val vector_ode_runge_kutta_simple_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_runge_kutta_simple_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val matrix_ode_runge_kutta_simple_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_runge_kutta_simple_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val float_end_ode_runge_kutta_simple_adapt : float array array ->
       float array ->
       float array ->
       float -> (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_runge_kutta_simple_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val vector_end_ode_runge_kutta_simple_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_runge_kutta_simple_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val matrix_end_ode_runge_kutta_simple_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_runge_kutta_simple_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val float_end_ode_runge_kutta_adapt : float array array ->
       float array ->
       float array ->
       float -> (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_runge_kutta_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val vector_end_ode_runge_kutta_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_runge_kutta_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val matrix_end_ode_runge_kutta_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_runge_kutta_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val float_end_ode_runge_kutta_bounded : int ->
       float array array ->
       float array ->
       float array ->
       float -> (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_runge_kutta_bounded maxstages butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val vector_end_ode_runge_kutta_bounded : int ->
       float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_runge_kutta_bounded maxstages butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val matrix_end_ode_runge_kutta_bounded : int ->
       float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_runge_kutta_bounded maxstages butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val float_ode_runge_kutta_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_runge_kutta_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val vector_ode_runge_kutta_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_runge_kutta_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val matrix_ode_runge_kutta_adapt : float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_runge_kutta_adapt butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val float_ode_runge_kutta_bounded : int ->
       float array array ->
       float array ->
       float array ->
       float ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_runge_kutta_bounded maxstages butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val vector_ode_runge_kutta_bounded : int ->
       float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_runge_kutta_bounded maxstages butcher_matrix butcher_vector_fine butcher_vector_raw tolerance function nsteps value beginning ending

val matrix_ode_runge_kutta_bounded : int ->
       float array array ->
       float array ->
       float array ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_runge_kutta_bounded maxstages butcher_matrix butcher_matrix_fine butcher_vector_raw tolerance function nsteps value beginning ending

Suivent quelques tableaux de Butcher. Ils ont été glanés sur internet.

val rk2_a : float array array

val rk2_b_fine : float array

val rk2_b_raw : float array

val rkf_2_3_a : float array array

val rkf_2_3_b_fine : float array

val rkf_2_3_b_raw : float array

val bogacki_shampine_a : float array array

val bogacki_shampine_b_raw : float array

val bogacki_shampine_b_fine : float array

val rk4_bogacki_shampine_a : float array array

val rk4_bogacki_shampine_b_fine : float array

val rk4_bogacki_shampine_b_err : float array

val rk4_bogacki_shampine_b_raw : float array

val dormand_prince_4_5_a : float array array

val dormand_prince_4_5_b_raw : float array

val dormand_prince_4_5_b_fine : float array

val runge_kutta_fehlberg_a : float array array

val runge_kutta_fehlberg_b_fine : float array

val runge_kutta_fehlberg_b_raw : float array

val cash_karp_a : float array array

val cash_karp_b_fine : float array

val cash_karp_b_raw : float array

val hem_5_3_a : float array array

val hem_5_3_b_fine : float array

val hem_5_3_b_raw : float array

val rk5_4_cash669_first_a : float array array

val rk5_4_cash669_first_b_fine : float array

val rk5_4_cash669_first_b_halfdiff : float array

val rk5_4_cash669_first_b_raw : float array

val rk6_4_cash669_second_b_fine : float array

val rk6_4_cash669_second_a : float array array

val rk6_4_cash669_second_b_halfdiff : float array

val rk6_4_cash669_second_b_raw : float array

val rk7_dormand_prince_a : float array array

val rk7_dormand_prince_b_raw : float array

val rk7_dormand_prince_b_fine : float array

val dormand_prince_8_5_3_a : float array array

val dormand_prince_8_5_3_b_fine : float array

val dormand_prince_8_5_3_b_err : float array

val dormand_prince_8_5_3_b_raw : float array

Les méthodes adaptatives qui suivent sont adaptées à n'importe quelle méthode de Runge-Kutta, qu'elle soit implicite ou explicite.

val float_end_ode_adapt : ((float -> float -> float) -> int -> float -> float -> float -> float) ->
       float -> (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_adapt methode tolerance function nsteps value beginning ending

val vector_end_ode_adapt : ((float -> float array -> float array) ->
        int -> float array -> float -> float -> float array) ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_adapt methode tolerance function nsteps value beginning ending

val matrix_end_ode_adapt : ((float -> float array array -> float array array) ->
        int -> float array array -> float -> float -> float array array) ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_adapt methode tolerance function nsteps value beginning ending

val float_end_ode_bounded : int ->
       ((float -> float -> float) -> int -> float -> float -> float -> float) ->
       float -> (float -> float -> float) -> int -> float -> float -> float -> float

float_end_ode_bounded maxstages methode tolerance function nsteps value beginning ending

val vector_end_ode_bounded : int ->
       ((float -> float array -> float array) ->
        int -> float array -> float -> float -> float array) ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array

vector_end_ode_bounded maxstages methode tolerance function nsteps value beginning ending

val matrix_end_ode_bounded : int ->
       ((float -> float array array -> float array array) ->
        int -> float array array -> float -> float -> float array array) ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array

matrix_end_ode_bounded maxstages methode tolerance function nsteps value beginning ending

val float_ode_adapt : ((float -> float -> float) -> int -> float -> float -> float -> float array) ->
       float ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_adapt methode tolerance function nsteps value beginning ending

val vector_ode_adapt : ((float -> float array -> float array) ->
        int -> float array -> float -> float -> float array array) ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_adapt methode tolerance function nsteps value beginning ending

val matrix_ode_adapt : ((float -> float array array -> float array array) ->
        int -> float array array -> float -> float -> float array array array) ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_adapt methode tolerance function nsteps value beginning ending

val float_ode_bounded : int ->
       ((float -> float -> float) -> int -> float -> float -> float -> float array) ->
       float ->
       (float -> float -> float) -> int -> float -> float -> float -> float array

float_ode_bounded methode tolerance function nsteps value beginning ending

val vector_ode_bounded : int ->
       ((float -> float array -> float array) ->
        int -> float array -> float -> float -> float array array) ->
       float ->
       (float -> float array -> float array) ->
       int -> float array -> float -> float -> float array array

vector_ode_bounded methode tolerance function nsteps value beginning ending

val matrix_ode_bounded : int ->
       ((float -> float array array -> float array array) ->
        int -> float array array -> float -> float -> float array array array) ->
       float ->
       (float -> float array array -> float array array) ->
       int -> float array array -> float -> float -> float array array array

matrix_ode_bounded methode tolerance function nsteps value beginning ending

val phem_5_6_a : float array array

val phem_5_6_b_raw : float array

val phem_5_6_b_fine : float array

Les présentes résolutions fonctionnent s'il est possible d'extraire une fonction implicite pour donner y'.

val float_ode_implicit : ((float -> float -> float) -> int -> float -> float -> float -> 'a) ->
       ((float -> float) -> float -> float) ->
       (float -> float -> float -> float) ->
       float -> int -> float -> float -> float -> 'a

float_ode_implicit methode_ode methode_zero function guess nsteps value beginning ending

float_ode_adapt ( float_ode_runge_kutta_adapt cash_karp_a cash_karp_b_fine cash_karp_b_raw 1e-1 ) 1e-2

val vector_ode_implicit : ((float -> float array -> float array) ->
        int -> float array -> float -> float -> 'a) ->
       ((float array -> float array) -> float array -> float array) ->
       (float -> float array -> float array -> float array) ->
       float array -> int -> float array -> float -> float -> 'a

vector_ode_implicit methode_ode methode_zero function guess nsteps value beginning ending

vector_ode_adapt ( vector_ode_runge_kutta_adapt cash_karp_a cash_karp_b_fine cash_karp_b_raw 1e-1 ) 1e-2

val gen_dirac_mass : 'a -> ('a -> 'b) -> 'b

gen_dirac_mass

val float_dirac_mass : (float -> 'a) -> 'a

float_dirac_mass function

val float_gen_dirac_mass : float -> (float -> 'a) -> 'a

float_gen_dirac_mass position function

val float_dirac_comb : int -> (float -> float) -> float

float_dirac_comb size function

val float_vector_dirac_comb : int -> (float -> float array) -> float array

float_vector_dirac_comb size function

val float_matrix_dirac_comb : int -> (float -> float array array) -> float array array

float_matrix_dirac_comb size function

val vector_dirac_mass : int -> (float array -> 'a) -> 'a

vector_dirac_mass dimension function

val vector_gen_dirac_mass : float array -> (float array -> 'a) -> 'a

vector_gen_dirac_mass position function

val matrix_dirac_mass : int -> int -> (float array array -> 'a) -> 'a

matrix_dirac_mass n_rows n_columns function

val matrix_gen_dirac_mass : float array array -> (float array array -> 'a) -> 'a

matrix_gen_dirac_mass position function

val float_dirac_family_bell : float -> float -> float

float_dirac_family_bell parameter real

val float_dirac_family_rectangle : float -> float -> float

float_dirac_family_rectangle parameter real

val float_dirac_family_triangle : float -> float -> float

float_dirac_family_triangle parameter real

val float_distrib_deriv : (('a -> float) -> 'b) -> ('b -> float) -> ('a -> float) -> float

float_distrib_deriv

val vector_distrib_deriv : (('a -> float array) -> 'b) ->
       ('b -> float array) -> ('a -> float array) -> float array

vector_distrib_deriv

val matrix_distrib_deriv : (('a -> float array array) -> 'b) ->
       ('b -> float array array) -> ('a -> float array array) -> float array array

matrix_distrib_deriv

val float_variable_translation : float -> (float -> 'a) -> float -> 'a

float_variable_translation value function real

val vector_float_variable_translation : float array -> (float array -> 'a) -> float array -> 'a

vector_float_variable_translation value function real

val matrix_float_variable_translation : float array array -> (float array array -> 'a) -> float array array -> 'a

matrix_float_variable_translation value function real

val float_distrib_transform : (('a -> 'b) -> 'c) -> ('c -> 'd) -> ('a -> 'b) -> 'd

float_distrib_transform

val normal_cumul_distribution : float -> float

normal_cumul_distribution real

val normal_cumul_distribution_complem : float -> float

normal_cumul_distribution_complem real

val erf : float -> float

erf real

val erf_complem : float -> float

erf_complem real

val normal_quantile : float -> float

normal_quantile real

val probit : float -> float

probit real

val sin_int : float -> float

sin_int real

val si : float -> float

si real

val shi : float -> float

shi real

val elliptic_integral_first_kind : float -> float -> float

elliptic_integral_first_kind k x

val elliptic_integral_second_kind : float -> float -> float

elliptic_integral_second_kind k x

val elliptic_integral_secondBis_kind : float -> float -> float

elliptic_integral_secondBis_kind k x

val elliptic_integral_third_kind : float -> float -> float -> float

elliptic_integral_third_kind k c x

val elliptic_integral : ((float -> float) -> float -> float -> 'a) ->
       float array array -> float array array -> float array -> float -> float -> 'a

elliptic_integral methode coefficients_up coefficients_down root_coefficients x

val expm_ode : (('a -> float array array -> float array array) ->
        int -> float array array -> float -> float -> 'b) ->
       int -> float array array -> 'b

expm_ode methode nsteps matrix

val expm_ode_bis : (('a -> float array array -> float array array) ->
        int -> float array array -> float -> float -> 'b) ->
       int -> float array array -> 'b

expm_ode_bis methode nsteps matrix

val slow_tune_expm : float -> float array array -> float array array

slow_tune_expm threshold matrix

val slow_tune_expm_bis : float -> float array array -> float array array

slow_tune_expm_bis threshold matrix

val tune_expm : float -> float array array -> float array array

tune_expm threshold matrix

val tune_expm_bis : float -> float array array -> float array array

tune_expm_bis threshold matrix

val slow_direct_expm : float array array -> float array array

slow_direct_expm matrix

val slow_direct_expm_bis : float array array -> float array array

slow_direct_expm_bis matrix

val direct_expm : float array array -> float array array

direct_expm matrix

val direct_expm_bis : float array array -> float array array

direct_expm_bis matrix

val slow_expm : float array array -> float array array

slow_expm matrix

val slow_expm_bis : float array array -> float array array

slow_expm_bis matrix

val slow_expm_ter : float array array -> float array array

slow_expm_ter matrix

val slow_expm_quater : float array array -> float array array

slow_expm_quater matrix

val expm : float array array -> float array array

expm matrix

val expm_bis : float array array -> float array array

expm_bis matrix

val expm_ter : float array array -> float array array

expm_ter matrix

val expm_quater : float array array -> float array array

expm_quater matrix

val curv_absc : ((float -> float) -> float -> float) ->
       ((float -> float) -> float -> float -> 'a) ->
       (float -> float array) -> float -> float -> 'a

curv_absc methode_diff methode_int function x y

val developpante : ((float -> float) -> float -> float) ->
       ((float -> float) -> float -> float -> float) ->
       (float -> float array) -> float -> float -> float -> float array

developpante methode_diff methode_int function parameter beginning real

val prescribed_curvature_2 : ((float -> float array -> float array) ->
        'a -> float array -> float -> float -> 'b) ->
       (float -> float) -> 'a -> float -> float -> 'b

prescribed_curvature_2 methode function nsteps beginning ending

val prescribed_curvature_torsion_3 : ((float -> float array -> float array) ->
        'a -> float array -> float -> float -> 'b) ->
       (float -> float) -> (float -> float) -> 'a -> float -> float -> 'b

prescribed_curvature_torsion_3 methode function nsteps beginning ending

val prescribed_multicurvature : ((float -> float array -> float array) ->
        'a -> float array -> float -> float -> 'b) ->
       (float -> float array) -> 'a -> float -> float -> 'b

prescribed_multicurvature methode function nsteps beginning ending

val clothoid : ((float -> float) -> float -> float -> 'a) -> float -> 'a array

clothoid methode real