Struct rv::process::RandomProcessMleOp

pub struct RandomProcessMleOp<P, X>
where
    P: RandomProcessMle<X>,
    X: Scalar + Debug,
{ /* private fields */ }

Random Process Optimization target for Argmin

Implementations

impl<P, X> RandomProcessMleOp<P, X>

where P: RandomProcessMle<X>, X: Scalar + Debug,

pub fn new(process: &P) -> Self

Create a new Process wrapper for optimization

Trait Implementations

impl<P, X> CostFunction for RandomProcessMleOp<P, X>

where P: RandomProcessMle<X>, X: Scalar + Debug,

type Param = Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

Type of the parameter vector

type Output = f64

Type of the return value of the cost function

fn cost(&self, param: &DVector<f64>) -> Result<Self::Output, Error>

Compute 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<P, X> Gradient for RandomProcessMleOp<P, X>

where P: RandomProcessMle<X>, X: Scalar + Debug,

type Param = Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

Type of the parameter vector

type Gradient = Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

Type of the gradient

fn gradient(&self, param: &DVector<f64>) -> Result<Self::Gradient, Error>

Compute 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.