Struct newton_rootfinder::model::UserModelFromFunction

pub struct UserModelFromFunction {
    pub inputs: DVector<f64>,
    pub func: fn(_: &DVector<f64>) -> DVector<f64>,
    pub left: DVector<f64>,
    pub right: DVector<f64>,
    // some fields omitted
}

Blanket implementation to easily adapt user function to the Model trait required by the solver to work with finite-differences

The right side of the equation is a constant and by default zero. No other outputs are computed

Examples

pub fn square(x: &nalgebra::DVector::<f64>) -> nalgebra::DVector::<f64> {
    x*x
}

use newton_rootfinder as nrf;
use nrf::model::Model; // trait import required

let iteratives = nalgebra::DVector::from_vec(vec!(2.0));
let mut user_model = nrf::model::UserModelFromFunction::new(1, square);
user_model.set_iteratives(&iteratives);
user_model.evaluate();

assert_eq!(user_model.len_problem(), 1);
assert_eq!(user_model.get_iteratives(), nalgebra::DVector::from_vec(vec!(2.0)));
assert_eq!(user_model.jacobian_provided(), false);
assert_eq!(user_model.get_residuals().get_values(0), (4.0, 0.0));

Fields

inputs: DVector<f64>

func: fn(_: &DVector<f64>) -> DVector<f64>

left: DVector<f64>

right: DVector<f64>

Implementations

impl UserModelFromFunction

pub fn new(
    problem_size: usize,
    func: fn(_: &DVector<f64>) -> DVector<f64>
) -> Self

Trait Implementations

impl Model<Dynamic> for UserModelFromFunction

type InaccurateValuesError = Infallible

type UnusableValuesError = Infallible

fn evaluate(&mut self) -> Result<(), ModelError<Self, Dynamic>>

This method should update the values of the outputs of the model by using as inputs the values set by the Model::set_iteratives method.

fn get_residuals(&self) -> ResidualsValues<Dynamic>

This method gets the values of the output for the solver. The return argument is in a specific format, separating left and right member of an equation.

fn get_iteratives(&self) -> DVector<f64>

This method is required to access the values of the iteratives variables during the resolution process. The values returned should be the same one as the one set by the Model::set_iteratives method.

fn set_iteratives(&mut self, iteratives: &DVector<f64>)

This method provides the solver a mecanism to set the iteratives values and perform the resolution

fn len_problem(&self) -> usize

This method defines the dimension of the problem.

fn jacobian_provided(&self) -> bool

This method allows the solver to know if the jacobian is provided by the user or not

fn get_jacobian(&mut self) -> Result<JacobianValues<D>, ModelError<Self, D>>

Method allowing to access the jacobian matrix This method takes a mutable model, as it allows to compute the jacobian when needed and not only when the model is evaluated.

fn get_memory(&self) -> DVector<f64>

This method allow the solver to memorize information after calculating the reference point and before the jacobian evaluation by finite-difference.

fn set_memory(&mut self, memory: &DVector<f64>)

This method is called in-between the computation of each column of the jacobian matrix, in order to reset the values to the ones from the Model::get_memory