Evaluate the primal, Jacobian and Hessian of function objects. More...

#include <evaluationHelper.hpp>

Public Types
template<typename Func>
using	DefaultHandle = EvaluationHandleForward<Func, JacobianComputationType>

template<typename Func>
using	DefaultHandle2nd = EvaluationHandleForward<Func, HessianComputationType>

template<typename Func, size_t m, size_t n>
using	DefaultHandleFixed

template<typename Func, size_t m, size_t n>
using	DefaultHandleFixed2nd

template<typename VecIn, typename VecOut>
using	FunctorInterface = void (*)(VecIn const& x, VecOut& y)

using	HessianComputationType = RealForwardGen<RealForwardVec<4>, Direction<RealForwardVec<4>, 4>>

using	JacobianComputationType = RealForwardVec<4>

Static Public Member Functions
template<typename Type, typename Func>
static inlineEvaluationHandle< Func, Type >	createHandle (Func &func, size_t m, size_t n)
	Helper function for the creation of an evaluation handle with the specified CoDiPack type and a variable vector size.

template<typename Func>
static inlineDefaultHandle< Func >	createHandleDefault (Func &func, size_t m, size_t n)
	Helper function for the creation of a default first order evaluation handle with a variable vector size.

template<typename Func>
static inlineDefaultHandle2nd< Func >	createHandleDefault2nd (Func &func, size_t m, size_t n)
	Helper function for the creation of a default second order evaluation handle with a variable vector size.

template<size_t m, size_t n, typename Func>
static inlineDefaultHandleFixed< Func, m, n >	createHandleDefaultFixed (Func &func)
	Helper function for the creation of a default first order evaluation handle with a compile time vector size.

template<size_t m, size_t n, typename Func>
static inlineDefaultHandleFixed2nd< Func, m, n >	createHandleDefaultFixed2nd (Func &func)
	Helper function for the creation of a default second order evaluation handle with a compile time vector size.

template<typename Type, size_t m, size_t n, typename Func>
static inlineEvaluationHandle< Func, Type, std::array< Type, n >, std::array< Type, m > >	createHandleFixed (Func &func)
	Helper function for the creation of an evaluation handle with the specified CoDiPack type and a compile time vector size.

template<typename Type, typename InputStore, typename OutputStore, typename Func>
static inlineEvaluationHandle< Func, Type, InputStore, OutputStore >	createHandleFull (Func &func, size_t m, size_t n)
	Helper function for the creation of an evaluation handle with the specified CoDiPack type and storage types.

template<typename T = double>
static inlineHessian< T >	createHessian (size_t m, size_t n)
	Create a Hessian with the given size.

template<size_t m, size_t n, typename T = double>
static inlineHessian< T, std::array< T, m n n > >	createHessianFixed ()
	Create a Hessian with a compile time size.

template<typename T = double>
static inlineJacobian< T >	createJacobian (size_t m, size_t n)
	Create a Jacobian with the given size.

template<size_t m, size_t n, typename T = double>
static inlineJacobian< T, std::array< T, m *n > >	createJacobianFixed ()
	Create a Jacobian with a compile time size.

template<typename Handle, typename VecX, typename Hes>
static inlinevoid	evalHandleHessian (Handle &handle, VecX const &x, Hes &hes)
	Compute the Hessian of the function object stored in the handle.

template<typename Handle, typename VecX, typename Jac>
static inlinevoid	evalHandleJacobian (Handle &handle, VecX const &x, Jac &jac)
	Compute the Jacobian of the function object stored in the handle.

template<typename Handle, typename VecX, typename Jac, typename Hes>
static inlinevoid	evalHandleJacobianAndHessian (Handle &handle, VecX const &x, Jac &jac, Hes &hes)
	Compute the Hessian of the evaluation procedure in the function object.

template<typename Handle, typename VecX, typename VecY>
static inlinevoid	evalHandlePrimal (Handle &handle, VecX const &x, VecY &y)
	Perform a primal evaluation of the function object stored in the handle.

template<typename Handle, typename VecX, typename VecY, typename Hes>
static inlinevoid	evalHandlePrimalAndHessian (Handle &handle, VecX const &x, VecY &y, Hes &hes)
	Compute the primal result and Hessian of the function object.

template<typename Handle, typename VecX, typename VecY, typename Jac>
static inlinevoid	evalHandlePrimalAndJacobian (Handle &handle, VecX const &x, VecY &y, Jac &jac)
	Compute the primal result and Jacobian of the function object stored in the handle.

template<typename Handle, typename VecX, typename VecY, typename Jac, typename Hes>
static inlinevoid	evalHandlePrimalAndJacobianAndHessian (Handle &handle, VecX const &x, VecY &y, Jac &jac, Hes &hes)
	Compute the primal result, Jacobian, and Hessian of the function object.

template<typename Func, typename VecX, typename Hes>
static inlinevoid	evalHessian (Func &func, VecX const &x, size_t const ySize, Hes &hes)
	Compute the Hessian of the function object.

template<typename Func, typename VecX, typename Jac>
static inlinevoid	evalJacobian (Func &func, VecX const &x, size_t const ySize, Jac &jac)
	Compute the Jacobian of the function object.

template<typename Func, typename VecX, typename Jac, typename Hes>
static inlinevoid	evalJacobianAndHessian (Func &func, VecX const &x, size_t ySize, Jac &jac, Hes &hes)
	Compute the Jacobian and Hessian of the function object.

template<typename Func, typename VecX, typename VecY>
static inlinevoid	evalPrimal (Func &func, VecX const &x, VecY &y)
	Perform a primal evaluation of the function object with the default first order type.

template<typename Func, typename VecX, typename VecY, typename Hes>
static inlinevoid	evalPrimalAndHessian (Func &func, VecX const &x, VecY &y, Hes &hes)
	Compute the primal result and Hessian of the function object.

template<typename Func, typename VecX, typename VecY, typename Jac>
static inlinevoid	evalPrimalAndJacobian (Func &func, VecX const &x, VecY &y, Jac &jac)
	Compute the primal result and Jacobian of the function object.

template<typename Func, typename VecX, typename VecY, typename Jac, typename Hes>
static inlinevoid	evalPrimalAndJacobianAndHessian (Func &func, VecX const &x, VecY &y, Jac &jac, Hes &hes)
	Compute the primal result, Jacobian, and Hessian of the function object.

Detailed Description

Evaluate the primal, Jacobian and Hessian of function objects.

This helper provides the means to easily evaluate derivatives of arbitrary function objects. These function objects can be regular functions, lambda functions or structures where operator() is implemented.

The nomenclature and mathematical definitions for the function, the Jacobian, and the Hessian can be found in the Mathematical naming conventions documentation. Function arguments in this class follow the same naming scheme.

The algorithms will call the function objects with the vector of inputs and with the vector of outputs as arguments. The function object has to resemble the interface defined by FunctorInterface. An example function definition is:

void func1(std::vector<ADType> const& x, std::vector<ADType>& y) { ... }
// or
void func1(std::array<ADType, n> const& x, std::array<ADType, m>& y) { ... }

x is the vector of input values and y is the vector of output values. ADType is the chosen CoDiPack type for the function. For most users, this definition will be enough. For more general examples please go to section Advanced function object definitions.

The CoDiPack type can be any ActiveType type from CoDiPack, for example all types that are defined in codi.hpp. The evaluation helper provides the default CoDiPack type definitions EvaluationHelper::JacobianComputationType and EvaluationHelper::HessianComputationType. These two use the forward mode of algorithmic differentiation and are more appropriate if and are small. They can also be used if is smaller than . For cases in in which the dimensions are larger and is smaller than , the types codi::JacobianComputationType and codi::HessianComputationType can be used. They use the reverse AD mode for the computation. Please refer to Advanced function object definitions to see how these types can be used.

The most simple example of using the EvaluationHelper is:

#include <codi.hpp>
 
#include "outputHelpers.hpp"
 
using Real = codi::EvaluationHelper::HessianComputationType;
 
void func(std::vector<Real> const& x, std::vector<Real>& y) {
  y[0] = x[0] + x[1];
  y[1] = x[0] - x[1];
  y[2] = x[0] * x[1];
  y[3] = x[0] / x[1];
}
 
int main(int nargs, char** args) {
  std::vector<double> x = {3.0, 4.0};
  std::vector<double> y(4);
 
  codi::EvaluationHelper eh;
  auto jac = eh.createJacobian(4,2);
  auto hes = eh.createHessian(4,2);
 
  eh.evalPrimalAndJacobianAndHessian(func, x, y, jac, hes);
 
  std::cout << "Jacobian:" << std::endl;
  std::cout << jac << std::endl;
  printHesForOutput("Hessian with respect to y[0]: ", hes, 0);
  printHesForOutput("Hessian with respect to y[1]: ", hes, 1);
  printHesForOutput("Hessian with respect to y[2]: ", hes, 2);
  printHesForOutput("Hessian with respect to y[3]: ", hes, 3);
 
  return 0;
}

Since we want to evaluate the Hessian, we use the Hessian type of the EvaluationHelper. The function is defined with this type and the standard vector classes. In the main function, we create the vector on which we want to call the function and then use the helper to create the storage for the Jacobian and Hessian. With the values can be accessed. For the Hessian the values can be accessed with where is the output dimension and as well as are the input dimensions.

The evaluation helper class provides all combinations of evaluation choices, that is: evalPrimal(), evalJacobian(), evalHessian(), evalPrimalAndJacobian(), evalPrimalAndHessian(), evalJacobianAndHessian() and evalPrimalAndJacobianAndHessian(). Each of these functions uses the default CoDiPack types in the evaluation helper. In the cases where the primal is not stored, the user has to provide the number of output values manually.

If the EvaluationHelper is used to evaluate the same function several times, a higher performance can be achieved if a handle for the evaluation is created up front and then used several times. The above example with the handle creation would look like this:

auto handle = eh.createHandleDefaultFixed2nd<4, 2>(func);

eh.evalHandlePrimalAndJacobianAndHessian(handle, x, y, jac, hes);

The evaluation logic nearly stayed the same, but instead of providing the function to the evaluation routine, we create a handle up front and then use this handle in the evalHandle method. Each of the above mentioned eval routines has a corresponding evalHandle method.

Each of the create methods has similar create..Fixed method which uses the std::array type instead of the std::vector type for the data management. These methods can be used if the size is known at compile time. An example with these methods would be:

#include <codi.hpp>
 
#include "outputHelpers.hpp"
 
using Real = codi::EvaluationHelper::HessianComputationType;
 
void func(std::array<Real, 2> const& x, std::array<Real, 4>& y) {
  y[0] = x[0] + x[1];
  y[1] = x[0] - x[1];
  y[2] = x[0] * x[1];
  y[3] = x[0] / x[1];
}
 
int main(int nargs, char** args) {
  std::array<double, 2> x = {3.0, 4.0};
  std::array<double, 4> y;
 
  codi::EvaluationHelper eh;
  auto jac = eh.createJacobianFixed<4,2>();
  auto hes = eh.createHessianFixed<4,2>();
 
  auto handle = eh.createHandleDefaultFixed2nd<4, 2>(func);
  eh.evalHandlePrimalAndJacobianAndHessian(handle, x, y, jac, hes);
 
  std::cout << "Jacobian:" << std::endl;
  std::cout << jac << std::endl;
  printHesForOutput("Hessian with respect to y[0]: ", hes, 0);
  printHesForOutput("Hessian with respect to y[1]: ", hes, 1);
  printHesForOutput("Hessian with respect to y[2]: ", hes, 2);
  printHesForOutput("Hessian with respect to y[3]: ", hes, 3);
 
  return 0;
}

Until now, the default definition for the used CoDiPack types have been used. In order to use an arbitrary CoDiPack type, the createHandle(), createHandleFixed(), and createHandleFull() methods can be used. The first one uses std::vectors for the storage, the second method std::array, and in the third the user can provide the storage class as a template parameter. The use case for the createHandle() method would look like this:

auto handle = eh.createHandle<codi::RealReverse>(func, 4, 2);

codi::RealReverse

RealReverseGen< double > RealReverse

Definition codi.hpp:124

Advanced function object definitions

The function object can also have a template argument for the evaluation type, e.g.:

struct Func {
  template<typename T>
  void operator()(std::vector<T> const& x, std::vector<T>& y);
};

There is also no need to specify std::vector as the array class, e.g.:

struct Func {
  template<typename InVec, typename OutVec>
  void operator()(InVec const& x, OutVec& y);
};

Member Typedef Documentation

◆ DefaultHandle

template<typename Func>

using codi::EvaluationHelper::DefaultHandle = EvaluationHandleForward<Func, JacobianComputationType>

Type for the default handle for first order derivative computations with a variable vector size.

Template Parameters

Func	See FunctorInterface.

◆ DefaultHandle2nd

template<typename Func>

using codi::EvaluationHelper::DefaultHandle2nd = EvaluationHandleForward<Func, HessianComputationType>

Type for the default handle for second order derivative computations with a variable vector size.

Template Parameters

Func	See FunctorInterface.

◆ DefaultHandleFixed

template<typename Func, size_t m, size_t n>

using codi::EvaluationHelper::DefaultHandleFixed

Initial value:

 
          EvaluationHandleForward<Func, JacobianComputationType, std::array<JacobianComputationType, n>,
                                  std::array<JacobianComputationType, m>>

Type for the default handle for first order derivative computations with a compile time vector size.

Template Parameters

Func	See FunctorInterface
m	The size of the output vector.
n	The size of the input vector.

◆ DefaultHandleFixed2nd

template<typename Func, size_t m, size_t n>

using codi::EvaluationHelper::DefaultHandleFixed2nd

Initial value:

 
          EvaluationHandleForward<Func, HessianComputationType, std::array<HessianComputationType, n>,
                                  std::array<HessianComputationType, m>>

Type for the default handle for second order derivative computations with a compile time vector size.

Template Parameters

Func	See FunctorInterface
m	The size of the output vector.
n	The size of the input vector.

◆ FunctorInterface

template<typename VecIn, typename VecOut>

using codi::EvaluationHelper::FunctorInterface = void (*)(VecIn const& x, VecOut& y)

Function object syntax for all Func template arguments.

Template Parameters

VecIn	User defined (default: std::vector).
VecOut	User defined (default: std::vector).

◆ HessianComputationType

using codi::EvaluationHelper::HessianComputationType = RealForwardGen<RealForwardVec<4>, Direction<RealForwardVec<4>, 4>>

The default type used for second order derivative computation. It is defined as forward vector over forward vector AD mode of size 4 and 4. *‍/

◆ JacobianComputationType

using codi::EvaluationHelper::JacobianComputationType = RealForwardVec<4>

The default type used for first order derivative computation. It is defined as forward vector AD mode of size 4.

Member Function Documentation

◆ createHandle()

template<typename Type, typename Func>

static inlineEvaluationHandle< Func, Type > codi::EvaluationHelper::createHandle	(	Func &	func,
		size_t	m,
		size_t	n )

inlinestatic

Helper function for the creation of an evaluation handle with the specified CoDiPack type and a variable vector size.

The CoDiPack type can be an arbitrary one:

auto handle = codi::EvaluationHelper::createHandle<codi::RealReverse>(func, m, n);

codi::EvaluationHelper::createHandle

static inlineEvaluationHandle< Func, Type > createHandle(Func &func, size_t m, size_t n)

Helper function for the creation of an evaluation handle with the specified CoDiPack type and a varia...

Definition evaluationHelper.hpp:685

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	m	The size of the output vector.
[in]	n	The size of the input vector.

Template Parameters

CoDiType	An arbitrary CoDiPack type based on ActiveType. All definitions in codi.hpp are supported. For user developed tapes, EvaluationHandle has to be specialized.
Func	See FunctorInterface.

◆ createHandleDefault()

template<typename Func>

static inlineDefaultHandle< Func > codi::EvaluationHelper::createHandleDefault	(	Func &	func,
		size_t	m,
		size_t	n )

inlinestatic

Helper function for the creation of a default first order evaluation handle with a variable vector size.

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	m	The size of the output vector.
[in]	n	The size of the input vector.

Template Parameters

Func	See FunctorInterface.

◆ createHandleDefault2nd()

template<typename Func>

static inlineDefaultHandle2nd< Func > codi::EvaluationHelper::createHandleDefault2nd	(	Func &	func,
		size_t	m,
		size_t	n )

inlinestatic

Helper function for the creation of a default second order evaluation handle with a variable vector size.

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	m	The size of the output vector.
[in]	n	The size of the input vector.

Template Parameters

Func	See FunctorInterface.

◆ createHandleDefaultFixed()

template<size_t m, size_t n, typename Func>

static inlineDefaultHandleFixed< Func, m, n > codi::EvaluationHelper::createHandleDefaultFixed ( Func & func )

inlinestatic

Helper function for the creation of a default first order evaluation handle with a compile time vector size.

Parameters

[in] func The function object for the evaluation (see FunctorInterface).

Template Parameters

m	The size of the output vector.
n	The size of the input vector.
Func	See FunctorInterface.

◆ createHandleDefaultFixed2nd()

template<size_t m, size_t n, typename Func>

static inlineDefaultHandleFixed2nd< Func, m, n > codi::EvaluationHelper::createHandleDefaultFixed2nd ( Func & func )

inlinestatic

Helper function for the creation of a default second order evaluation handle with a compile time vector size.

Parameters

[in] func The function object for the evaluation (see FunctorInterface).

Template Parameters

m	The size of the output vector.
n	The size of the input vector.
Func	See FunctorInterface.

◆ createHandleFixed()

template<typename Type, size_t m, size_t n, typename Func>

static inlineEvaluationHandle< Func, Type, std::array< Type, n >, std::array< Type, m > > codi::EvaluationHelper::createHandleFixed ( Func & func )

inlinestatic

Helper function for the creation of an evaluation handle with the specified CoDiPack type and a compile time vector size.

The CoDiPack type can be an arbitrary one:

auto handle = codi::EvaluationHelper::createHandleFixed<codi::RealReverse, m, n>(func);

codi::EvaluationHelper::createHandleFixed

static inlineEvaluationHandle< Func, Type, std::array< Type, n >, std::array< Type, m > > createHandleFixed(Func &func)

Helper function for the creation of an evaluation handle with the specified CoDiPack type and a compi...

Definition evaluationHelper.hpp:707

Parameters

[in] func The function object for the evaluation (see FunctorInterface).

Template Parameters

CoDiType	An arbitrary CoDiPack type based on ActiveType. All definitions in codi.hpp are supported. For user developed tapes, EvaluationHandle has to be specialized.
Func	See FunctorInterface.
m	The size of the output vector.
n	The size of the input vector.

◆ createHandleFull()

template<typename Type, typename InputStore, typename OutputStore, typename Func>

static inlineEvaluationHandle< Func, Type, InputStore, OutputStore > codi::EvaluationHelper::createHandleFull	(	Func &	func,
		size_t	m,
		size_t	n )

inlinestatic

Helper function for the creation of an evaluation handle with the specified CoDiPack type and storage types.

The CoDiPack type can be an arbitrary one and the storage types must use it for their elements.

auto handle = codi::EvaluationHelper::createHandleFull<codi::RealReverse,
                                                       std::vector<codi::RealReverse>,
                                                       std::array<<codi::RealReverse, m>>(func, m, n);

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	m	The size of the output vector.
[in]	n	The size of the input vector.

Template Parameters

CoDiType	An arbitrary CoDiPack type based on ActiveType. All definitions in codi.hpp are supported. For user developed tapes, EvaluationHandle has to be specialized.
Func	See FunctorInterface
InputStore	The storage type for vectors of input variables.
OutputStore	The storage type for vectors of output variables.

◆ createHessian()

template<typename T = double>

static inlineHessian< T > codi::EvaluationHelper::createHessian	(	size_t	m,
		size_t	n )

inlinestatic

Create a Hessian with the given size.

Parameters

[in]	m	The size of the output vector.
[in]	n	The size of the input vector.

Template Parameters

T	The storage type of the Hessian.

◆ createHessianFixed()

template<size_t m, size_t n, typename T = double>

static inlineHessian< T, std::array< T, m *n *n > > codi::EvaluationHelper::createHessianFixed ( )

inlinestatic

Create a Hessian with a compile time size.

Template Parameters

T	The storage type of the Hessian.
m	The size of the output vector.
n	The size of the input vector.

◆ createJacobian()

template<typename T = double>

static inlineJacobian< T > codi::EvaluationHelper::createJacobian	(	size_t	m,
		size_t	n )

inlinestatic

Create a Jacobian with the given size.

Parameters

[in]	m	The size of the output vector.
[in]	n	The size of the input vector.

Template Parameters

T	The storage type of the Jacobian.

◆ createJacobianFixed()

template<size_t m, size_t n, typename T = double>

static inlineJacobian< T, std::array< T, m *n > > codi::EvaluationHelper::createJacobianFixed ( )

inlinestatic

Create a Jacobian with a compile time size.

Template Parameters

T	The storage type of the Jacobian.
m	The size of the output vector.
n	The size of the input vector.

◆ evalHandleHessian()

template<typename Handle, typename VecX, typename Hes>

static inlinevoid codi::EvaluationHelper::evalHandleHessian	(	Handle &	handle,
		VecX const &	x,
		Hes &	hes )

inlinestatic

Compute the Hessian of the function object stored in the handle.

Parameters

[in]	handle	The handle with all data for the evaluation.
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	hes	The Hessian in which the values are stored.

Template Parameters

Handle	The handle type for the data storage and the evaluation.
VecX	The vector type for the input values. Element type is e.g. double.
Hes	The storage type of the Hessian. Element type is e.g. double.

◆ evalHandleJacobian()

template<typename Handle, typename VecX, typename Jac>

static inlinevoid codi::EvaluationHelper::evalHandleJacobian	(	Handle &	handle,
		VecX const &	x,
		Jac &	jac )

inlinestatic

Compute the Jacobian of the function object stored in the handle.

Parameters

[in]	handle	The handle with all data for the evaluation.
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	jac	The Jacobian in which the values are stored.

Template Parameters

Handle	The handle type for the data storage and the evaluation.
VecX	The vector type for the input values. Element type is e.g. double.
Jac	The storage type of the Jacobian. Element type is e.g. double.

◆ evalHandleJacobianAndHessian()

template<typename Handle, typename VecX, typename Jac, typename Hes>

static inlinevoid codi::EvaluationHelper::evalHandleJacobianAndHessian	(	Handle &	handle,
		VecX const &	x,
		Jac &	jac,
		Hes &	hes )

inlinestatic

Compute the Hessian of the evaluation procedure in the function object.

In this method the Jacobian is also stored.

Parameters

[in]	handle	The handle with all data for the evaluation.
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	jac	The Jacobian in which the values are stored.
[out]	hes	The Hessian in which the values are stored.

Template Parameters

Handle	The handle type for the data storage and the evaluation.
VecX	The vector type for the input values. Element type is e.g. double.
Jac	The storage type of the Jacobian. Element type is e.g. double.
Hes	The storage type of the Hessian. Element type is e.g. double.

◆ evalHandlePrimal()

template<typename Handle, typename VecX, typename VecY>

static inlinevoid codi::EvaluationHelper::evalHandlePrimal	(	Handle &	handle,
		VecX const &	x,
		VecY &	y )

inlinestatic

Perform a primal evaluation of the function object stored in the handle.

Parameters

[in]	handle	The handle with all data for the evaluation.
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	y	The vector for the result of the primal function evaluation. The vector must have the correct size allocated.

Template Parameters

Handle	The handle type for the data storage and the evaluation.
VecX	The vector type for the input values. Element type is e.g. double.
VecY	The vector type for the output values. Element type is e.g. double.

◆ evalHandlePrimalAndHessian()

template<typename Handle, typename VecX, typename VecY, typename Hes>

static inlinevoid codi::EvaluationHelper::evalHandlePrimalAndHessian	(	Handle &	handle,
		VecX const &	x,
		VecY &	y,
		Hes &	hes )

inlinestatic

Compute the primal result and Hessian of the function object.

Parameters

[in]	handle	The handle with all data for the evaluation.
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	y	The vector for the result of the primal function evaluation. The vector must have the correct size allocated.
[out]	hes	The Hessian in which the values are stored.

Template Parameters

Handle	The handle type for the data storage and the evaluation.
VecX	The vector type for the input values. Element type is e.g. double.
VecY	The vector type for the output values. Element type is e.g. double.
Hes	The storage type of the Hessian. Element type is e.g. double.

◆ evalHandlePrimalAndJacobian()

template<typename Handle, typename VecX, typename VecY, typename Jac>

static inlinevoid codi::EvaluationHelper::evalHandlePrimalAndJacobian	(	Handle &	handle,
		VecX const &	x,
		VecY &	y,
		Jac &	jac )

inlinestatic

Compute the primal result and Jacobian of the function object stored in the handle.

Parameters

[in]	handle	The handle with all data for the evaluation.
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	y	The vector for the result of the primal function evaluation. The vector must have the correct size allocated.
[out]	jac	The Jacobian in which the values are stored.

Template Parameters

Handle	The handle type for the data storage and the evaluation.
VecX	The vector type for the input values. Element type is e.g. double.
VecY	The vector type for the output values. Element type is e.g. double.
Jac	The storage type of the Jacobian. Element type is e.g. double.

◆ evalHandlePrimalAndJacobianAndHessian()

template<typename Handle, typename VecX, typename VecY, typename Jac, typename Hes>

static inlinevoid codi::EvaluationHelper::evalHandlePrimalAndJacobianAndHessian	(	Handle &	handle,
		VecX const &	x,
		VecY &	y,
		Jac &	jac,
		Hes &	hes )

inlinestatic

Compute the primal result, Jacobian, and Hessian of the function object.

Parameters

[in]	handle	The handle with all data for the evaluation.
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	y	The vector for the result of the primal function evaluation. The vector must have the correct size allocated.
[out]	jac	The Jacobian in which the values are stored.
[out]	hes	The Hessian in which the values are stored.

Template Parameters

Handle	The handle type for the data storage and the evaluation.
VecX	The vector type for the input values. Element type is e.g. double.
VecY	The vector type for the output values. Element type is e.g. double.
Jac	The storage type of the Jacobian. Element type is e.g. double.
Hes	The storage type of the Hessian. Element type is e.g. double.

◆ evalHessian()

template<typename Func, typename VecX, typename Hes>

static inlinevoid codi::EvaluationHelper::evalHessian	(	Func &	func,
		VecX const &	x,
		size_t const	ySize,
		Hes &	hes )

inlinestatic

Compute the Hessian of the function object.

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	x	The vector with the primal values where the function object is evaluated.
[in]	ySize	The size of the output vector.
[out]	hes	The Hessian in which the values are stored.

Template Parameters

Func	See FunctorInterface.
VecX	The vector type for the input values. Element type is e.g. double.
Hes	The storage type of the Hessian. Element type is e.g. double.

◆ evalJacobian()

template<typename Func, typename VecX, typename Jac>

static inlinevoid codi::EvaluationHelper::evalJacobian	(	Func &	func,
		VecX const &	x,
		size_t const	ySize,
		Jac &	jac )

inlinestatic

Compute the Jacobian of the function object.

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	x	The vector with the primal values where the function object is evaluated.
[in]	ySize	The size of the output vector.
[out]	jac	The Jacobian in which the values are stored.

Template Parameters

Func	See FunctorInterface.
VecX	The vector type for the input values. Element type is e.g. double.
Jac	The storage type of the Jacobian. Element type is e.g. double.

◆ evalJacobianAndHessian()

template<typename Func, typename VecX, typename Jac, typename Hes>

static inlinevoid codi::EvaluationHelper::evalJacobianAndHessian	(	Func &	func,
		VecX const &	x,
		size_t	ySize,
		Jac &	jac,
		Hes &	hes )

inlinestatic

Compute the Jacobian and Hessian of the function object.

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	x	The vector with the primal values where the function object is evaluated.
[in]	ySize	The size of the output vector.
[out]	jac	The Jacobian in which the values are stored.
[out]	hes	The Hessian in which the values are stored.

Template Parameters

Func	See FunctorInterface
VecX	The vector type for the input values. Element type is e.g. double.
Jac	The storage type of the Jacobian. Element type is e.g. double.
Hes	The storage type of the Hessian. Element type is e.g. double.

◆ evalPrimal()

template<typename Func, typename VecX, typename VecY>

static inlinevoid codi::EvaluationHelper::evalPrimal	(	Func &	func,
		VecX const &	x,
		VecY &	y )

inlinestatic

Perform a primal evaluation of the function object with the default first order type.

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	y	The vector for the result of the primal function evaluation. The vector must have the correct size allocated.

Template Parameters

Func	See FunctorInterface.
VecX	The vector type for the input values. Element type is e.g. double.
VecY	The vector type for the output values. Element type is e.g. double.

◆ evalPrimalAndHessian()

template<typename Func, typename VecX, typename VecY, typename Hes>

static inlinevoid codi::EvaluationHelper::evalPrimalAndHessian	(	Func &	func,
		VecX const &	x,
		VecY &	y,
		Hes &	hes )

inlinestatic

Compute the primal result and Hessian of the function object.

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	y	The vector for the result of the primal function evaluation. The vector must have the correct size allocated.
[out]	hes	The Hessian in which the values are stored.

Template Parameters

Func	See FunctorInterface.
VecX	The vector type for the input values. Element type is e.g. double.
VecY	The vector type for the output values. Element type is e.g. double.
Hes	The storage type of the Hessian. Element type is e.g. double.

◆ evalPrimalAndJacobian()

template<typename Func, typename VecX, typename VecY, typename Jac>

static inlinevoid codi::EvaluationHelper::evalPrimalAndJacobian	(	Func &	func,
		VecX const &	x,
		VecY &	y,
		Jac &	jac )

inlinestatic

Compute the primal result and Jacobian of the function object.

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	y	The vector for the result of the primal function evaluation. The vector must have the correct size allocated.
[out]	jac	The Jacobian in which the values are stored.

Template Parameters

Func	See FunctorInterface.
VecX	The vector type for the input values. Element type is e.g. double.
VecY	The vector type for the output values. Element type is e.g. double.
Jac	The storage type of the Jacobian. Element type is e.g. double.

◆ evalPrimalAndJacobianAndHessian()

template<typename Func, typename VecX, typename VecY, typename Jac, typename Hes>

static inlinevoid codi::EvaluationHelper::evalPrimalAndJacobianAndHessian	(	Func &	func,
		VecX const &	x,
		VecY &	y,
		Jac &	jac,
		Hes &	hes )

inlinestatic

Compute the primal result, Jacobian, and Hessian of the function object.

Parameters

[in]	func	The function object for the evaluation (see FunctorInterface).
[in]	x	The vector with the primal values where the function object is evaluated.
[out]	y	The vector for the result of the primal function evaluation. The vector must have the correct size allocated.
[out]	jac	The Jacobian in which the values are stored.
[out]	hes	The Hessian in which the values are stored.

Template Parameters

Func	See FunctorInterface.
VecX	The vector type for the input values. Element type is e.g. double.
VecY	The vector type for the output values. Element type is e.g. double.
Jac	The storage type of the Jacobian. Element type is e.g. double.
Hes	The storage type of the Hessian. Element type is e.g. double.

The documentation for this struct was generated from the following file:

include/codi/tools/helpers/evaluationHelper.hpp

Public Types

Static Public Member Functions

Detailed Description

Advanced function object definitions

Member Typedef Documentation

◆ DefaultHandle

◆ DefaultHandle2nd

◆ DefaultHandleFixed

◆ DefaultHandleFixed2nd

◆ FunctorInterface

◆ HessianComputationType

◆ JacobianComputationType

Member Function Documentation

◆ createHandle()

◆ createHandleDefault()

◆ createHandleDefault2nd()

◆ createHandleDefaultFixed()

◆ createHandleDefaultFixed2nd()

◆ createHandleFixed()

◆ createHandleFull()

◆ createHessian()

◆ createHessianFixed()

◆ createJacobian()

◆ createJacobianFixed()

◆ evalHandleHessian()

◆ evalHandleJacobian()

◆ evalHandleJacobianAndHessian()

◆ evalHandlePrimal()

◆ evalHandlePrimalAndHessian()

◆ evalHandlePrimalAndJacobian()

◆ evalHandlePrimalAndJacobianAndHessian()

◆ evalHessian()

◆ evalJacobian()

◆ evalJacobianAndHessian()

◆ evalPrimal()

◆ evalPrimalAndHessian()

◆ evalPrimalAndJacobian()

◆ evalPrimalAndJacobianAndHessian()