eqsolver

eqsolver - um solucionador de equações e biblioteca de otimização para ferrugem

Esta biblioteca de ferrugem tem como objetivo resolver numericamente equações e otimizar funções objetivas.

A biblioteca é mantida passivamente , o que significa que nenhum outro recurso será adicionado. No entanto, questões no Github serão respondidas e resolvidas.

Contribuições e feedback para esta biblioteca são mais do que bem -vindos!

Métodos suportados

Os seguintes métodos estão disponíveis para uso na biblioteca. Suas descrições usam o maior domínio e codomínio possíveis para as funções, que é RN. No entanto, qualquer subconjunto (bem-comportado) do RN também funciona. Além disso, os métodos que usam entrada ou saída multivariados utilizam fortemente a biblioteca de álgebra linear para Nalgebra de ferrugem.

Variável única

Método de Newton-Raphson

Encontra uma raiz de uma função univariada f (x), dada a sua derivada df (x) e um palpite inicial. Este método tem uma taxa quadrática de convergência.

Método de Newton-Raphson com diferenças finitas

Encontra uma raiz de uma função univariada f (x) aproximando seu df derivado (x) usando diferenças finitas, dada um palpite inicial da raiz. Este método tem uma taxa quadrática de convergência, mas requer um pouco mais de computação do que a versão não-finita, tornando o tempo da parede um pouco mais longo.

Método Secante

Encontra uma raiz de uma função univariada f (x) recebe dois valores iniciais exclusivos. Esse método possui uma taxa de convergência ligeiramente menor (igual à proporção de ouro), mas apenas uma chamada chama por iteração, tornando o tempo da parede às vezes menor que os métodos de Newton-Raphson.

Multivariado

O método de Newton-Raphson (com e sem diferenças finitas)

Para uma função f: rn → rn, esse método encontra x tal que f (x) é o vetor zero, que é equivalente a resolver um sistema de n equações com n incógnitas.

Existem duas versões desse método, uma exige que a matriz jacobiana seja dada e a outra se aproxima que ela usando diferenças finitas. A última versão tem, portanto, tempo de parede um pouco mais longo. Ambos os métodos requerem um palpite inicial.

Para certos problemas mal postos, esse método falhará. Para um método mais lento, mas mais robusto, consulte o método Levenberg-Marquardt abaixo.

Método de Gauss-Newton (com e sem diferenças finitas)

Para uma função f: rm → rn, esse método encontra x tal que f (x) é o vetor zero, que é equivalente a resolver um sistema de n equações com m incumidas. Isso é feito resolvendo um problema mínimo quadrado em cada iteração, o que torna o tempo da parede desse método um pouco mais longo que o método de Newton-Raphson.

Existem duas versões desse método, uma exige que a matriz jacobiana seja dada e a outra se aproxima que ela usando diferenças finitas. A última versão tem, portanto, tempo de parede um pouco mais longo. Ambos os métodos requerem um palpite inicial.

Para certos problemas mal postos, esse método falhará. Para um método mais lento, mas mais robusto, consulte o método Levenberg-Marquardt abaixo.

O método de Levenberg-Marquardt (com e sem diferenças finitas)

Para uma função f: rm → rn, esse método encontra x tal que f (x) é o vetor zero, que é equivalente a resolver um sistema de n equações com m incumidas. Isso é feito resolvendo um problema de mínimo quadrado umedecido (mais computação do que o problema usual do mínimo quadrado) em cada iteração que torna o tempo da parede desse método um pouco mais longo que o método de Gauss-Newton.

Existem duas versões desse método, uma exige que a matriz jacobiana seja dada e a outra se aproxima que ela usando diferenças finitas. A última versão tem, portanto, tempo de parede um pouco mais longo. Ambos os métodos requerem um palpite inicial.

Optimissores globais de funções objetivas

Otimização de enxame de partículas

Para uma função f: rn → r, esse método encontra x tal que f (x) <= f (y) para todos y, ou seja, o mínimo global. Este método requer um palpite e limites iniciais para os quais existe o mínimo global.

Use este método se você souber os limites dos parâmetros.

Método de entropia cruzada

Para uma função f: rn → r, esse método encontra x tal que f (x) <= f (y) para todos y, ou seja, o mínimo global. Este método requer um palpite inicial e um vetor RN de desvios padrão (incerteza de cada parâmetro).

Use esse método se você não conhece os limites dos parâmetros, mas saiba como cada parâmetro é incerto.

Equações diferenciais ordinárias (ou sistemas deles)

Existe uma única struct para equações diferenciais comuns (ODE) que podem ser modificadas (usando o padrão do construtor) para usar um dos seguintes métodos de etapa:

Euler para a frente

Este método requer uma chamada para a função correspondente à equação e, portanto, é rápida. No entanto, tem uma ordem de precisão de 1 e é instável para certas funções.

Método de Heun (Runge-Kutta 2)

Este método requer duas chamadas para a função correspondente à equação e, portanto, é mais lento que Euler para a frente. Este método tem uma ordem de precisão de 2.

Runge-Kutta 4 (padrão)

Este método requer quatro chamadas para a função correspondente à equação e, portanto, é mais lento que o método de Heun. Este método tem uma ordem de precisão de 4. O solucionador de ODE usa esse método como padrão.

Exemplos

Exemplo do método de Newton-Raphson com diferenças finitas.

 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

Exemplo do método de Newton-Raphson com diferenças finitas para o sistema de equações

 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)

Exemplo de solução para um único odes de primeira ordem

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

Exemplo de resolução de um problema de menos quadrado não linear com o método 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 ( ) ;

Exemplo de usar otimistas globais na função 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 ) ;

Para mais exemplos, consulte o diretório exemplos.