Struct argmin::core::test_utils::TestProblem

pub struct TestProblem {}

Pseudo problem useful for testing

Implements CostFunction, Operator, Gradient, Jacobian, Hessian, and Anneal.

Implementations

impl TestProblem

pub fn new() -> Self

Create an instance of TestProblem.

Example

use argmin::core::test_utils::TestProblem;

let problem = TestProblem::new();

Trait Implementations

impl Anneal for TestProblem

fn anneal(&self, p: &Self::Param, _t: Self::Float) -> Result<Self::Output, Error>

Returns a clone of parameter p.

Example

use argmin::core::test_utils::TestProblem;
use argmin::solver::simulatedannealing::Anneal;

let problem = TestProblem::new();

let param = vec![1.0, 2.0];

let res = problem.anneal(&param, 1.0)?;

type Param = Vec<f64, Global>

Type of the parameter vector

type Output = Vec<f64, Global>

Return type of the anneal function

type Float = f64

Precision of floats

impl Clone for TestProblem

fn clone(&self) -> TestProblem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CostFunction for TestProblem

fn cost(&self, _p: &Self::Param) -> Result<Self::Output, Error>

Returns 1.0f64.

Example

use argmin::core::test_utils::TestProblem;
use argmin::core::CostFunction;

let problem = TestProblem::new();

let param = vec![1.0, 2.0];

let res = problem.cost(&param)?;

type Param = Vec<f64, Global>

Type of the parameter vector

type Output = f64

Tyope of the return value of the cost function

fn bulk_cost<'a, P>(&self, params: &'a [P]) -> Result<Vec<Self::Output>, Error> where
    P: Borrow<Self::Param> + SyncAlias,
    Self::Output: SendAlias,
    Self: SyncAlias, 

Compute cost in bulk. If the rayon feature is enabled, multiple calls to cost will be run in parallel using rayon, otherwise they will execute sequentially. If the rayon feature is enabled, parallelization can still be turned off by overwriting parallelize to return false. This can be useful in cases where it is preferable to parallelize only certain parts. Note that even if parallelize is set to false, the parameter vectors and the problem are still required to be Send and Sync. Those bounds are linked to the rayon feature. This method can be overwritten.

fn parallelize(&self) -> bool

Indicates whether to parallelize calls to cost when using bulk_cost. By default returns true, but can be set manually to false if needed. This allows users to turn off parallelization for certain traits implemented on their problem. Note that parallelization requires the rayon feature to be enabled, otherwise calls to cost will be executed sequentially independent of how parallelize is set.

impl Debug for TestProblem

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

Formats the value using the given formatter.

impl Default for TestProblem

fn default() -> TestProblem

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TestProblem

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Gradient for TestProblem

fn gradient(&self, p: &Self::Param) -> Result<Self::Param, Error>

Returns a clone of parameter p.

Example

use argmin::core::test_utils::TestProblem;
use argmin::core::Gradient;

let problem = TestProblem::new();

let param = vec![1.0, 2.0];

let res = problem.gradient(&param)?;

type Param = Vec<f64, Global>

Type of the parameter vector

type Gradient = Vec<f64, Global>

Type of the gradient

fn bulk_gradient<'a, P>(
    &self,
    params: &'a [P]
) -> Result<Vec<Self::Gradient>, Error> where
    P: Borrow<Self::Param> + SyncAlias,
    Self::Gradient: SendAlias,
    Self: SyncAlias, 

Compute gradient in bulk. If the rayon feature is enabled, multiple calls to gradient will be run in parallel using rayon, otherwise they will execute sequentially. If the rayon feature is enabled, parallelization can still be turned off by overwriting parallelize to return false. This can be useful in cases where it is preferable to parallelize only certain parts. Note that even if parallelize is set to false, the parameter vectors and the problem are still required to be Send and Sync. Those bounds are linked to the rayon feature. This method can be overwritten.

fn parallelize(&self) -> bool

Indicates whether to parallelize calls to gradient when using bulk_gradient. By default returns true, but can be set manually to false if needed. This allows users to turn off parallelization for certain traits implemented on their problem. Note that parallelization requires the rayon feature to be enabled, otherwise calls to gradient will be executed sequentially independent of how parallelize is set.

impl Hash for TestProblem

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Hessian for TestProblem

fn hessian(&self, p: &Self::Param) -> Result<Self::Hessian, Error>

Returns vec![p, p].

Example

use argmin::core::test_utils::TestProblem;
use argmin::core::Hessian;

let problem = TestProblem::new();

let param = vec![1.0, 2.0];

let res = problem.hessian(&param)?;

type Param = Vec<f64, Global>

Type of the parameter vector

type Hessian = Vec<Vec<f64, Global>, Global>

Type of the Hessian

fn bulk_hessian<'a, P>(
    &self,
    params: &'a [P]
) -> Result<Vec<Self::Hessian>, Error> where
    P: Borrow<Self::Param> + SyncAlias,
    Self::Hessian: SendAlias,
    Self: SyncAlias, 

Compute hessian in bulk. If the rayon feature is enabled, multiple calls to hessian will be run in parallel using rayon, otherwise they will execute sequentially. If the rayon feature is enabled, parallelization can still be turned off by overwriting parallelize to return false. This can be useful in cases where it is preferable to parallelize only certain parts. Note that even if parallelize is set to false, the parameter vectors and the problem are still required to be Send and Sync. Those bounds are linked to the rayon feature. This method can be overwritten.

fn parallelize(&self) -> bool

Indicates whether to parallelize calls to hessian when using bulk_hessian. By default returns true, but can be set manually to false if needed. This allows users to turn off parallelization for certain traits implemented on their problem. Note that parallelization requires the rayon feature to be enabled, otherwise calls to hessian will be executed sequentially independent of how parallelize is set.

impl Jacobian for TestProblem

fn jacobian(&self, p: &Self::Param) -> Result<Self::Jacobian, Error>

Returns vec![p, p].

Example

use argmin::core::test_utils::TestProblem;
use argmin::core::Jacobian;

let problem = TestProblem::new();

let param = vec![1.0, 2.0];

let res = problem.jacobian(&param)?;

type Param = Vec<f64, Global>

Type of the parameter vector

type Jacobian = Vec<Vec<f64, Global>, Global>

Type of the Jacobian

fn bulk_jacobian<'a, P>(
    &self,
    params: &'a [P]
) -> Result<Vec<Self::Jacobian>, Error> where
    P: Borrow<Self::Param> + SyncAlias,
    Self::Jacobian: SendAlias,
    Self: SyncAlias, 

Compute jacobian in bulk. If the rayon feature is enabled, multiple calls to jacobian will be run in parallel using rayon, otherwise they will execute sequentially. If the rayon feature is enabled, parallelization can still be turned off by overwriting parallelize to return false. This can be useful in cases where it is preferable to parallelize only certain parts. Note that even if parallelize is set to false, the parameter vectors and the problem are still required to be Send and Sync. Those bounds are linked to the rayon feature. This method can be overwritten.

fn parallelize(&self) -> bool

Indicates whether to parallelize calls to jacobian when using bulk_jacobian. By default returns true, but can be set manually to false if needed. This allows users to turn off parallelization for certain traits implemented on their problem. Note that parallelization requires the rayon feature to be enabled, otherwise calls to jacobian will be executed sequentially independent of how parallelize is set.

impl Operator for TestProblem

fn apply(&self, p: &Self::Param) -> Result<Self::Output, Error>

Returns a clone of parameter p.

Example

use argmin::core::test_utils::TestProblem;
use argmin::core::Operator;

let problem = TestProblem::new();

let param = vec![1.0, 2.0];

let res = problem.apply(&param)?;

type Param = Vec<f64, Global>

Type of the parameter vector

type Output = Vec<f64, Global>

Type of the return value of the operator

fn bulk_apply<'a, P>(&self, params: &'a [P]) -> Result<Vec<Self::Output>, Error> where
    P: Borrow<Self::Param> + SyncAlias,
    Self::Output: SendAlias,
    Self: SyncAlias, 

Compute apply in bulk. If the rayon feature is enabled, multiple calls to apply will be run in parallel using rayon, otherwise they will execute sequentially. If the rayon feature is enabled, parallelization can still be turned off by overwriting parallelize to return false. This can be useful in cases where it is preferable to parallelize only certain parts. Note that even if parallelize is set to false, the parameter vectors and the problem are still required to be Send and Sync. Those bounds are linked to the rayon feature. This method can be overwritten.

fn parallelize(&self) -> bool

Indicates whether to parallelize calls to apply when using bulk_apply. By default returns true, but can be set manually to false if needed. This allows users to turn off parallelization for certain traits implemented on their problem. Note that parallelization requires the rayon feature to be enabled, otherwise calls to apply will be executed sequentially independent of how parallelize is set.

impl PartialEq<TestProblem> for TestProblem

fn eq(&self, other: &TestProblem) -> 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 Serialize for TestProblem

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Copy for TestProblem

impl Eq for TestProblem

impl StructuralEq for TestProblem

impl StructuralPartialEq for TestProblem