eqsolver

eqsolver - Eine Gleichungslöser- und Optimierungsbibliothek für Rost

Diese Rust -Bibliothek zielt darauf ab, Gleichungen numerisch zu lösen und objektive Funktionen zu optimieren.

Die Bibliothek ist passiv gepflegt , was bedeutet, dass keine anderen Funktionen hinzugefügt werden. Probleme im GitHub werden jedoch beantwortet und gelöst.

Beiträge und Feedback in diese Bibliothek sind mehr als willkommen!

Unterstützte Methoden

Die folgenden Methoden können in der Bibliothek verwendet werden. Ihre Beschreibungen verwenden die größtmögliche Domäne und Codomäne für die Funktionen, nämlich RN. Allerdings funktioniert jede (gut erzogene) Untergruppe von RN. Darüber hinaus verwenden die Methoden, die multivariate Ein- oder Ausgabe verwenden oder ausgeben, die lineare Algebra -Bibliothek für Rostnalgebra stark.

Einzelvariable

Newton-Raphsons Methode

Findet eine Wurzel einer univariaten Funktion f (x) angesichts ihrer Derivat df (x) und einer anfänglichen Vermutung. Diese Methode hat eine quadratische Konvergenzrate.

Newton-Raphsons Methode mit begrenzten Unterschieden

Findet eine Wurzel einer univariaten Funktion f (x), indem sie ihren Derivat df (x) unter Verwendung endlicher Unterschiede annähert Diese Methode hat eine quadratische Konvergenzrate, erfordert jedoch etwas mehr Berechnung als die Version der Nicht-Finite-Differenz, was die Wandzeit etwas länger macht.

Sekantmethode

Findet eine Wurzel einer univariaten Funktion f (x) bei zwei eindeutigen Startwerten. Diese Methode hat eine etwas geringere Konvergenzrate (gleich dem goldenen Verhältnis), aber nur einen Funktionsaufruf pro Iteration, der seine Wandzeit manchmal niedriger macht als die Newton-Raphson-Methoden.

Multivariate

Newton-Raphsons Methode (mit und ohne begrenzte Unterschiede)

Für eine Funktion f: rn → rn findet diese Methode x so, dass f (x) der Nullvektor ist, der der Lösung eines Systems von N -Gleichungen mit N -Unbekannten entspricht.

Es gibt zwei Versionen dieser Methode, eine erfordert, dass die jakobische Matrix verabreicht wird, und der andere nähert sich mit endlichen Unterschieden an. Die letztere Version hat daher etwas längere Wandzeit. Beide Methoden erfordern eine erste Vermutung.

Bei bestimmten schlecht gestellten Problemen schlägt diese Methode fehl. Eine langsamere, aber robustere Methode finden Sie in der Levenberg-Marquardt-Methode unten.

Gauß-Newtons Methode (mit und ohne begrenzte Unterschiede)

Für eine Funktion F: RM → RN findet diese Methode X so, dass f (x) der Nullvektor ist, der der Lösung eines Systems von N -Gleichungen mit M -Unbekannten entspricht. Dies geschieht durch die Lösung eines Problems mit der kleinsten Quadratmetern in jeder Iteration, wodurch die Wandzeit dieser Methode etwas länger ist als die Methode von Newton-Raphson.

Es gibt zwei Versionen dieser Methode, eine erfordert, dass die jakobische Matrix verabreicht wird, und der andere nähert sich mit endlichen Unterschieden an. Die letztere Version hat daher etwas längere Wandzeit. Beide Methoden erfordern eine erste Vermutung.

Bei bestimmten schlecht gestellten Problemen schlägt diese Methode fehl. Eine langsamere, aber robustere Methode finden Sie in der Levenberg-Marquardt-Methode unten.

Die Methode von Levenberg-Marquardt (mit und ohne begrenzte Unterschiede)

Für eine Funktion F: RM → RN findet diese Methode X so, dass f (x) der Nullvektor ist, der der Lösung eines Systems von N -Gleichungen mit M -Unbekannten entspricht. Dies geschieht durch die Lösung eines gedämpften Problems mit dem kleinsten Quadrat (mehr Berechnung als das übliche Problem mit der kleinsten Quadratmen) in jeder Iteration, wodurch die Wandzeit dieser Methode etwas länger ist als die Methode von Gauß-Newton.

Es gibt zwei Versionen dieser Methode, eine erfordert, dass die jakobische Matrix verabreicht wird, und der andere nähert sich mit endlichen Unterschieden an. Die letztere Version hat daher etwas längere Wandzeit. Beide Methoden erfordern eine erste Vermutung.

Globale Optimierer von objektiven Funktionen

Partikelschwarmoptimierung

Für eine Funktion f: rn → r findet diese Methode x so, dass f (x) <= f (y) für alle y, dh das globale Minimum. Diese Methode erfordert eine anfängliche Vermutung und Grenzen, für die das globale Minimum existiert.

Verwenden Sie diese Methode, wenn Sie die Grenzen der Parameter kennen.

Cross-Entropy-Methode

Für eine Funktion f: rn → r findet diese Methode x so, dass f (x) <= f (y) für alle y, dh das globale Minimum. Diese Methode erfordert eine anfängliche Vermutung und einen RN -Vektor von Standardabweichungen (Unsicherheit jedes Parameters).

Verwenden Sie diese Methode, wenn Sie die Grenzen der Parameter nicht kennen, aber wissen, wie unsicher jeder Parameter ist.

Gewöhnliche Differentialgleichungen (oder Systeme von ihnen)

Es gibt eine einzelne struct für gewöhnliche Differentialgleichungen (ODE), die modifiziert werden kann (unter Verwendung des Builder -Musters), um eine der folgenden Schrittmethoden zu verwenden:

Euler vorwärts

Diese Methode erfordert einen Aufruf der Funktion, die der Gleichung entspricht, und ist somit schnell. Es hat jedoch eine Genauigkeitsordnung von 1 und ist für bestimmte Funktionen instabil.

HEuns Methode (Rang-Kutta 2)

Diese Methode erfordert zwei Aufrufe der Funktion, die der Gleichung entspricht, und ist daher langsamer als Euler vorwärts. Diese Methode hat eine Genauigkeit von 2.

RUNGE-KUTTA 4 (Standard)

Diese Methode erfordert vier Aufrufe der Funktion, die der Gleichung entspricht, und ist daher langsamer als die Methode von Heun. Diese Methode hat eine Genauigkeitsreihenfolge von 4. Der ODE -Solver verwendet diese Methode als Standard.

Beispiele

Beispiel für die Methode von Newton-Raphson mit begrenzten Unterschieden.

 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

Beispiel für die Methode von Newton-Raphson mit begrenzten Unterschieden für das System von Gleichungen

 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)

Beispiel für eine Lösung für eine einzelne ODES erster Ordnung

 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 ) ;

Beispiel für die Lösung eines nichtlinearen Problems mit der Levenberg-Marquardt-Methode

 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 ( ) ;

Beispiel für die Verwendung globaler Optimierer in der Rastrigin -Funktion

 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 ) ;

Weitere Beispiele finden Sie im Beispielverzeichnis.