eqsolver

eqsolver - un solveur d'équation et une bibliothèque d'optimisation pour la rouille

Cette bibliothèque de rouille vise à résoudre numériquement les équations et à optimiser les fonctions objectives.

La bibliothèque est passivement entretenue , ce qui signifie qu'aucune autre fonctionnalité ne sera ajoutée. Cependant, les problèmes sur le github seront répondus et résolus.

Les contributions et les commentaires à cette bibliothèque sont plus que les bienvenus!

Méthodes supportées

Les méthodes suivantes sont disponibles à utiliser dans la bibliothèque. Leurs descriptions utilisent le plus grand domaine et codomaine possible pour les fonctions, qui est RN. Cependant, tout sous-ensemble (bien élevé) de RN fonctionne également. De plus, les méthodes qui utilisent une entrée ou une sortie multivariée utilisent fortement la bibliothèque d'algèbre linéaire pour Rust Nalgebra.

Variable unique

Méthode de Newton-Raphson

Trouve une racine d'une fonction univariée f (x) étant donné son DF (x) dérivé et une supposition initiale. Cette méthode a un taux quadratique de convergence.

Méthode de Newton-Raphson avec des différences finies

Trouve une racine d'une fonction univariée f (x) en approximant son DF dérivé (x) en utilisant des différences finies, étant donné une supposition initiale de la racine. Cette méthode a un taux de convergence quadratique mais nécessite un peu plus de calcul que la version non finite-différence, ce qui rend le temps du mur légèrement plus long.

Méthode sécante

Trouve une racine d'une fonction univariée f (x) compte tenu de deux valeurs de départ uniques. Cette méthode a un taux de convergence légèrement inférieur (égal au rapport doré) mais ne fait qu'une seule fonction par itération, ce qui rend son temps de mur parfois inférieur aux méthodes de Newton-Raphson.

Multivarié

La méthode de Newton-Raphson (avec et sans différences finies)

Pour une fonction F: RN → RN, cette méthode trouve x telle que F (x) est le vecteur zéro, qui équivaut à résoudre un système de n équations avec n inconnues.

Il existe deux versions de cette méthode, l'une nécessite que la matrice jacobienne soit donnée et l'autre se rapproche en utilisant des différences finies. Cette dernière version a donc un temps de mur légèrement plus long. Les deux méthodes nécessitent une supposition initiale.

Pour certains problèmes mal posés, cette méthode échouera. Pour une méthode plus lente mais plus robuste, consultez la méthode Levenberg-Marquardt ci-dessous.

La méthode de Gauss-Newton (avec et sans différences finies)

Pour une fonction F: RM → RN, cette méthode trouve x telle que F (x) est le vecteur zéro, qui équivaut à résoudre un système de n équations avec m inconnues. Cela se fait en résolvant un problème le moins carré dans chaque itération, ce qui rend le temps de mur de cette méthode légèrement plus long que la méthode de Newton-Raphson.

Il existe deux versions de cette méthode, l'une nécessite que la matrice jacobienne soit donnée et l'autre se rapproche en utilisant des différences finies. Cette dernière version a donc un temps de mur légèrement plus long. Les deux méthodes nécessitent une supposition initiale.

Pour certains problèmes mal posés, cette méthode échouera. Pour une méthode plus lente mais plus robuste, consultez la méthode Levenberg-Marquardt ci-dessous.

La méthode de Levenberg-Marquardt (avec et sans différences finies)

Pour une fonction F: RM → RN, cette méthode trouve x telle que F (x) est le vecteur zéro, qui équivaut à résoudre un système de n équations avec m inconnues. Cela se fait en résolvant un problème des moindres carrés amorti (plus de calcul que le problème le moins carré habituel) dans chaque itération, ce qui rend le temps de mur de cette méthode légèrement plus long que la méthode de Gauss-Newton.

Il existe deux versions de cette méthode, l'une nécessite que la matrice jacobienne soit donnée et l'autre se rapproche en utilisant des différences finies. Cette dernière version a donc un temps de mur légèrement plus long. Les deux méthodes nécessitent une supposition initiale.

Optimistes globaux des fonctions objectives

Optimisation de l'essaim de particules

Pour une fonction f: rn → r, cette méthode trouve x telle que f (x) <= f (y) pour tout y, c'est-à-dire le minimum global. Cette méthode nécessite une supposition initiale et des limites pour lesquelles le minimum global existe.

Utilisez cette méthode si vous connaissez les limites des paramètres.

Méthode d'entrée croisée

Pour une fonction f: rn → r, cette méthode trouve x telle que f (x) <= f (y) pour tout y, c'est-à-dire le minimum global. Cette méthode nécessite une supposition initiale et un vecteur RN des écarts-types (incertitude de chaque paramètre).

Utilisez cette méthode si vous ne connaissez pas les limites des paramètres, mais sachez à quel point chaque paramètre est incertain.

Équations différentielles ordinaires (ou systèmes)

Il existe une seule struct pour les équations différentielles ordinaires (ODE) qui peuvent être modifiées (en utilisant le modèle du constructeur) pour utiliser l'une des méthodes d'étape suivantes:

Euler en avant

Cette méthode nécessite un appel à la fonction correspondant à l'équation et est donc rapide. Il a cependant un ordre de précision de 1 et est instable pour certaines fonctions.

Méthode de Heun (Runge-Kutta 2)

Cette méthode nécessite deux appels à la fonction correspondant à l'équation et est donc plus lent qu'Euler. Cette méthode a un ordre de précision de 2.

Runge-Kutta 4 (par défaut)

Cette méthode nécessite quatre appels à la fonction correspondant à l'équation et est donc plus lent que la méthode de Heun. Cette méthode a un ordre de précision de 4. Le solveur ODE utilise cette méthode comme défaut.

Exemples

Exemple de la méthode de Newton-Raphson avec des différences finies.

 use eqsolver :: single_variable :: FDNewton ;

let f = | x : f64 | x . exp ( ) - 1. /x ; // e^x = 1/x
let solution = FDNewton :: new ( f ) . solve ( 0.5 ) ; // Starting guess is 0.5

Exemple de la méthode de Newton-Raphson avec des différences finies pour le système d'équations

 use eqsolver :: multivariable :: MultiVarNewtonFD ;
use nalgebra :: { vector , Vector2 } ;

// Want to solve x^2 - y = 1 and xy = 2
let f = | v : Vector2 < f64 > | vector ! [ v [ 0 ] . powi ( 2 ) - v [ 1 ] - 1. , v [ 0 ] * v [ 1 ] - 2. ] ;

let solution = MultiVarNewtonFD :: new ( f ) . solve ( vector ! [ 1. , 1. ] ) ; // Starting guess is (1, 1)

Exemple de solution pour une seule ODE de premier ordre

 use eqsolver :: ODESolver ;

let f = | t : f64 , y : f64 | t * y ; // y' = f(t, y) = ty
let ( x0 , y0 ) = ( 0. , 0.2 ) ;
let x_end = 2. ;
let step_size = 1e-3 ;

let solution = ODESolver :: new ( f , x0 , y0 , step_size ) . solve ( x_end ) ;

Exemple de résolution d'un problème carré non linéaire avec la méthode Levenberg-Marquardt

 use eqsolver :: multivariable :: LevenbergMarquardtFD ;
use nalgebra :: { vector , Vector2 } ;

let c0 = [ 3. , 5. , 3. ] ;
let c1 = [ 1. , 0. , 4. ] ;
let c2 = [ 6. , 2. , 2. ] ;

// Function from R2 to R3
let f = | v : Vector2 < f64 > | {
    vector ! (
        ( v [ 0 ] - c0 [ 0 ] ) . powi ( 2 ) + ( v [ 1 ] - c0 [ 1 ] ) . powi ( 2 ) - c0 [ 2 ] * c0 [ 2 ] ,
        ( v [ 0 ] - c1 [ 0 ] ) . powi ( 2 ) + ( v [ 1 ] - c1 [ 1 ] ) . powi ( 2 ) - c1 [ 2 ] * c1 [ 2 ] ,
        ( v [ 0 ] - c2 [ 0 ] ) . powi ( 2 ) + ( v [ 1 ] - c2 [ 1 ] ) . powi ( 2 ) - c2 [ 2 ] * c2 [ 2 ] ,
    )
} ;

let solution_lm = LevenbergMarquardtFD :: new ( f )
    . solve ( vector ! [ 4.5 , 2.5 ] ) // Guess
    . unwrap ( ) ;

Exemple d'utilisation des optimisseurs globaux sur la fonction Rastrigin

 use eqsolver :: global_optimisers :: { CrossEntropy , ParticleSwarm } ;
use nalgebra :: SVector ;
use std :: f64 :: consts :: PI ;

const SIZE : usize = 10 ;
let rastrigin = | v : SVector < f64 , SIZE > | {
    v . fold ( 10. * SIZE as f64 , |acc , x| {
        acc + x * x - 10. * f64 :: cos ( 2. * PI * x )
    } )
} ;

let bounds = SVector :: repeat ( 10. ) ;
let standard_deviations = SVector :: repeat ( 10. ) ;
let guess = SVector :: repeat ( 5. ) ;

let opt_pso = ParticleSwarm :: new ( rastrigin , -bounds , bounds ) . solve ( guess ) ;
let opt_ce = CrossEntropy :: new ( rastrigin )
    . with_std_dev ( standard_deviations )
    . solve ( guess ) ;

Pour plus d'exemples, veuillez consulter le répertoire des exemples.