Levenberg Marquardt

https://docs.rs/levenberg_marquardt/0.15.0/levenberg_marquardt/
Admin
Levenberg Marquardt is a Rust implementation of the Levenberg-Marquardt optimization algorithm for...
Tokens:1,438
Snippets:11
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Implement LeastSquaresProblem for Custom Problem

Source: https://docs.rs/levenberg_marquardt

Implement the `LeastSquaresProblem` trait to define your optimization problem. This involves providing methods to set parameters, retrieve current parameters, calculate residuals, and compute the Jacobian matrix. Ensure your `ParameterStorage`, `ResidualStorage`, and `JacobianStorage` types are correctly defined.

```rust
struct ExampleProblem {
    // holds current value of the n parameters
    p: Vector2<f64>,
}

// We implement a trait for every problem we want to solve
impl LeastSquaresProblem<f64, U2, U2> for ExampleProblem {
    type ParameterStorage = Owned<f64, U2>;
    type ResidualStorage = Owned<f64, U2>;
    type JacobianStorage = Owned<f64, U2, U2>;
     
    fn set_params(&mut self, p: &Vector2<f64>) {
        self.p.copy_from(p);
        // do common calculations for residuals and the Jacobian here
    }
     
    fn params(&self) -> Vector2<f64> { self.p }
     
    fn residuals(&self) -> Option<Vector2<f64>> {
        let [x, y] = [self.p.x, self.p.y];
        // vector containing residuals r1(x⃗)r_1()r1 and r2(x⃗)r_2()r2
        Some(Vector2::new(x*x + y - 11., x + y*y - 7.))
    }
     
    fn jacobian(&self) -> Option<Matrix2<f64>> {
        let [x, y] = [self.p.x, self.p.y];
         
        // first row of Jacobian, derivatives of first residual
        let d1_x = 2. * x; // ∂∂x1r1(x⃗)=∂∂x(x2+y−11)=2x∂∂x1r1() = ∂∂x (x2 + y - 11) = 2x∂x1∂r1() = ∂x∂(x2+y−11)=2x
        let d1_y = 1.;     // ∂∂x2r1(x⃗)=∂∂y(x2+y−11)=1∂∂x2r1() = ∂∂y (x2 + y - 11) = 1∂x2∂r1() = ∂y∂(x2+y−11)=1
         
        // second row of Jacobian, derivatives of second residual
        let d2_x = 1.;     // ∂∂x1r2(x⃗)=∂∂x(x+y2−7)=1∂∂x1r2() = ∂∂x (x + y^2 - 7) = 1∂x1∂r2() = ∂x∂(x+y2−7)=1
        let d2_y = 2. * y; // ∂∂x2r2(x⃗)=∂∂y(x+y2−7)=2y∂∂x2r2() = ∂∂y (x + y^2 - 7) = 2y∂x2∂r2() = ∂y∂(x+y2−7)=2y

        Some(Matrix2::new(
            d1_x, d1_y,
            d2_x, d2_y,
        ))
    }
}

```

--------------------------------

### Minimize Least Squares Problem with Levenberg-Marquardt

Source: https://docs.rs/levenberg_marquardt

Instantiate the `LevenbergMarquardt` optimizer and use its `minimize` method to solve a defined `LeastSquaresProblem`. This method returns a `MinimizationReport` containing information about the optimization process, including whether it was successful and the final objective function value.

```rust
let problem = ExampleProblem {
    // the initial guess for x⃗x
    p: Vector2::new(1., 1.),
};
let (_result, report) = LevenbergMarquardt::new().minimize(problem);
assert!(report.termination.was_successful());
assert!(report.objective_function.abs() < 1e-10);
```

--------------------------------

### differentiate_numerically

Source: https://docs.rs/levenberg_marquardt

Computes a numerical approximation of the Jacobian.

```APIDOC
## Function: differentiate_numerically

### Description
Compute a numerical approximation of the Jacobian.

### Parameters
(No specific parameters are detailed in the source text.)

### Returns
(Return type and value are not specified in the source text.)

### Example
(No example is provided in the source text.)
```

--------------------------------

### differentiate_holomorphic_numerically

Source: https://docs.rs/levenberg_marquardt

Computes a numerical approximation of the Jacobian for holomorphic residuals.

```APIDOC
## Function: differentiate_holomorphic_numerically

### Description
Compute a numerical approximation of the Jacobian for _holomorphic_ residuals.

### Parameters
(No specific parameters are detailed in the source text.)

### Returns
(Return type and value are not specified in the source text.)

### Example
(No example is provided in the source text.)
```
Tokens:
Raw