Provides the interface to evaluate objective functions. More...

#include <ROL_Objective.hpp>

Inheritance diagram for ROL::Objective< Real >:

Public Member Functions
virtual	~Objective ()

virtual void	update (const Vector< Real > &x, bool flag=true, int iter=-1)
	Update objective function. More...

virtual Real	value (const Vector< Real > &x, Real &tol)=0
	Compute value. More...

virtual void	gradient (Vector< Real > &g, const Vector< Real > &x, Real &tol)
	Compute gradient. More...

virtual Real	dirDeriv (const Vector< Real > &x, const Vector< Real > &d, Real &tol)
	Compute directional derivative. More...

virtual void	hessVec (Vector< Real > &hv, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
	Apply Hessian approximation to vector. More...

virtual void	invHessVec (Vector< Real > &hv, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
	Apply inverse Hessian approximation to vector. More...

virtual void	precond (Vector< Real > &Pv, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
	Apply preconditioner to vector. More...

virtual std::vector < std::vector< Real > >	checkGradient (const Vector< Real > &x, const Vector< Real > &d, const bool printToStream=true, std::ostream &outStream=std::cout, const int numSteps=ROL_NUM_CHECKDERIV_STEPS, const int order=1)
	Finite-difference gradient check. More...

virtual std::vector < std::vector< Real > >	checkGradient (const Vector< Real > &x, const Vector< Real > &g, const Vector< Real > &d, const bool printToStream=true, std::ostream &outStream=std::cout, const int numSteps=ROL_NUM_CHECKDERIV_STEPS, const int order=1)
	Finite-difference gradient check. More...

virtual std::vector < std::vector< Real > >	checkGradient (const Vector< Real > &x, const Vector< Real > &d, const std::vector< Real > &steps, const bool printToStream=true, std::ostream &outStream=std::cout, const int order=1)
	Finite-difference gradient check with specified step sizes. More...

virtual std::vector < std::vector< Real > >	checkGradient (const Vector< Real > &x, const Vector< Real > &g, const Vector< Real > &d, const std::vector< Real > &steps, const bool printToStream=true, std::ostream &outStream=std::cout, const int order=1)
	Finite-difference gradient check with specified step sizes. More...

virtual std::vector < std::vector< Real > >	checkHessVec (const Vector< Real > &x, const Vector< Real > &v, const bool printToStream=true, std::ostream &outStream=std::cout, const int numSteps=ROL_NUM_CHECKDERIV_STEPS, const int order=1)
	Finite-difference Hessian-applied-to-vector check. More...

virtual std::vector < std::vector< Real > >	checkHessVec (const Vector< Real > &x, const Vector< Real > &hv, const Vector< Real > &v, const bool printToStream=true, std::ostream &outStream=std::cout, const int numSteps=ROL_NUM_CHECKDERIV_STEPS, const int order=1)
	Finite-difference Hessian-applied-to-vector check. More...

virtual std::vector < std::vector< Real > >	checkHessVec (const Vector< Real > &x, const Vector< Real > &v, const std::vector< Real > &steps, const bool printToStream=true, std::ostream &outStream=std::cout, const int order=1)
	Finite-difference Hessian-applied-to-vector check with specified step sizes. More...

virtual std::vector < std::vector< Real > >	checkHessVec (const Vector< Real > &x, const Vector< Real > &hv, const Vector< Real > &v, const std::vector< Real > &steps, const bool printToStream=true, std::ostream &outStream=std::cout, const int order=1)
	Finite-difference Hessian-applied-to-vector check with specified step sizes. More...

virtual std::vector< Real >	checkHessSym (const Vector< Real > &x, const Vector< Real > &v, const Vector< Real > &w, const bool printToStream=true, std::ostream &outStream=std::cout)
	Hessian symmetry check. More...

virtual std::vector< Real >	checkHessSym (const Vector< Real > &x, const Vector< Real > &hv, const Vector< Real > &v, const Vector< Real > &w, const bool printToStream=true, std::ostream &outStream=std::cout)
	Hessian symmetry check. More...

virtual void	setParameter (const std::vector< Real > &param)

Protected Member Functions
const std::vector< Real >	getParameter (void) const

Private Attributes
std::vector< Real >	param_

Detailed Description

template<class Real>
class ROL::Objective< Real >

Provides the interface to evaluate objective functions.

Provides the definition of the objective function interface.

ROL's objective function interface is designed for Fr$eacute;chet differentiable functionals $f:\mathcal{X}\to\mathbb{R}$, where $\mathcal{X}$ is a Banach space. The basic operator interace, to be implemented by the user, requires:

value – objective function evaluation.

It is strongly recommended that the user additionally overload:

gradient – the objective function gradient – the default is a finite-difference approximation;
hessVec – the action of the Hessian – the default is a finite-difference approximation.

The user may also overload:

update – update the objective function at each new iteration;
dirDeriv – compute the directional derivative – the default is a finite-difference approximation;
invHessVec – the action of the inverse Hessian;
precond – the action of a preconditioner for the Hessian.

Definition at line 77 of file ROL_Objective.hpp.

Constructor & Destructor Documentation

template<class Real>

virtual ROL::Objective< Real >::~Objective ( )

inlinevirtual

Definition at line 80 of file ROL_Objective.hpp.

Member Function Documentation

template<class Real>

virtual void ROL::Objective< Real >::update	(	const Vector< Real > &	x,
		bool	flag = `true`,
		int	iter = `-1`
	)

inlinevirtual

Update objective function.

This function updates the objective function at new iterations.

Parameters

[in]	x	is the new iterate.
[in]	flag	is true if the iterate has changed.
[in]	iter	is the outer algorithm iterations count.

Definition at line 89 of file ROL_Objective.hpp.

References ROL_UNUSED.

template<class Real>

virtual Real ROL::Objective< Real >::value	(	const Vector< Real > &	x,
		Real &	tol
	)

pure virtual

Compute value.

This function returns the objective function value.

Parameters

[in]	x	is the current iterate.
[in]	tol	is a tolerance for inexact objective function computation.

template<class Real >

void ROL::Objective< Real >::gradient	(	Vector< Real > &	g,
		const Vector< Real > &	x,
		Real &	tol
	)

virtual

Compute gradient.

This function returns the objective function gradient.

Parameters

[out]	g	is the gradient.
[in]	x	is the current iterate.
[in]	tol	is a tolerance for inexact objective function computation.

The default implementation is a finite-difference approximation based on the function value. This requires the definition of a basis $\{\phi_i\}$ for the optimization vectors x and the definition of a basis $\{\psi_j\}$ for the dual optimization vectors (gradient vectors g). The bases must be related through the Riesz map, i.e., $ R \{\phi_i\} = \{\psi_j\}$, and this must be reflected in the implementation of the ROL::Vector::dual() method.

Definition at line 71 of file ROL_ObjectiveDef.hpp.

References ROL::Vector< Real >::axpy(), ROL::Vector< Real >::basis(), ROL::Vector< Real >::clone(), ROL::Vector< Real >::dimension(), ROL::Vector< Real >::dot(), ROL::update(), ROL::value, zero, and ROL::Vector< Real >::zero().

template<class Real >

Real ROL::Objective< Real >::dirDeriv	(	const Vector< Real > &	x,
		const Vector< Real > &	d,
		Real &	tol
	)

virtual

Compute directional derivative.

This function returns the directional derivative of the objective function in the $d$ direction.

Parameters

[in]	x	is the current iterate.
[in]	d	is the direction.
[in]	tol	is a tolerance for inexact objective function computation.

Reimplemented in ROL::ProjectedObjective< Real >, ROL::ZOO::Objective_Zakharov< Real >, ROL::StdObjective< Real >, ROL::SlacklessObjective< Real >, and ROL::LogBarrierObjective< Real >.

Definition at line 54 of file ROL_ObjectiveDef.hpp.

References ROL::Vector< Real >::clone(), ROL::Vector< Real >::norm(), ROL::update(), ROL::value, and zero.

Referenced by ROL::StdObjective< Real >::dirDeriv().

template<class Real >

void ROL::Objective< Real >::hessVec	(	Vector< Real > &	hv,
		const Vector< Real > &	v,
		const Vector< Real > &	x,
		Real &	tol
	)

virtual

Apply Hessian approximation to vector.

This function applies the Hessian of the objective function to the vector $v$.

Parameters

[out]	hv	is the the action of the Hessian on $v$.
[in]	v	is the direction vector.
[in]	x	is the current iterate.
[in]	tol	is a tolerance for inexact objective function computation.

Definition at line 90 of file ROL_ObjectiveDef.hpp.

References ROL::Vector< Real >::axpy(), ROL::Vector< Real >::clone(), ROL::Vector< Real >::norm(), ROL::Vector< Real >::scale(), ROL::update(), zero, and ROL::Vector< Real >::zero().

Referenced by ROL::CompositeStep< Real >::accept(), ROL::PrimalDualActiveSetStep< Real >::compute(), ROL::computeDenseHessian(), ROL::RandVarFunctional< Real >::computeHessVec(), ROL::computeScaledDenseHessian(), ROL::StdObjective< Real >::hessVec(), ROL::ZOO::Objective_DiodeCircuit< Real >::hessVec(), ROL::Reduced_Objective_SimOpt< Real >::hessVec(), ROL::ReducedDynamicObjective< Real >::hessVec(), ROL::TrustRegionStep< Real >::initialize(), main(), and ROL::CompositeStep< Real >::solveTangentialSubproblem().

template<class Real>

virtual void ROL::Objective< Real >::invHessVec	(	Vector< Real > &	hv,
		const Vector< Real > &	v,
		const Vector< Real > &	x,
		Real &	tol
	)

inlinevirtual

Apply inverse Hessian approximation to vector.

This function applies the inverse Hessian of the objective function to the vector $v$.

Parameters

[out]	hv	is the action of the inverse Hessian on $v$.
[in]	v	is the direction vector.
[in]	x	is the current iterate.
[in]	tol	is a tolerance for inexact objective function computation.

Definition at line 145 of file ROL_Objective.hpp.

References ROL_UNUSED.

Referenced by ROL::NewtonStep< Real >::compute(), ROL::ProjectedNewtonStep< Real >::compute(), and ROL::TrustRegionStep< Real >::initialize().

template<class Real>

virtual void ROL::Objective< Real >::precond	(	Vector< Real > &	Pv,
		const Vector< Real > &	v,
		const Vector< Real > &	x,
		Real &	tol
	)

inlinevirtual

Apply preconditioner to vector.

This function applies a preconditioner for the Hessian of the objective function to the vector $v$.

Parameters

[out]	Pv	is the action of the Hessian preconditioner on $v$.
[in]	v	is the direction vector.
[in]	x	is the current iterate.
[in]	tol	is a tolerance for inexact objective function computation.

Reimplemented in ROL::Reduced_Objective_SimOpt< Real >, ROL::ProjectedObjective< Real >, ROL::StochasticObjective< Real >, ROL::RiskNeutralObjective< Real >, ROL::KelleySachsModel< Real >, ROL::TrustRegionModel< Real >, ROL::StdObjective< Real >, ROL::ConicApproximationModel< Real >, ROL::NonlinearLeastSquaresObjective_Dynamic< Real >, ROL::ROL::NonlinearLeastSquaresObjective_SimOpt< Real >, ROL::NonlinearLeastSquaresObjective_SimOpt< Real >, ROL::SlacklessObjective< Real >, and ROL::RiskLessObjective< Real >.

Definition at line 163 of file ROL_Objective.hpp.

References ROL::Vector< Real >::dual(), ROL_UNUSED, and ROL::Vector< Real >::set().

template<class Real>

virtual std::vector<std::vector<Real> > ROL::Objective< Real >::checkGradient	(	const Vector< Real > &	x,
		const Vector< Real > &	d,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`,
		const int	numSteps = `ROL_NUM_CHECKDERIV_STEPS`,
		const int	order = `1`
	)

inlinevirtual

Finite-difference gradient check.

This function computes a sequence of one-sided finite-difference checks for the gradient. At each step of the sequence, the finite difference step size is decreased. The output compares the error

\[ \left| \frac{f(x+td) - f(x)}{t} - \langle \nabla f(x),d\rangle_{\mathcal{X}^*,\mathcal{X}}\right|. \]

if the approximation is first order. More generally, difference approximation is

\[ \frac{1}{t} \sum\limits_{i=1}^m w_i f(x+t c_i d) \]

where m = order+1, $w_i$ are the difference weights and $c_i$ are the difference steps

Parameters

[in]	x	is an optimization variable.
[in]	d	is a direction vector.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.
[in]	numSteps	is a parameter which dictates the number of finite difference steps.
[in]	order	is the order of the finite difference approximation (1,2,3,4)

Definition at line 189 of file ROL_Objective.hpp.

References ROL::Vector< Real >::dual().

Referenced by ROL::Objective< Real >::checkGradient(), and main().

template<class Real >

std::vector< std::vector< Real > > ROL::Objective< Real >::checkGradient	(	const Vector< Real > &	x,
		const Vector< Real > &	g,
		const Vector< Real > &	d,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`,
		const int	numSteps = `ROL_NUM_CHECKDERIV_STEPS`,
		const int	order = `1`
	)

virtual

Finite-difference gradient check.

This function computes a sequence of one-sided finite-difference checks for the gradient. At each step of the sequence, the finite difference step size is decreased. The output compares the error

\[ \left| \frac{f(x+td) - f(x)}{t} - \langle \nabla f(x),d\rangle_{\mathcal{X}^*,\mathcal{X}}\right|. \]

if the approximation is first order. More generally, difference approximation is

\[ \frac{1}{t} \sum\limits_{i=1}^m w_i f(x+t c_i d) \]

where m = order+1, $w_i$ are the difference weights and $c_i$ are the difference steps

Parameters

[in]	x	is an optimization variable.
[in]	g	is used to create a temporary gradient vector.
[in]	d	is a direction vector.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.
[in]	numSteps	is a parameter which dictates the number of finite difference steps.
[in]	order	is the order of the finite difference approximation (1,2,3,4)

Definition at line 127 of file ROL_ObjectiveDef.hpp.

template<class Real>

virtual std::vector<std::vector<Real> > ROL::Objective< Real >::checkGradient	(	const Vector< Real > &	x,
		const Vector< Real > &	d,
		const std::vector< Real > &	steps,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`,
		const int	order = `1`
	)

inlinevirtual

Finite-difference gradient check with specified step sizes.

This function computes a sequence of one-sided finite-difference checks for the gradient. At each step of the sequence, the finite difference step size is decreased. The output compares the error

\[ \left| \frac{f(x+td) - f(x)}{t} - \langle \nabla f(x),d\rangle_{\mathcal{X}^*,\mathcal{X}}\right|. \]

if the approximation is first order. More generally, difference approximation is

\[ \frac{1}{t} \sum\limits_{i=1}^m w_i f(x+t c_i d) \]

where m = order+1, $w_i$ are the difference weights and $c_i$ are the difference steps

Parameters

[in]	x	is an optimization variable.
[in]	d	is a direction vector.
[in]	steps	is vector of steps of user-specified size.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.
[in]	order	is the order of the finite difference approximation (1,2,3,4)

Definition at line 249 of file ROL_Objective.hpp.

References ROL::Objective< Real >::checkGradient(), and ROL::Vector< Real >::dual().

template<class Real >

std::vector< std::vector< Real > > ROL::Objective< Real >::checkGradient	(	const Vector< Real > &	x,
		const Vector< Real > &	g,
		const Vector< Real > &	d,
		const std::vector< Real > &	steps,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`,
		const int	order = `1`
	)

virtual

Finite-difference gradient check with specified step sizes.

This function computes a sequence of one-sided finite-difference checks for the gradient. At each step of the sequence, the finite difference step size is decreased. The output compares the error

\[ \left| \frac{f(x+td) - f(x)}{t} - \langle \nabla f(x),d\rangle_{\mathcal{X}^*,\mathcal{X}}\right|. \]

if the approximation is first order. More generally, difference approximation is

\[ \frac{1}{t} \sum\limits_{i=1}^m w_i f(x+t c_i d) \]

where m = order+1, $w_i$ are the difference weights and $c_i$ are the difference steps

Parameters

[in]	x	is an optimization variable.
[in]	g	is used to create a temporary gradient vector.
[in]	d	is a direction vector.
[in]	steps	is vector of steps of user-specified size.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.
[in]	order	is the order of the finite difference approximation (1,2,3,4)

Definition at line 147 of file ROL_ObjectiveDef.hpp.

References ROL::Vector< Real >::clone(), ROL::Vector< Real >::dot(), ROL::Finite_Difference_Arrays::shifts, ROL::update(), ROL::value, and ROL::Finite_Difference_Arrays::weights.

template<class Real>

virtual std::vector<std::vector<Real> > ROL::Objective< Real >::checkHessVec	(	const Vector< Real > &	x,
		const Vector< Real > &	v,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`,
		const int	numSteps = `ROL_NUM_CHECKDERIV_STEPS`,
		const int	order = `1`
	)

inlinevirtual

Finite-difference Hessian-applied-to-vector check.

This function computes a sequence of one-sided finite-difference checks for the Hessian. At each step of the sequence, the finite difference step size is decreased. The output compares the error

\[ \left\| \frac{\nabla f(x+tv) - \nabla f(x)}{t} - \nabla^2 f(x)v\right\|_{\mathcal{X}^*}, \]

if the approximation is first order. More generally, difference approximation is

\[ \frac{1}{t} \sum\limits_{i=1}^m w_i \nabla f(x+t c_i v), \]

where m = order+1, $w_i$ are the difference weights and $c_i$ are the difference steps

Parameters

[in]	x	is an optimization variable.
[in]	v	is a direction vector.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.
[in]	numSteps	is a parameter which dictates the number of finite difference steps.
[in]	order	is the order of the finite difference approximation (1,2,3,4)

Definition at line 311 of file ROL_Objective.hpp.

References ROL::Vector< Real >::dual().

Referenced by ROL::Objective< Real >::checkHessVec(), and main().

template<class Real >

std::vector< std::vector< Real > > ROL::Objective< Real >::checkHessVec	(	const Vector< Real > &	x,
		const Vector< Real > &	hv,
		const Vector< Real > &	v,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`,
		const int	numSteps = `ROL_NUM_CHECKDERIV_STEPS`,
		const int	order = `1`
	)

virtual

Finite-difference Hessian-applied-to-vector check.

This function computes a sequence of one-sided finite-difference checks for the Hessian. At each step of the sequence, the finite difference step size is decreased. The output compares the error

\[ \left\| \frac{\nabla f(x+tv) - \nabla f(x)}{t} - \nabla^2 f(x)v\right\|_{\mathcal{X}^*}, \]

if the approximation is first order. More generally, difference approximation is

\[ \frac{1}{t} \sum\limits_{i=1}^m w_i \nabla f(x+t c_i v), \]

where m = order+1, $w_i$ are the difference weights and $c_i$ are the difference steps

Parameters

[in]	x	is an optimization variable.
[in]	hv	is used to create temporary gradient and Hessian-times-vector vectors.
[in]	v	is a direction vector.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.
[in]	numSteps	is a parameter which dictates the number of finite difference steps.
[in]	order	is the order of the finite difference approximation (1,2,3,4)

Definition at line 249 of file ROL_ObjectiveDef.hpp.

template<class Real>

virtual std::vector<std::vector<Real> > ROL::Objective< Real >::checkHessVec	(	const Vector< Real > &	x,
		const Vector< Real > &	v,
		const std::vector< Real > &	steps,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`,
		const int	order = `1`
	)

inlinevirtual

Finite-difference Hessian-applied-to-vector check with specified step sizes.

This function computes a sequence of one-sided finite-difference checks for the Hessian. At each step of the sequence, the finite difference step size is decreased. The output compares the error

\[ \left\| \frac{\nabla f(x+tv) - \nabla f(x)}{t} - \nabla^2 f(x)v\right\|_{\mathcal{X}^*}, \]

if the approximation is first order. More generally, difference approximation is

\[ \frac{1}{t} \sum\limits_{i=1}^m w_i \nabla f(x+t c_i v), \]

where m = order+1, $w_i$ are the difference weights and $c_i$ are the difference steps

Parameters

[in]	x	is an optimization variable.
[in]	v	is a direction vector.
[in]	steps	is vector of steps of user-specified size.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.
[in]	order	is the order of the finite difference approximation (1,2,3,4)

Definition at line 372 of file ROL_Objective.hpp.

References ROL::Objective< Real >::checkHessVec(), and ROL::Vector< Real >::dual().

template<class Real >

std::vector< std::vector< Real > > ROL::Objective< Real >::checkHessVec	(	const Vector< Real > &	x,
		const Vector< Real > &	hv,
		const Vector< Real > &	v,
		const std::vector< Real > &	steps,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`,
		const int	order = `1`
	)

virtual

Finite-difference Hessian-applied-to-vector check with specified step sizes.

This function computes a sequence of one-sided finite-difference checks for the Hessian. At each step of the sequence, the finite difference step size is decreased. The output compares the error

\[ \left\| \frac{\nabla f(x+tv) - \nabla f(x)}{t} - \nabla^2 f(x)v\right\|_{\mathcal{X}^*}, \]

if the approximation is first order. More generally, difference approximation is

\[ \frac{1}{t} \sum\limits_{i=1}^m w_i \nabla f(x+t c_i v), \]

where m = order+1, $w_i$ are the difference weights and $c_i$ are the difference steps

Parameters

[in]	x	is an optimization variable.
[in]	hv	is used to create temporary gradient and Hessian-times-vector vectors.
[in]	v	is a direction vector.
[in]	steps	is vector of steps of user-specified size.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.
[in]	order	is the order of the finite difference approximation (1,2,3,4)

Definition at line 267 of file ROL_ObjectiveDef.hpp.

References ROL::Vector< Real >::clone(), ROL::Finite_Difference_Arrays::shifts, ROL::update(), and ROL::Finite_Difference_Arrays::weights.

template<class Real>

virtual std::vector<Real> ROL::Objective< Real >::checkHessSym	(	const Vector< Real > &	x,
		const Vector< Real > &	v,
		const Vector< Real > &	w,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`
	)

inlinevirtual

Hessian symmetry check.

This function checks the symmetry of the Hessian by comparing

\[ \langle \nabla^2f(x)v,w\rangle_{\mathcal{X}^*,\mathcal{X}} \quad\text{and}\quad \langle \nabla^2f(x)w,v\rangle_{\mathcal{X}^*,\mathcal{X}}. \]

Parameters

[in]	x	is an optimization variable.
[in]	v	is a direction vector.
[in]	w	is a direction vector.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.

Definition at line 427 of file ROL_Objective.hpp.

References ROL::Vector< Real >::dual().

Referenced by main().

template<class Real >

std::vector< Real > ROL::Objective< Real >::checkHessSym	(	const Vector< Real > &	x,
		const Vector< Real > &	hv,
		const Vector< Real > &	v,
		const Vector< Real > &	w,
		const bool	printToStream = `true`,
		std::ostream &	outStream = `std::cout`
	)

virtual

Hessian symmetry check.

This function checks the symmetry of the Hessian by comparing

\[ \langle \nabla^2f(x)v,w\rangle_{\mathcal{X}^*,\mathcal{X}} \quad\text{and}\quad \langle \nabla^2f(x)w,v\rangle_{\mathcal{X}^*,\mathcal{X}}. \]

Parameters

[in]	x	is an optimization variable.
[in]	hv	is used to create temporary Hessian-times-vector vectors.
[in]	v	is a direction vector.
[in]	w	is a direction vector.
[in]	printToStream	is a flag that turns on/off output.
[out]	outStream	is the output stream.

Definition at line 374 of file ROL_ObjectiveDef.hpp.

References ROL::Vector< Real >::clone(), and ROL::Vector< Real >::dot().

template<class Real>

const std::vector<Real> ROL::Objective< Real >::getParameter ( void ) const

inlineprotected

Definition at line 464 of file ROL_Objective.hpp.

References ROL::Objective< Real >::param_.

Referenced by ROL::RegressionError< Real >::checkSize(), ROL::RegressionError< Real >::gradient(), DiffusionObjective< Real >::gradient_1(), DiffusionObjective< Real >::hessVec_11(), ROL::RegressionError< Real >::value(), and DiffusionObjective< Real >::value().

template<class Real>

virtual void ROL::Objective< Real >::setParameter ( const std::vector< Real > & param )

inlinevirtual

Definition at line 469 of file ROL_Objective.hpp.

References ROL::Objective< Real >::param_.

Member Data Documentation

template<class Real>

std::vector<Real> ROL::Objective< Real >::param_

private

Definition at line 461 of file ROL_Objective.hpp.

Referenced by ROL::Objective< Real >::getParameter(), and ROL::Objective< Real >::setParameter().

The documentation for this class was generated from the following files:

[out]	hv	is the the action of the Hessian on \(v\).
[in]	v	is the direction vector.
[in]	x	is the current iterate.
[in]	tol	is a tolerance for inexact objective function computation.

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

template<class Real> class ROL::Objective< Real >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class Real>
class ROL::Objective< Real >