Struct SolverBuilder 

pub struct SolverBuilder<'a, R: Problem, A>(/* private fields */);

Builder for the SolverDriver.

Implementations

impl<'a, R: Problem, A> SolverBuilder<'a, R, A>

pub fn with_initial(self, x0: Vec<R::Field>) -> Self

Sets the initial point from which the iterative process starts.

Examples found in repository

examples/equations.rs (line 36)

fn main() -> Result<(), String> {
    let r = Rosenbrock { a: 1.0, b: 1.0 };
    let mut solver = SolverDriver::builder(&r)
        .with_initial(vec![10.0, -5.0])
        .build();

    let tolerance = 1e-6;

    let (_, norm) = solver
        .find(|state| {
            println!(
                "iter = {}\t|| r(x) || = {}\tx = {:?}",
                state.iter(),
                state.norm(),
                state.x()
            );
            state.norm() <= tolerance || state.iter() >= 100
        })
        .map_err(|error| format!("{error}"))?;

    if norm <= tolerance {
        Ok(())
    } else {
        Err("did not converge".to_string())
    }
}

pub fn with_algo<S2, FA>(self, factory: FA) -> SolverBuilder<'a, R, S2>

where FA: FnOnce(&R, &Domain<R::Field>) -> S2,

Sets specific algorithm to be used.

This builder method accepts a closure that takes the reference to the problem and its domain. For many algorithms in gomez, you can simply pass the new constructor directly (e.g., TrustRegion::new).

pub fn build(self) -> SolverDriver<'a, R, A>

Builds the SolverDriver.

Examples found in repository

examples/equations.rs (line 37)

fn main() -> Result<(), String> {
    let r = Rosenbrock { a: 1.0, b: 1.0 };
    let mut solver = SolverDriver::builder(&r)
        .with_initial(vec![10.0, -5.0])
        .build();

    let tolerance = 1e-6;

    let (_, norm) = solver
        .find(|state| {
            println!(
                "iter = {}\t|| r(x) || = {}\tx = {:?}",
                state.iter(),
                state.norm(),
                state.x()
            );
            state.norm() <= tolerance || state.iter() >= 100
        })
        .map_err(|error| format!("{error}"))?;

    if norm <= tolerance {
        Ok(())
    } else {
        Err("did not converge".to_string())
    }
}