ObjectiveFunction Class Reference

Base class for concrete Objective Functions ObjectiveFunction contains a pointer to a QualityMetric. If the ObjectiveFunction is associated with more than one QualityMetric (i.e., the Objective is a composite, and the composed ObjectiveFunctions are associated with different QualityMetrics), then the QualityMetric pointer is set to NULL.. More...

#include <ObjectiveFunction.hpp>

Inheritance diagram for ObjectiveFunction:

Collaboration diagram for ObjectiveFunction:

Public Types
enum	GRADIENT_TYPE { NUMERICAL_GRADIENT, ANALYTICAL_GRADIENT, NUMERICAL_GRADIENT, ANALYTICAL_GRADIENT }
enum	GRADIENT_TYPE { NUMERICAL_GRADIENT, ANALYTICAL_GRADIENT, NUMERICAL_GRADIENT, ANALYTICAL_GRADIENT }

Public Member Functions
	ObjectiveFunction ()
virtual	~ObjectiveFunction ()
virtual bool	concrete_evaluate (PatchData &patch, double &fval, MsqError &err)=0
bool	evaluate (PatchData &patch, double &fval, MsqError &err)
void	set_gradient_type (GRADIENT_TYPE grad)
	Set gradType to either NUMERICAL_GRADIENT or ANALYTICAL_GRADIENT. More...
bool	compute_gradient (PatchData &patch, Vector3D *const &grad, double &OF_val, MsqError &err, size_t array_size=0)
	Calls either compute_numerical_gradient or compute_analytical_gradient depending on the value of gradType. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'. More...
bool	compute_hessian (PatchData &patch, MsqHessian &hessian, Vector3D *const &grad, double &OF_val, MsqError &err)
	Calls compute_analytical_hessian. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'. More...
QualityMetric *	get_quality_metric ()
virtual msq_std::list < QualityMetric * >	get_quality_metric_list ()
void	set_quality_metric (QualityMetric *qm)
	Set the value of qMetric. More...
void	set_negate_flag (int neg)
	Set the value of ObjectiveFunction's negateFlag. Unless composite, concrete ObjectiveFunctions should set this flag to to the value of the associated QualityMetric's negateFLag. More...
int	get_negate_flag ()
	Returns negateFlag. More...
	ObjectiveFunction ()
virtual	~ObjectiveFunction ()
virtual bool	concrete_evaluate (PatchData &patch, double &fval, MsqError &err)=0
bool	evaluate (PatchData &patch, double &fval, MsqError &err)
void	set_gradient_type (GRADIENT_TYPE grad)
	Set gradType to either NUMERICAL_GRADIENT or ANALYTICAL_GRADIENT. More...
bool	compute_gradient (PatchData &patch, Vector3D *const &grad, double &OF_val, MsqError &err, size_t array_size=0)
	Calls either compute_numerical_gradient or compute_analytical_gradient depending on the value of gradType. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'. More...
bool	compute_hessian (PatchData &patch, MsqHessian &hessian, Vector3D *const &grad, double &OF_val, MsqError &err)
	Calls compute_analytical_hessian. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'. More...
QualityMetric *	get_quality_metric ()
virtual msq_std::list < QualityMetric * >	get_quality_metric_list ()
void	set_quality_metric (QualityMetric *qm)
	Set the value of qMetric. More...
void	set_negate_flag (int neg)
	Set the value of ObjectiveFunction's negateFlag. Unless composite, concrete ObjectiveFunctions should set this flag to to the value of the associated QualityMetric's negateFLag. More...
int	get_negate_flag ()
	Returns negateFlag. More...

Protected Member Functions
bool	compute_numerical_gradient (PatchData &patch, Vector3D *const &grad, double &OF_val, MsqError &err, size_t array_size)
	Non-virtual function which numerically computes the gradient of the Objective Function. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'. More...
virtual bool	compute_analytical_gradient (PatchData &patch, Vector3D *const &grad, double &OF_val, MsqError &err, size_t array_size)
virtual bool	compute_analytical_hessian (PatchData &, MsqHessian &, Vector3D *const &, double &, MsqError &)
double	get_eps (PatchData &pd, double &local_val, int k, MsqVertex *vertex, MsqError &err)
	Returns eps used in the numerical gradient calculation. More...
void	set_use_local_gradient (bool new_bool)
	Sets useLocalGradient This variable determines whether compute_numercial_gradient can use the most efficient gradient calculation. More...
bool	compute_numerical_gradient (PatchData &patch, Vector3D *const &grad, double &OF_val, MsqError &err, size_t array_size)
	Non-virtual function which numerically computes the gradient of the Objective Function. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'. More...
virtual bool	compute_analytical_gradient (PatchData &patch, Vector3D *const &grad, double &OF_val, MsqError &err, size_t array_size)
virtual bool	compute_analytical_hessian (PatchData &, MsqHessian &, Vector3D *const &, double &, MsqError &)
double	get_eps (PatchData &pd, double &local_val, int k, MsqVertex *vertex, MsqError &err)
	Returns eps used in the numerical gradient calculation. More...
void	set_use_local_gradient (bool new_bool)
	Sets useLocalGradient This variable determines whether compute_numercial_gradient can use the most efficient gradient calculation. More...

Private Attributes
enum GRADIENT_TYPE	gradType
QualityMetric *	qMetric
	Flag for numerical or analytical gradient. More...
int	negateFlag
	Pointer to associated QualityMetric. More...
bool	useLocalGradient

Detailed Description

Base class for concrete Objective Functions ObjectiveFunction contains a pointer to a QualityMetric. If the ObjectiveFunction is associated with more than one QualityMetric (i.e., the Objective is a composite, and the composed ObjectiveFunctions are associated with different QualityMetrics), then the QualityMetric pointer is set to NULL..

Definition at line 67 of file includeLinks/ObjectiveFunction.hpp.

Member Enumeration Documentation

enum GRADIENT_TYPE

Enumerator
NUMERICAL_GRADIENT	can be very slow. Should be for tests only.
ANALYTICAL_GRADIENT	every differentiable function should have an analytical gradient implemented.
NUMERICAL_GRADIENT	can be very slow. Should be for tests only.
ANALYTICAL_GRADIENT	every differentiable function should have an analytical gradient implemented.

Definition at line 102 of file includeLinks/ObjectiveFunction.hpp.

    {
       NUMERICAL_GRADIENT,  
       ANALYTICAL_GRADIENT  
    };

enum GRADIENT_TYPE

Enumerator
NUMERICAL_GRADIENT	can be very slow. Should be for tests only.
ANALYTICAL_GRADIENT	every differentiable function should have an analytical gradient implemented.
NUMERICAL_GRADIENT	can be very slow. Should be for tests only.
ANALYTICAL_GRADIENT	every differentiable function should have an analytical gradient implemented.

Definition at line 102 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

    {
       NUMERICAL_GRADIENT,  
       ANALYTICAL_GRADIENT  
    };

Constructor & Destructor Documentation

ObjectiveFunction ( )

inline

Definition at line 70 of file includeLinks/ObjectiveFunction.hpp.

                        :
        useLocalGradient(false)
       {}

virtual ~ObjectiveFunction ( )

inlinevirtual

Definition at line 76 of file includeLinks/ObjectiveFunction.hpp.

       {};

ObjectiveFunction ( )

inline

Definition at line 70 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

                        :
        useLocalGradient(false)
       {}

virtual ~ObjectiveFunction ( )

inlinevirtual

Definition at line 76 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

       {};

Member Function Documentation

bool compute_analytical_gradient ( PatchData &  patch, Vector3D *const &  grad, double &  OF_val, MsqError &  err, size_t  array_size  )

protectedvirtual

Fills an array of Vector3D, grad, with the gradient of the objective function computed using the gradient of the quality metric. If the function has not been over-riden in the concrete Objective Function, the base class implementation prints a warning and then defaults to numerical gradient. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

Parameters

patch	The PatchData object for which the objective function gradient is computed.
grad	An array of Vector3D, at least the size of the number of vertices in the patch.
OF_val	is set to the value of the objective function.
array_size	is the size of the grad Vector3D[] array and must correspond to the number of vertices in the patch.

Reimplemented in LPtoPTemplate, LPtoPTemplate, MaxTemplate, MaxTemplate, CompositeOFScalarMultiply, LInfTemplate, CompositeOFScalarMultiply, LInfTemplate, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFMultiply, and CompositeOFMultiply.

Definition at line 152 of file ObjectiveFunction/ObjectiveFunction.cpp.

References ObjectiveFunction::compute_numerical_gradient(), MSQ_CHKERR, ObjectiveFunction::NUMERICAL_GRADIENT, and ObjectiveFunction::set_gradient_type().

Referenced by ObjectiveFunction::compute_gradient().

                                                                              {
      set_gradient_type(NUMERICAL_GRADIENT);
      bool result = compute_numerical_gradient(patch, grad, OF_val, err, array_size);
      return !MSQ_CHKERR(err) && result;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual bool compute_analytical_gradient ( PatchData &  patch, Vector3D *const &  grad, double &  OF_val, MsqError &  err, size_t  array_size  )

protectedvirtual

Fills an array of Vector3D, grad, with the gradient of the objective function computed using the gradient of the quality metric. If the function has not been over-riden in the concrete Objective Function, the base class implementation prints a warning and then defaults to numerical gradient. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

Parameters

patch	The PatchData object for which the objective function gradient is computed.
grad	An array of Vector3D, at least the size of the number of vertices in the patch.
OF_val	is set to the value of the objective function.
array_size	is the size of the grad Vector3D[] array and must correspond to the number of vertices in the patch.

Reimplemented in LPtoPTemplate, LPtoPTemplate, MaxTemplate, MaxTemplate, CompositeOFScalarMultiply, LInfTemplate, CompositeOFScalarMultiply, LInfTemplate, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFMultiply, and CompositeOFMultiply.

bool compute_analytical_hessian ( PatchData &  , MsqHessian &  , Vector3D *const &  , double &  , MsqError &  err  )

protectedvirtual

Fills a MsqHessian object with the Hessian of the objective function computed using the hessian of the quality metric. If the function has not been over-riden in the concrete Objective Function, the base class implementation prints a warning and returns false. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

Reimplemented in LPtoPTemplate, and LPtoPTemplate.

Definition at line 161 of file ObjectiveFunction/ObjectiveFunction.cpp.

References MsqError::INVALID_STATE, and MSQ_SETERR.

Referenced by ObjectiveFunction::compute_hessian().

                                                           {
      MSQ_SETERR(err)("Analytic hessian not implemented for this Objective "
                    "Function. Feasible Newton algorythm cannot be used.\n",
                    MsqError::INVALID_STATE);
      return false;
    }

Here is the caller graph for this function:

virtual bool compute_analytical_hessian ( PatchData &  , MsqHessian &  , Vector3D *const &  , double &  , MsqError &    )

protectedvirtual

Fills a MsqHessian object with the Hessian of the objective function computed using the hessian of the quality metric. If the function has not been over-riden in the concrete Objective Function, the base class implementation prints a warning and returns false. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

Reimplemented in LPtoPTemplate, and LPtoPTemplate.

bool compute_gradient	(	PatchData &	patch,
		Vector3D *const &	grad,
		double &	OF_val,
		MsqError &	err,
		size_t	array_size = 0
	)

Calls either compute_numerical_gradient or compute_analytical_gradient depending on the value of gradType. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

bool compute_gradient ( PatchData &  patch, Vector3D *const &  grad, double &  OF_val, MsqError &  err, size_t  array_size = 0  )

inline

Calls either compute_numerical_gradient or compute_analytical_gradient depending on the value of gradType. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

Calls either compute_numerical_gradient or compute_analytical_gradient depending on the value of gradType.

Definition at line 257 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::ANALYTICAL_GRADIENT, ObjectiveFunction::compute_analytical_gradient(), ObjectiveFunction::compute_numerical_gradient(), ObjectiveFunction::gradType, MSQ_CHKERR, and ObjectiveFunction::NUMERICAL_GRADIENT.

Referenced by TerminationCriterion::accumulate_inner(), CompositeOFMultiply::compute_analytical_gradient(), CompositeOFAdd::compute_analytical_gradient(), CompositeOFScalarAdd::compute_analytical_gradient(), CompositeOFScalarMultiply::compute_analytical_gradient(), ConjugateGradient::optimize_vertex_positions(), SteepestDescent::optimize_vertex_positions(), FeasibleNewton::optimize_vertex_positions(), and TerminationCriterion::reset_inner().

   {
     bool obj_bool = false;
     switch(gradType){
       case NUMERICAL_GRADIENT:
          obj_bool=compute_numerical_gradient(patch, grad, OF_val,
                                              err, array_size);
          break;
       case ANALYTICAL_GRADIENT:
          obj_bool=compute_analytical_gradient(patch, grad, OF_val,
                                               err, array_size);
          break;
     }
     return !MSQ_CHKERR(err) && obj_bool;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool compute_hessian ( PatchData &  patch, MsqHessian &  hessian, Vector3D *const &  grad, double &  OF_val, MsqError &  err  )

inline

Calls compute_analytical_hessian. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

Calls compute_analytical_hessian. Numerical objective function hessians are only used for test purposes.

Definition at line 282 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::compute_analytical_hessian(), and MSQ_CHKERR.

Referenced by FeasibleNewton::optimize_vertex_positions().

   {
     bool result = compute_analytical_hessian(patch, hessian,
                                       grad, OF_val, err);
     return !MSQ_CHKERR(err) && result;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool compute_hessian	(	PatchData &	patch,
		MsqHessian &	hessian,
		Vector3D *const &	grad,
		double &	OF_val,
		MsqError &	err
	)

Calls compute_analytical_hessian. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

bool compute_numerical_gradient ( Mesquite::PatchData &  pd, Vector3D *const &  grad, double &  OF_val, MsqError &  err, size_t  array_size  )

protected

Non-virtual function which numerically computes the gradient of the Objective Function. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

Numerically Calculates the gradient of the ObjectiveFunction for the free vertices in the patch. Returns 'false' if the patch is outside of a required feasible region, returns 'ture' otherwise. The behavior of the function depends on the value of the boolean useLocalGradient. If useLocalGradient is set to 'true', compute_numerical_gradient creates a sub-patch around a free vertex, and then perturbs that vertex in one of the coordinate directions. Only the ObjectiveFunction value on the local sub-patch is used in the computation of the gradient. Therefore, useLocalGradient should only be set to 'true' for ObjectiveFunctions which can use this method. Unless the concrete ObjectiveFunction sets useLocalGradient to 'true' in its constructor, the value will be 'false'. In this case, the objective function value for the entire patch is used in the calculation of the gradient. This is computationally expensive, but it is numerically correct for all (C_1) functions.

Parameters

pd	PatchData on which the gradient is taken.
grad	Array of Vector3D of length the number of vertices used to store gradient.
OF_val	will be set to the objective function value.
array_size	Either the length of grad or 0.

Definition at line 65 of file ObjectiveFunction/ObjectiveFunction.cpp.

References ObjectiveFunction::evaluate(), ObjectiveFunction::get_eps(), PatchData::get_subpatch(), PatchData::get_vertex_array(), MsqError::INVALID_STATE, j, MSQ_CHKERR, MSQ_DBGOUT, MSQ_ERRZERO, MSQ_SETERR, PatchData::num_vertices(), and ObjectiveFunction::useLocalGradient.

Referenced by ObjectiveFunction::compute_analytical_gradient(), and ObjectiveFunction::compute_gradient().

{
  size_t num_vtx=pd.num_vertices();
  if(num_vtx!=array_size && array_size>0)
    MSQ_DBGOUT(1) << "\nArray size not equal to the number of vertices.\n";

  OF_val = 0.; // in case of return false. 
  MsqVertex* vertices=pd.get_vertex_array(err);
  double flocal=0;
  double flocald=0;
  double eps=0;
  size_t m=0;
  short j;
  
  if(useLocalGradient){
    //********************useLocalGradient***************************
    //if useLocalGradient is turned on, do more efficient computation
    PatchData sub_patch;
    for (m=0; m<num_vtx; ++m) {
      if (vertices[m].is_free_vertex()) {
        pd.get_subpatch(m, sub_patch, err); MSQ_ERRZERO(err);
        //If sub_patch is not in the feasible region, do not
        //calculate anything.  Just return false.
        bool b = evaluate(sub_patch,flocal,err);
        if(MSQ_CHKERR(err) || !b) {
          return false;
        }

        //loop over the three coords x,y,z
        for(j=0;j<3;++j){
          eps=get_eps(sub_patch, flocald, j, (&vertices[m]), err); MSQ_ERRZERO(err);
          //PRINT_INFO("\nin obj num grad j=%i, eps=%20.19f",j,eps);
          if(eps==0){
            MSQ_SETERR(err)("Dividing by zero in Objective Functions numerical grad",
                            MsqError::INVALID_STATE);
            return false;
          }
          grad[m][j]=(flocald-flocal)/eps;
        }
      }
      else {
        for(j=0;j<3;++j)
          grad[m][j] = 0.0;
      }
    }
    evaluate(pd, OF_val, err);  MSQ_ERRZERO(err);
  }
  else {
    //********************DO NOT useLocalGradient********************
    //if useLocalGradient is turned off, we do inefficient computation
    for (m=0; m<num_vtx; ++m) {

      if (vertices[m].is_free_vertex()) {
        //If pd is not in the feasible region, do not calculate anything.
        //Just return false.
        bool b = evaluate(pd,flocal,err);
        if(MSQ_CHKERR(err) || !b) {
          return false;
        }
        OF_val = flocal;
        //loop over the three coords x,y,z
        for(j=0;j<3;++j){
          eps=get_eps(pd, flocald, j, (&vertices[m]), err); MSQ_ERRZERO(err);
          //PRINT_INFO("\nin obj num grad j=%i, eps=%20.19f",j,eps);
          if(eps==0){
            MSQ_SETERR(err)("Dividing by zero in Objective Functions numerical grad",
                            MsqError::INVALID_STATE);
            return false;
          }
          grad[m][j]=(flocald-flocal)/eps;
        }
      }
      else {
        for(j=0;j<3;++j)
          grad[m][j] = 0.0;
      }
      //PRINT_INFO("  gradx = %f, grady = %f, gradz = %f\n",grad[m][0],grad[m][1],grad[m][2]);   
    }//end loop over all vertices
  }
  //*****************END of DO NOT useLocalGradient*****************
                        return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool compute_numerical_gradient ( PatchData &  patch, Vector3D *const &  grad, double &  OF_val, MsqError &  err, size_t  array_size  )

protected

Non-virtual function which numerically computes the gradient of the Objective Function. Function returns 'false' if the patch is not within a required feasible regeion. Otherwise, it returns 'true'.

virtual bool concrete_evaluate ( PatchData &  patch, double &  fval, MsqError &  err  )

pure virtual

Evaluate the objective function on a given patch.

Implemented in LPtoPTemplate, LPtoPTemplate, MaxTemplate, MaxTemplate, LInfTemplate, LInfTemplate, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFScalarMultiply, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFScalarMultiply, CompositeOFMultiply, and CompositeOFMultiply.

virtual bool concrete_evaluate ( PatchData &  patch, double &  fval, MsqError &  err  )

pure virtual

Evaluate the objective function on a given patch.

Implemented in LPtoPTemplate, LPtoPTemplate, MaxTemplate, MaxTemplate, LInfTemplate, LInfTemplate, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFScalarMultiply, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFScalarMultiply, CompositeOFMultiply, and CompositeOFMultiply.

Referenced by ObjectiveFunction::evaluate().

Here is the caller graph for this function:

bool evaluate ( PatchData &  patch, double &  fval, MsqError &  err  )

inline

Computes the value of the objective funciton as fval*negateFlag, where fval is computed in concrete_evaluate(patch, fval, err) and negateFlag is either 1 or -1 depending on whether the function needs to be minimized or maximized, respectively. Returns the bool given as a return value from concrete_evaluate. If the bool is 'false', then the patch is not within the feasible region required by the associated QualityMetric(s).

Definition at line 94 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::concrete_evaluate(), and ObjectiveFunction::negateFlag.

Referenced by TerminationCriterion::accumulate_inner(), ObjectiveFunction::compute_numerical_gradient(), CompositeOFMultiply::concrete_evaluate(), CompositeOFAdd::concrete_evaluate(), CompositeOFScalarMultiply::concrete_evaluate(), CompositeOFScalarAdd::concrete_evaluate(), TerminationCriterion::cull_vertices(), ObjectiveFunction::get_eps(), ConjugateGradient::get_step(), SmartLaplacianSmoother::optimize_vertex_positions(), SteepestDescent::optimize_vertex_positions(), FeasibleNewton::optimize_vertex_positions(), and TerminationCriterion::reset_inner().

       {
         bool return_bool = concrete_evaluate(patch, fval, err);
         fval *= negateFlag;
         return return_bool;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

bool evaluate ( PatchData &  patch, double &  fval, MsqError &  err  )

inline

Computes the value of the objective funciton as fval*negateFlag, where fval is computed in concrete_evaluate(patch, fval, err) and negateFlag is either 1 or -1 depending on whether the function needs to be minimized or maximized, respectively. Returns the bool given as a return value from concrete_evaluate. If the bool is 'false', then the patch is not within the feasible region required by the associated QualityMetric(s).

Definition at line 94 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

References ObjectiveFunction::concrete_evaluate(), and ObjectiveFunction::negateFlag.

       {
         bool return_bool = concrete_evaluate(patch, fval, err);
         fval *= negateFlag;
         return return_bool;
       }

Here is the call graph for this function:

double get_eps ( PatchData &  pd, double &  local_val, int  k, MsqVertex *  vertex, MsqError &  err  )

inlineprotected

Returns eps used in the numerical gradient calculation.

double get_eps ( PatchData &  pd, double &  local_val, int  k, MsqVertex *  vertex, MsqError &  err  )

inlineprotected

Returns eps used in the numerical gradient calculation.

Returns an appropiate value (eps) to use as a delta step for MsqVertex vertex in dimension k (i.e. k=0 -> x, k=1 -> y, k=2 -> z). The objective function value at the perturbed vertex position is given in local_val.

Definition at line 299 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::evaluate(), i, k, and MSQ_ERRZERO.

Referenced by ObjectiveFunction::compute_numerical_gradient().

  {
    double eps = 1.e-07;
    //  double rho=.5;
    int imax=20;
    int i=0;
    bool feasible=false;
    double tmp_var=0.0;
    while (i<imax && !feasible)
      {
        i++;
        //perturb kth coord val and check feas if needed
        tmp_var=(*vertex)[k];
        (*vertex)[k]+=eps;
        feasible = evaluate(pd,local_val,err); MSQ_ERRZERO(err);
        //if step was too big, shorten it         
        if(!feasible)
          eps*=0.5;
        //revert kth coord val
        (*vertex)[k]=tmp_var;
      }//end while looking for feasible eps
    return eps;
  }//end function get_eps

Here is the call graph for this function:

Here is the caller graph for this function:

int get_negate_flag ( )

inline

Returns negateFlag.

Definition at line 170 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::negateFlag.

Referenced by CompositeOFMultiply::CompositeOFMultiply(), CompositeOFScalarMultiply::compute_analytical_gradient(), LPtoPTemplate::compute_analytical_gradient(), and LPtoPTemplate::compute_analytical_hessian().

       {
         return negateFlag;
       }

Here is the caller graph for this function:

int get_negate_flag ( )

inline

Returns negateFlag.

Definition at line 170 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

References ObjectiveFunction::negateFlag.

       {
         return negateFlag;
       }

QualityMetric* get_quality_metric ( )

inline

Return the quality metric associated with this objective function. Returns null for composite functions which have multiple associated quality metrics. Use get_quality_metric_list() to retrieve all metrics.

Definition at line 139 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

References ObjectiveFunction::qMetric.

                                        {
         return qMetric;
       }

QualityMetric* get_quality_metric ( )

inline

Return the quality metric associated with this objective function. Returns null for composite functions which have multiple associated quality metrics. Use get_quality_metric_list() to retrieve all metrics.

Definition at line 139 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::qMetric.

Referenced by CompositeOFAdd::CompositeOFAdd(), CompositeOFMultiply::CompositeOFMultiply(), CompositeOFScalarAdd::CompositeOFScalarAdd(), CompositeOFScalarMultiply::CompositeOFScalarMultiply(), LPtoPTemplate::compute_analytical_gradient(), LPtoPTemplate::compute_analytical_hessian(), NonSmoothSteepestDescent::compute_function(), NonSmoothSteepestDescent::compute_gradient(), LInfTemplate::concrete_evaluate(), MaxTemplate::concrete_evaluate(), and LPtoPTemplate::concrete_evaluate().

                                        {
         return qMetric;
       }

Here is the caller graph for this function:

virtual msq_std::list<QualityMetric*> get_quality_metric_list ( )

inlinevirtual

returns a list of all associated metrics;

Reimplemented in CompositeOFAdd, CompositeOFScalarAdd, CompositeOFScalarMultiply, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFScalarMultiply, CompositeOFMultiply, and CompositeOFMultiply.

Definition at line 146 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

References ObjectiveFunction::qMetric.

       {
         msq_std::list<QualityMetric*> temp_list;
         temp_list.push_front(qMetric);
         return temp_list;
       }

virtual msq_std::list<QualityMetric*> get_quality_metric_list ( )

inlinevirtual

returns a list of all associated metrics;

Reimplemented in CompositeOFAdd, CompositeOFScalarAdd, CompositeOFScalarMultiply, CompositeOFAdd, CompositeOFScalarAdd, CompositeOFScalarMultiply, CompositeOFMultiply, and CompositeOFMultiply.

Definition at line 146 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::qMetric.

Referenced by NonSmoothSteepestDescent::compute_function(), NonSmoothSteepestDescent::compute_gradient(), LInfTemplate::concrete_evaluate(), LPtoPTemplate::concrete_evaluate(), CompositeOFMultiply::get_quality_metric_list(), CompositeOFScalarMultiply::get_quality_metric_list(), CompositeOFScalarAdd::get_quality_metric_list(), and CompositeOFAdd::get_quality_metric_list().

       {
         msq_std::list<QualityMetric*> temp_list;
         temp_list.push_front(qMetric);
         return temp_list;
       }

Here is the caller graph for this function:

void set_gradient_type ( GRADIENT_TYPE  grad )

inline

Set gradType to either NUMERICAL_GRADIENT or ANALYTICAL_GRADIENT.

Definition at line 110 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::gradType.

Referenced by CompositeOFAdd::CompositeOFAdd(), CompositeOFMultiply::CompositeOFMultiply(), CompositeOFScalarAdd::CompositeOFScalarAdd(), CompositeOFScalarMultiply::CompositeOFScalarMultiply(), ObjectiveFunction::compute_analytical_gradient(), LInfTemplate::LInfTemplate(), LPtoPTemplate::LPtoPTemplate(), MaxTemplate::MaxTemplate(), and ShapeImprovementWrapper::ShapeImprovementWrapper().

    { gradType = grad; }

Here is the caller graph for this function:

void set_gradient_type ( GRADIENT_TYPE  grad )

inline

Set gradType to either NUMERICAL_GRADIENT or ANALYTICAL_GRADIENT.

Definition at line 110 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

References ObjectiveFunction::gradType.

    { gradType = grad; }

void set_negate_flag ( int  neg )

inline

Set the value of ObjectiveFunction's negateFlag. Unless composite, concrete ObjectiveFunctions should set this flag to to the value of the associated QualityMetric's negateFLag.

Definition at line 164 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::negateFlag.

Referenced by CompositeOFAdd::CompositeOFAdd(), CompositeOFMultiply::CompositeOFMultiply(), CompositeOFScalarAdd::CompositeOFScalarAdd(), CompositeOFScalarMultiply::CompositeOFScalarMultiply(), LInfTemplate::LInfTemplate(), LPtoPTemplate::LPtoPTemplate(), and MaxTemplate::MaxTemplate().

       {
         negateFlag=neg;
       }

Here is the caller graph for this function:

void set_negate_flag ( int  neg )

inline

Set the value of ObjectiveFunction's negateFlag. Unless composite, concrete ObjectiveFunctions should set this flag to to the value of the associated QualityMetric's negateFLag.

Definition at line 164 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

References ObjectiveFunction::negateFlag.

       {
         negateFlag=neg;
       }

void set_quality_metric ( QualityMetric *  qm )

inline

Set the value of qMetric.

Definition at line 154 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::qMetric.

Referenced by CompositeOFAdd::CompositeOFAdd(), CompositeOFMultiply::CompositeOFMultiply(), CompositeOFScalarAdd::CompositeOFScalarAdd(), CompositeOFScalarMultiply::CompositeOFScalarMultiply(), LInfTemplate::LInfTemplate(), LPtoPTemplate::LPtoPTemplate(), and MaxTemplate::MaxTemplate().

       {
         qMetric=qm;
       }

Here is the caller graph for this function:

void set_quality_metric ( QualityMetric *  qm )

inline

Set the value of qMetric.

Definition at line 154 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

References ObjectiveFunction::qMetric.

       {
         qMetric=qm;
       }

void set_use_local_gradient ( bool  new_bool )

inlineprotected

Sets useLocalGradient This variable determines whether compute_numercial_gradient can use the most efficient gradient calculation.

Definition at line 230 of file src/ObjectiveFunction/ObjectiveFunction.hpp.

References ObjectiveFunction::useLocalGradient.

       {
         useLocalGradient=new_bool;
       }

void set_use_local_gradient ( bool  new_bool )

inlineprotected

Sets useLocalGradient This variable determines whether compute_numercial_gradient can use the most efficient gradient calculation.

Definition at line 230 of file includeLinks/ObjectiveFunction.hpp.

References ObjectiveFunction::useLocalGradient.

       {
         useLocalGradient=new_bool;
       }

Member Data Documentation

enum GRADIENT_TYPE gradType

private

Definition at line 238 of file includeLinks/ObjectiveFunction.hpp.

Referenced by ObjectiveFunction::compute_gradient(), and ObjectiveFunction::set_gradient_type().

int negateFlag

private

Pointer to associated QualityMetric.

Definition at line 242 of file includeLinks/ObjectiveFunction.hpp.

Referenced by ObjectiveFunction::evaluate(), ObjectiveFunction::get_negate_flag(), and ObjectiveFunction::set_negate_flag().

QualityMetric * qMetric

private

Flag for numerical or analytical gradient.

Definition at line 240 of file includeLinks/ObjectiveFunction.hpp.

Referenced by ObjectiveFunction::get_quality_metric(), ObjectiveFunction::get_quality_metric_list(), and ObjectiveFunction::set_quality_metric().

bool useLocalGradient

private

          Equals one if ObjectiveFunction needs to

be minimized; equals negative one if ObjectiveFunction needs to be maximized.

Definition at line 245 of file includeLinks/ObjectiveFunction.hpp.

Referenced by ObjectiveFunction::compute_numerical_gradient(), and ObjectiveFunction::set_use_local_gradient().

---

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

• includeLinks/ObjectiveFunction.hpp
• src/ObjectiveFunction/ObjectiveFunction.hpp
• ObjectiveFunction/ObjectiveFunction.cpp
• inks/ObjectiveFunction.cpp