Struct argmin::prelude::OpWrapper

pub struct OpWrapper<O> where
    O: ArgminOp,  {
    pub cost_func_count: u64,
    pub grad_func_count: u64,
    pub hessian_func_count: u64,
    pub modify_func_count: u64,
    // some fields omitted
}

This wraps an operator and keeps track of how often the cost, gradient and Hessian have been computed and how often the modify function has been called. Usually, this is an implementation detail unless a solver is needed within another solver (such as a line search within a gradient descent method), then it may be necessary to wrap the operator in an OpWrapper.

Fields

cost_func_count: u64

grad_func_count: u64

hessian_func_count: u64

modify_func_count: u64

Methods

impl<O> OpWrapper<O> where
    O: ArgminOp, 

pub fn new(op: &O) -> OpWrapper<O>

Constructor

pub fn apply(
    &mut self,
    param: &<O as ArgminOp>::Param
) -> Result<<O as ArgminOp>::Output, Error>

Calls the apply method of op and increments cost_func_count.

pub fn gradient(
    &mut self,
    param: &<O as ArgminOp>::Param
) -> Result<<O as ArgminOp>::Param, Error>

Calls the gradient method of op and increments gradient_func_count.

pub fn hessian(
    &mut self,
    param: &<O as ArgminOp>::Param
) -> Result<<O as ArgminOp>::Hessian, Error>

Calls the hessian method of op and increments hessian_func_count.

pub fn modify(
    &mut self,
    param: &<O as ArgminOp>::Param,
    extent: f64
) -> Result<<O as ArgminOp>::Param, Error>

Calls the modify method of op and increments modify_func_count.

pub fn consume_op(&mut self, other: OpWrapper<O>)

Consumes an operator by increasing the function call counts of self by the ones in other.

pub fn reset(self) -> OpWrapper<O>

Reset the cost function counts to zero

pub fn get_op(self) -> O

Returns the operator op by taking ownership of self.

pub fn clone_op(&self) -> O

Returns a clone of the operator op.

pub fn new_from_op(op: &OpWrapper<O>) -> OpWrapper<O>

Creates a new OpWrapper<O> from another OpWrapper<O> by cloning the op and initializing all counts with 0.

Trait Implementations

impl<O> ArgminOp for OpWrapper<O> where
    O: ArgminOp, 

The OpWrapper should behave just like any other ArgminOp

type Param = <O as ArgminOp>::Param

Type of the parameter vector

type Output = <O as ArgminOp>::Output

Output of the operator

type Hessian = <O as ArgminOp>::Hessian

Type of Hessian

fn apply(
    &self,
    param: &<OpWrapper<O> as ArgminOp>::Param
) -> Result<<OpWrapper<O> as ArgminOp>::Output, Error>

Applies the operator/cost function to parameters

fn gradient(
    &self,
    param: &<OpWrapper<O> as ArgminOp>::Param
) -> Result<<OpWrapper<O> as ArgminOp>::Param, Error>

Computes the gradient at the given parameters

fn hessian(
    &self,
    param: &<OpWrapper<O> as ArgminOp>::Param
) -> Result<<OpWrapper<O> as ArgminOp>::Hessian, Error>

Computes the hessian at the given parameters

fn modify(
    &self,
    param: &<OpWrapper<O> as ArgminOp>::Param,
    extent: f64
) -> Result<<OpWrapper<O> as ArgminOp>::Param, Error>

Modifies a parameter vector. Comes with a variable that indicates the "degree" of the modification.

impl<O> Clone for OpWrapper<O> where
    O: ArgminOp + Clone, 

fn clone(&self) -> OpWrapper<O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<O> Serialize for OpWrapper<O> where
    O: ArgminOp + Serialize, 

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<O> Debug for OpWrapper<O> where
    O: ArgminOp + Debug, 

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

Formats the value using the given formatter.

impl<'de, O> Deserialize<'de> for OpWrapper<O> where
    O: ArgminOp + Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.