Struct newton_rootfinder::iteratives::IterativeParams

pub struct IterativeParams { /* private fields */ }

The parameters of an iterative variable

This parameters are used by the step_limitation() method from the Iterative trait to reduce the size of a step

Implementations

impl IterativeParams

pub fn new(
    max_step_abs: f64,
    max_step_rel: f64,
    min_value: f64,
    max_value: f64
) -> Self

The parameters are used by the step_limitation() method from the Iterative trait to reduce the size of a step

Both value max_step_abs and max_step_rel must be positive

The min_value must be lower than the max_value

pub fn get_min_value(&self) -> f64

pub fn get_max_value(&self) -> f64

pub fn get_max_step_abs(&self) -> f64

pub fn get_max_step_rel(&self) -> f64

Trait Implementations

impl Clone for IterativeParams

fn clone(&self) -> IterativeParams

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IterativeParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for IterativeParams

fn default() -> IterativeParams

Returns the “default value” for a type.

impl Display for IterativeParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Iterative for IterativeParams

fn step_limitation(&self, value_current: f64, raw_step: f64) -> f64

Compute a limited update step

The step size is reduced according to the following criteria :

 abs(step_size) < max_step_abs
 abs(step_size) < max_step_rel*abs(iterative_value)

Also, the step must not violated the constraints on the min_value and max_value of the iterative variable.

Warning: setting the parameters max_step_rel to a value different from infinity might lead to very reduced step size if the iterative value is near zero.

Examples

use newton_rootfinder as nrf;
use nrf::iteratives::*;

let (max_step_abs, max_step_rel, min_value, max_value) = (1.0, 1.0, f64::NEG_INFINITY, f64::INFINITY);
let mut iterative_var = IterativeParams::new(max_step_abs, max_step_rel, min_value, max_value);
assert_eq!(iterative_var.step_limitation(1.0, 1.0), 2.0);
assert_eq!(iterative_var.step_limitation(1.0, 3.0), 2.0);

let (max_step_abs, max_step_rel, min_value, max_value) = (0.1, 0.5, f64::NEG_INFINITY, f64::INFINITY);
let mut iterative_var = IterativeParams::new(max_step_abs, max_step_rel, min_value, max_value);
assert_eq!(iterative_var.step_limitation(1.5, 0.5), 1.6);
assert_eq!(iterative_var.step_limitation(0.1, 3.0), 0.15000000000000002);

fn compute_perturbation(&self, x: f64) -> f64

Compute the perturbation (only valid if it is working with finite differences)

fn with_finite_diff(&self) -> bool

Method to differente without panicking if it is working with finite differences

impl PartialEq<IterativeParams> for IterativeParams

fn eq(&self, other: &IterativeParams) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for IterativeParams