Struct TestSparseProblem 

pub struct TestSparseProblem {}

A struct representing the following sparse problem.

Example 1: x = [1, 1, 0, 0], y = 1 Example 2: x = [0, 0, 1, 1], y = -1 Example 3: x = [1, 0, 0, 0], y = 1 Example 4: x = [0, 0, 1, 0], y = -1

cost = Σ (w^T x - y)^2

Implements CostFunction and Gradient.

Implementations

impl TestSparseProblem

pub fn new() -> TestSparseProblem

Create an instance of TestSparseProblem.

Example

use argmin::core::test_utils::TestSparseProblem;

let problem = TestSparseProblem::new();

Trait Implementations

impl Clone for TestSparseProblem

fn clone(&self) -> TestSparseProblem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CostFunction for TestSparseProblem

fn cost( &self, param: &<TestSparseProblem as CostFunction>::Param, ) -> Result<<TestSparseProblem as CostFunction>::Output, Error>

Returns a sum of squared errors.

Example

use argmin::core::test_utils::TestSparseProblem;
use argmin::core::CostFunction;

let problem = TestSparseProblem::new();

let param = vec![1.0, 2.0, 3.0, 4.0];

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

type Param = Vec<f64>

Type of the parameter vector

type Output = f64

Type of the return value of the cost function

fn bulk_cost<P>(&self, params: &[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 TestSparseProblem

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

Formats the value using the given formatter.

impl Default for TestSparseProblem

fn default() -> TestSparseProblem

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TestSparseProblem

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Gradient for TestSparseProblem

fn gradient( &self, param: &<TestSparseProblem as Gradient>::Param, ) -> Result<<TestSparseProblem as Gradient>::Gradient, Error>

Returns a gradient of the cost function.

Example

use argmin::core::test_utils::TestSparseProblem;
use argmin::core::Gradient;

let problem = TestSparseProblem::new();

let param = vec![1.0, 2.0, 3.0, 4.0];

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

type Param = Vec<f64>

Type of the parameter vector

type Gradient = Vec<f64>

Type of the gradient

fn bulk_gradient<P>(&self, params: &[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 TestSparseProblem

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

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TestSparseProblem

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for TestSparseProblem

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for TestSparseProblem

impl Eq for TestSparseProblem

impl StructuralPartialEq for TestSparseProblem