Uncmin< V, M, FUNC > Class Template Reference

#include <Uncmin.h>

Collaboration diagram for Uncmin< V, M, FUNC >:

[legend]

List of all members.

Public Types
typedef FUNC	function_type
	Type definition of function object to minimize.
Public Member Functions
	Uncmin (FUNC *f)
	Constructor that sets dimension and function to minimize.
	Uncmin (int d=1)
	Constructor that sets dimension, but not function to minimize.
	~Uncmin ()
	Destructor of uncmin.
int	Minimize (V &start, V &xpls, double &fpls, V &gpls, M &hpls)
	Method to compute values that minimize the function.
int	Minimize (V &start, V &xpls, double &fpls, V &gpls)
	Version of Minimize in which the hessian is allocated locally rather than passed as an argument to the function.
FUNC *	GetFunction ()
	Returns pointer to object containing function to minimize, gradient, and hessian.
void	SetFunction (FUNC *f)
	Assigns pointer to object containing function to minimize, gradient, and hessian.
void	SetFuncExpensive (int iexp)
	Assigns flag indicating whether function is expensive to evaluate.
int	SetScaleArg (V typsiz)
	Assigns typical magnitude of each argument to function.
void	SetScaleFunc (double fscale)
	Assigns typical magnitude of function near minimum.
void	SetNumDigits (double ndigit)
	Assigns the number of reliable digits returned by f_to_minimize.
void	SetMaxIter (int maxiter)
	Assigns the maximum number of iterations.
void	SetTolerances (double step, double grad, double macheps=-1.0)
	Assigns step tolerance, gradient tolerance, and the machine epsilon.
void	SetMaxStep (double stepmx)
	Assigns maximum allowable scaled step length at any iteration.
void	SetTrustRegionRadius (double dlt)
	Assigns initial trust region radius.
void	SetChecks (int check_gradient, int check_hessian=0)
	Assigns flags to check analytic gradient and hessian.
void	SetPrint (std::FILE *file, int print_results, int print_iterations=0)
	Assigns flags to indicate whether results are printed and specify which file is receive the print output.
void	SetMethod (int method)
	Assigns method to use to solve minimization problem.
void	GetStoppingCriteria (double &gradtol, double &steptol, int &iterations)
	Returns stopping criteria computed at the end of the last call to Minimize.
int	GetMessage ()
	Returns message index generated in the last call to Minimize.

---

Detailed Description

template<class V, class M, class FUNC>
class Uncmin< V, M, FUNC >

Documentation of member functions is given in their definitions which follow the Uncmin class definition

Definition at line 201 of file Uncmin.h.

---

Member Typedef Documentation

template<class V, class M, class FUNC>

typedef FUNC Uncmin< V, M, FUNC >::function_type

Type definition of function object to minimize.

Definition at line 206 of file Uncmin.h.

---

Constructor & Destructor Documentation

template<class V, class M, class FUNC>

Uncmin< V, M, FUNC >::Uncmin

(

FUNC *

f

)

[inline]

Constructor that sets dimension and function to minimize.

The minclass function object must define:

1. a method, f_to_minimize, to minimize. f_to_minimize must have the form public static double f_to_minimize(double x[]) where x is the vector of arguments to the function and the return value is the value of the function evaluated at x.

2. a method, gradient, that has the form public static void gradient(double x[], double g[]) where g is the gradient of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the gradient.

3. a method, hessian, that has the form public static void hessian(double x[],double h[][]) where h is the Hessian of f evaluated at x. This method will have an empty body if the user does not wish to provide an analytic estimate of the Hessian. If the user wants Uncmin++ to check the Hessian, then the hessian method should only fill the lower triangle (and diagonal)of h.

Minimization parameters are set at default values.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

*f

Pointer to function object f.

Definition at line 448 of file Uncmin.h.

00449                                                                          :
00450   minclass(f)
00451 {
00452   if (minclass)
00453     n = minclass->dim();
00454   else
00455     n = 0;
00456 
00457   mfile = 0;
00458 
00459   mLastGradCrit = 0.0;
00460   mLastStepCrit = 0.0;
00461   mLastIteration = 0;
00462   mLastMessage = 0;
00463 
00464   /* Set default parameter values */
00465   dfault();
}

template<class V, class M, class FUNC>

Uncmin< V, M, FUNC >::Uncmin

(

int

d = 1

)

[inline]

Constructor that sets dimension, but not function to minimize.

Note: Function to minimize must be set by calling SetFunction. Minimization parameters are set to default values.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

d

Dimension d (number of function arguments).

Definition at line 484 of file Uncmin.h.

00485                                                                        :
00486   minclass(0), typsiz(d)
00487 {
00488 
00489   n = d;
00490 
00491   mfile = 0;
00492 
00493   mLastGradCrit = 0.0;
00494   mLastStepCrit = 0.0;
00495   mLastIteration = 0;
00496   mLastMessage = 0;
00497 
00498   /* Set default parameter values */
00499   dfault();
00500 
}

template<class V, class M, class FUNC>

Uncmin< V, M, FUNC >::~Uncmin

(

)

[inline]

Destructor of uncmin.

Definition at line 505 of file Uncmin.h.

{

---

Member Function Documentation

template<class V, class M, class FUNC>

int Uncmin< V, M, FUNC >::Minimize	(	V &	start,
		V &	xpls,
		double &	fpls,
		V &	gpls,
		M &	hpls
	)			[inline]

Method to compute values that minimize the function.

Translated by Brad Hanson from optdrv_f77 by Steve Verrill.

Returns 0 if mLastMessage is 0, 1, 2, or 3 (indicating optimal solution probably found), otherwise returns non-zero.

On exit data member mLastMessage is set to indicate status of solution.

Possible values of mLastMessage are: 0 = Optimal solution found, terminated with gradient small. 1 = Terminated with gradient small, xpls is probably optimal. 2 = Terminated with stepsize small, xpls is probably optimal. 3 = Lower point cannot be found, xpls is probably optimal. 4 = Iteration limit (default 150) exceeded. 5 = Too many large steps, function may be unbounded. -1 = Analytic gradient check requested, but no analytic gradient supplied. -2 = Analytic hessian check requested, but no analytic hessian supplied. -3 = Illegal dimension. -4 = Illegal tolerance. -5 = Illegal iteration limit. -6 = Minimization function has no good digits. -7 = Iteration limit exceeded in lnsrch. -20 = Function not defined at starting value. -21 = Check of analytic gradient failed. -22 = Check of analytic hessian failed.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]	&start	Address of vector containing initial estimate of location of minimum.
[out]	&xpls	Address of vector containing local minimum (size must be n on input).
[out]	&fpls	Address of function value at local minimum.
[out]	&gpls	Address of vector containing gradient at local minimum (size must be n on input).
[out]	&hpls	Address of matrix containing hessian at local minimum (size must be n X n on input). Only the lower half should be input; the upper off-diagonal entries can be set to zero. On return, the lower half of hpls contains the Cholesky factor of the Hessian, evaluated at the solution (i.e., H = LL').

Definition at line 1000 of file Uncmin.h.

Referenced by Uncmin< V, M, FUNC >::Minimize().

{

  bool noupdt;
  bool mxtake;

  int i, j, num5, remain, ilow, ihigh;
  int icscmx;
  int iretcd;
  int itncnt;

  /*
    Return code.
      itrmcd =  0:    Optimal solution found
      itrmcd =  1:    Terminated with gradient small, X is probably optimal
      itrmcd =  2:    Terminated with stepsize small, X is probably optimal
      itrmcd =  3:    Lower point cannot be found, X is probably optimal
      itrmcd =  4:    Iteration limit (150) exceeded
      itrmcd =  5:    Too many large steps, function may be unbounded.
   */
  int itrmcd;

  double rnf, analtl, dltsav, amusav, dlpsav, phisav, phpsav;

  double f;

  double amu = 0.0;
  double dltp = 0.0;
  double phi = 0.0;
  double phip0 = 0.0;

  int method = algorithm;

  mLastGradCrit = 0.0;
  mLastStepCrit = 0.0;
  mLastIteration = 0;
  mLastMessage = -9999;

  iagflg = minclass->HasAnalyticGradient();
  iahflg = minclass->HasAnalyticHessian();

  /*
    msg
    Flag to set various options.
    Bits which indicate flags which control checks of gradient and hessian and what output is printed.
    msg should be zero or a sum of the following values which indicate which flags to set or not set.

      1 = Turn off check of analytic gradient.
      2 = Turn off check of analytic hessian.
      4 = Turn off printing of results.
      8 = Turn on printing of results at each iteration.
   */
  int msg = (fCheckGradient == 0) * 1 + (fCheckHessian == 0) * 2 + (fPrintResults == 0) * 4
      + (fPrintIterationResults != 0) * 8;

  /* Check that dimensions match */
  if (start.size() != n || xpls.size() != n || gpls.size() != n || hpls.num_rows() != n
      || hpls.num_columns() != n) // Refactored function "num_columns", ww, 12-22-2007
  {
    mLastMessage = -3;
    return -1;
  }

  /* Check that starting values are valid */
  if (!(minclass->ValidParameters(start)))
  {
    mLastMessage = -20;
    return -1;
  }

  /* Workspace */
  M &a = hpls;
  V udiag(n); //workspace (for diagonal of Hessian)
  V g(n); // workspace (for gradient at current iterate)
  V p(n); // workspace for step
  V sx(n); // workspace (for scaling vector)
  V wrk0(n), wrk1(n), wrk2(n), wrk3(n);

  V x(start);

  double dlt = mdlt;

  dltsav = amusav = dlpsav = phisav = phpsav = 0.0;

  // INITIALIZATION

  for (i = 1; i <= n; i++)
  {
    p(i) = 0.0;
  }

  itncnt = 0;
  iretcd = -1;

  /* Check for valid options */
  if (optchk(x, sx, msg, method))
  {
    mLastMessage = msg;
    return -1;
  }

  rnf = max(std::pow(10.0, -ndigit), epsm);
  analtl = max(.01, std::sqrt(rnf));

  if (!(msg & 4))
  {
    num5 = n/5;
    remain = n%5;

    std::fprintf(mfile, "\n\nOPTDRV          Typical x\n\n");

    ilow = -4;
    ihigh = 0;

    for (i = 1; i <= num5; i++)
    {
      ilow += 5;
      ihigh += 5;

      std::fprintf(mfile, "%d--%d     ", ilow, ihigh);

      for (j = 1; j <= 5; j++)
      {
        std::fprintf(mfile, "%lf  ", (double) typsiz(ilow+j-1));
      }
      std::fprintf(mfile, "\n");
    }

    ilow += 5;
    ihigh = ilow + remain - 1;

    std::fprintf(mfile, "%d--%d     ", ilow, ihigh);

    for (j = 1; j <= remain; j++)
    {
      std::fprintf(mfile, "%lf  ", (double) typsiz(ilow+j-1));
    }

    std::fprintf(mfile, "\n");

    std::fprintf(mfile, "\n\nOPTDRV      Scaling vector for x\n\n");

    ilow = -4;
    ihigh = 0;

    for (i = 1; i <= num5; i++)
    {
      ilow += 5;
      ihigh += 5;

      std::fprintf(mfile, "%d--%d     ", ilow, ihigh);

      for (j = 1; j <= 5; j++)
      {
        std::fprintf(mfile, "%lf  ", (double) sx(ilow+j-1));
      }
      std::fprintf(mfile, "\n");
    }

    ilow += 5;
    ihigh = ilow + remain - 1;

    std::fprintf(mfile, "%d--%d     ", ilow, ihigh);

    for (j = 1; j <= remain; j++)
    {
      std::fprintf(mfile, "%lf  ", (double) sx(ilow+j-1));
    }

    std::fprintf(mfile, "\n");

    std::fprintf(mfile, "\n\nOPTDRV      Typical f = %f\n", fscale);
    std::fprintf(mfile, "OPTDRV      Number of good digits in");
    std::fprintf(mfile, " f_to_minimize = %d\n", ndigit);
    std::fprintf(mfile, "OPTDRV      Gradient flag");
    std::fprintf(mfile, " = %d\n", iagflg);
    std::fprintf(mfile, "OPTDRV      Hessian flag");
    std::fprintf(mfile, " = %d\n", iahflg);
    std::fprintf(mfile, "OPTDRV      Expensive function calculation flag");
    std::fprintf(mfile, " = %d\n", iexp);
    std::fprintf(mfile, "OPTDRV      Method to use");
    std::fprintf(mfile, " = %d\n", method);
    std::fprintf(mfile, "OPTDRV      Iteration limit");
    std::fprintf(mfile, " = %d\n", itnlim);
    std::fprintf(mfile, "OPTDRV      Machine epsilon");
    std::fprintf(mfile, " = %e\n", epsm);
    std::fprintf(mfile, "OPTDRV      Maximum step size");
    std::fprintf(mfile, " = %f\n", stepmx);
    std::fprintf(mfile, "OPTDRV      Step tolerance");
    std::fprintf(mfile, " = %e\n", steptl);
    std::fprintf(mfile, "OPTDRV      Gradient tolerance");
    std::fprintf(mfile, " = %e\n", gradtl);
    std::fprintf(mfile, "OPTDRV      Trust region radius");
    std::fprintf(mfile, " = %f\n", dlt);
    std::fprintf(mfile, "OPTDRV      Relative noise in");
    std::fprintf(mfile, " f_to_minimize = %e\n", rnf);
    std::fprintf(mfile, "OPTDRV      Analytical fd tolerance");
    std::fprintf(mfile, " = %e\n", analtl);
  }

  // EVALUATE FCN(X)
  f = minclass->f_to_minimize(x);

  // EVALUATE ANALYTIC OR FINITE DIFFERENCE GRADIENT AND CHECK ANALYTIC
  // GRADIENT, IF REQUESTED.
  if (iagflg == 0)
  {
    fstofd(x, f, g, sx, rnf);
  }
  else
  {
    minclass->gradient(x, g);

    if (!(msg & 1))
    {
      if (grdchk(x, f, g, typsiz, sx, fscale, rnf, analtl, wrk1, msg))
      {
        mLastMessage = msg;
        return -1; // msg = -21
      }
    }
  }

  optstp(x, f, g, wrk1, itncnt, icscmx, itrmcd, sx, fscale, itnlim, iretcd, mxtake, msg);

  if (itrmcd != 0)
  {
    fpls = f;

    for (i = 1; i <= n; i++)
    {
      xpls(i) = x(i);
      gpls(i) = g(i);
    }
  }
  else
  {
    if (iexp == 1)
    {
      // IF OPTIMIZATION FUNCTION EXPENSIVE TO EVALUATE (IEXP=1), THEN
      // HESSIAN WILL BE OBTAINED BY SECANT (BFGS) UPDATES.  GET INITIAL HESSIAN.

      hsnint(a, sx, method);
    }
    else
    {
      // EVALUATE ANALYTIC OR FINITE DIFFERENCE HESSIAN AND CHECK ANALYTIC
      // HESSIAN IF REQUESTED (ONLY IF USER-SUPPLIED ANALYTIC HESSIAN
      // ROUTINE minclass->hessian FILLS ONLY LOWER TRIANGULAR PART AND DIAGONAL OF A).

      if (iahflg == 0)
      {
        if (iagflg == 1)
        {
          fstofd(x, g, a, sx, rnf, wrk1);
        }
        else
        {
          sndofd(x, f, a, sx, rnf, wrk1, wrk2);
        }
      }
      else
      {
        if (msg & 2)
        {
          minclass->hessian(x, a);
        }
        else
        {
          if (heschk(x, f, g, a, typsiz, sx, rnf, analtl, iagflg, udiag, wrk1, wrk2, msg))
          {
            mLastMessage = msg;
            return -1; // msg = -22
          }
          // HESCHK EVALUATES minclass->hessian AND CHECKS IT AGAINST THE FINITE
          // DIFFERENCE HESSIAN WHICH IT CALCULATES BY CALLING FSTOFD
          // (IF IAGFLG .EQ. 1) OR SNDOFD (OTHERWISE).
        }
      }
    }

    if (!(msg & 4))
      result(x, f, g, a, p, itncnt, 1);

    // ITERATION
    while (itrmcd == 0)
    {
      itncnt++;
      mLastIteration = itncnt; // BAH

      // FIND PERTURBED LOCAL MODEL HESSIAN AND ITS LL+ DECOMPOSITION
      // (SKIP THIS STEP IF LINE SEARCH OR DOGSTEP TECHNIQUES BEING USED WITH
      // SECANT UPDATES.  CHOLESKY DECOMPOSITION L ALREADY OBTAINED FROM
      // SECFAC.)
      if (iexp != 1 || method == 3)
      {
        chlhsn(a, sx, udiag);
      }

      // SOLVE FOR NEWTON STEP:  AP=-G
      for (i = 1; i <= n; i++)
      {
        wrk1(i) = -g(i);
      }

      lltslv(a, p, wrk1);

      // DECIDE WHETHER TO ACCEPT NEWTON STEP  XPLS=X + P
      // OR TO CHOOSE XPLS BY A GLOBAL STRATEGY.
      if (iagflg == 0 && method != 1)
      {
        dltsav = dlt;

        if (method != 2)
        {
          amusav = amu;
          dlpsav = dltp;
          phisav = phi;
          phpsav = phip0;
        }
      }

      if (method == 1)
      {
        lnsrch(x, f, g, p, xpls, fpls, mxtake, iretcd, sx);
        if (iretcd == -7) // BAH
        {
          mLastMessage = iretcd;
          return -1;
        }
      }
      else if (method == 2)
      {
        dogdrv(x, f, g, a, p, xpls, fpls, sx, dlt, iretcd, mxtake, wrk0, wrk1, wrk2, wrk3);
      }
      else
      {
        hookdr(x, f, g, a, udiag, p, xpls, fpls, sx, dlt, iretcd, mxtake, amu, dltp, phi, phip0,
            wrk0, wrk1, wrk2, itncnt);
      }

      // IF COULD NOT FIND SATISFACTORY STEP AND FORWARD DIFFERENCE
      // GRADIENT WAS USED, RETRY USING CENTRAL DIFFERENCE GRADIENT.
      if (iretcd == 1 && iagflg == 0)
      {
        // SET IAGFLG FOR CENTRAL DIFFERENCES
        iagflg = -1;

        if (!(msg & 4))
        {
          std::fprintf(mfile, "\nOPTDRV      Shift from forward to central");
          std::fprintf(mfile, " differences");
          std::fprintf(mfile, "\nOPTDRV      in iteration %d", itncnt);
          std::fprintf(mfile, "\n");
        }

        fstocd(x, sx, rnf, g);

        if (method == 1)
        {
          // SOLVE FOR NEWTON STEP:  AP=-G
          for (i = 1; i <= n; i++)
          {
            wrk1(i) = -g(i);
          }

          lltslv(a, p, wrk1);

          lnsrch(x, f, g, p, xpls, fpls, mxtake, iretcd, sx);
          if (iretcd == -7) // BAH
          {
            mLastMessage = iretcd;
            return -1;
          }
        }
        else
        {
          dlt = dltsav;
          if (method == 2)
          {
            // SOLVE FOR NEWTON STEP:  AP=-G
            for (i = 1; i <= n; i++)
            {
              wrk1(i) = -g(i);
            }

            lltslv(a, p, wrk1);

            dogdrv(x, f, g, a, p, xpls, fpls, sx, dlt, iretcd, mxtake, wrk0, wrk1, wrk2, wrk3);
          }
          else
          {
            amu = amusav;
            dltp = dlpsav;
            phi = phisav;
            phip0 = phpsav;

            chlhsn(a, sx, udiag);

            // SOLVE FOR NEWTON STEP:  AP=-G
            for (i = 1; i <= n; i++)
            {
              wrk1(i) = -g(i);
            }

            lltslv(a, p, wrk1);

            hookdr(x, f, g, a, udiag, p, xpls, fpls, sx, dlt, iretcd, mxtake, amu, dltp, phi,
                phip0, wrk0, wrk1, wrk2, itncnt);
          }
        }
      }
      // CALCULATE STEP FOR OUTPUT
      for (i = 1; i <= n; i++)
      {
        p(i) = xpls(i) - x(i);
      }

      // CALCULATE GRADIENT AT XPLS
      if (iagflg == -1)
      {
        // CENTRAL DIFFERENCE GRADIENT
        fstocd(xpls, sx, rnf, gpls);
      }
      else if (iagflg == 0)
      {
        // FORWARD DIFFERENCE GRADIENT
        fstofd(xpls, fpls, gpls, sx, rnf);
      }
      else
      {
        // ANALYTIC GRADIENT
        minclass->gradient(xpls, gpls);
      }

      // CHECK WHETHER STOPPING CRITERIA SATISFIED
      optstp(xpls, fpls, gpls, x, itncnt, icscmx, itrmcd, sx, fscale, itnlim, iretcd, mxtake, msg);

      if (itrmcd == 0)
      {
        // EVALUATE HESSIAN AT XPLS
        if (iexp != 0)
        {
          if (method == 3)
          {
            secunf(x, g, a, udiag, xpls, gpls, itncnt, rnf, iagflg, noupdt, wrk1, wrk2, wrk3);
          }
          else
          {
            secfac(x, g, a, xpls, gpls, itncnt, rnf, iagflg, noupdt, wrk0, wrk1, wrk2, wrk3);
          }
        }
        else
        {
          if (iahflg == 1)
          {
            minclass->hessian(xpls, a);
          }
          else
          {
            if (iagflg == 1)
            {
              fstofd(xpls, gpls, a, sx, rnf, wrk1);
            }
            else
            {
              sndofd(xpls, fpls, a, sx, rnf, wrk1, wrk2);
            }
          }
        }

        if (msg & 8)
        {
          result(xpls, fpls, gpls, a, p, itncnt, 1);
        }

        // X <-- XPLS  AND  G <-- GPLS  AND  F <-- FPLS
        f = fpls;

        for (i = 1; i <= n; i++)
        {
          x(i) = xpls(i);
          g(i) = gpls(i);
        }
      }
    }

    // TERMINATION
    // -----------
    // RESET XPLS,FPLS,GPLS,  IF PREVIOUS ITERATE SOLUTION
    //
    if (itrmcd == 3)
    {
      fpls = f;

      for (i = 1; i <= n; i++)
      {
        xpls(i) = x(i);
        gpls(i) = g(i);
      }
    }
  }

  // PRINT RESULTS
  if (!(msg & 4))
  {
    result(xpls, fpls, gpls, a, p, itncnt, 0);
  }
  mLastMessage = itrmcd;
  return (itrmcd >= 0 && itrmcd <= 3) ? 0 : 1;

Here is the caller graph for this function:

template<class V, class M, class FUNC>

int Uncmin< V, M, FUNC >::Minimize	(	V &	start,
		V &	xpls,
		double &	fpls,
		V &	gpls
	)			[inline]

Version of Minimize in which the hessian is allocated locally rather than passed as an argument to the function.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]	&start	Address of vector containing initial estimate of location of minimum.
[out]	&xpls	Address of vector containing local minimum (size must be n on input).
[out]	&fpls	Address of function value at local minimum.
[out]	&gpls	Address of vector containing gradient at local minimum (size must be n on input).

Definition at line 1532 of file Uncmin.h.

References Uncmin< V, M, FUNC >::Minimize().

{

  M *a = new M(n,n);

  int result = Minimize(start, xpls, fpls, gpls, *a);

  delete a;

  return result;

Here is the call graph for this function:

template<class V, class M, class FUNC>

FUNC * Uncmin< V, M, FUNC >::GetFunction

(

)

[inline]

Returns pointer to object containing function to minimize, gradient, and hessian.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Definition at line 766 of file Uncmin.h.

{
  return minclass;

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetFunction

(

FUNC *

f

)

[inline]

Assigns pointer to object containing function to minimize, gradient, and hessian.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

*f

Pointer to function object f.

Definition at line 786 of file Uncmin.h.

{
  minclass = f;

  /* If dimension does not match change n and re-intialize typsiz */
  if (n != f->dim())
  {
    n = f->dim();
    V defaultTypSiz(n, 1.0);
    typsiz = defaultTypSiz;
  }

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetFuncExpensive

(

int

iexp

)

[inline]

Assigns flag indicating whether function is expensive to evaluate.

Set iexp =1 if function is expensive to evaluate, = 0 otherwise. If iexp = 1, then the Hessian will be evaluated by secant (BFGS) update rather than analytically or by finite differences.

Default value is 0 if this function is not called.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

iexp

Set iexp =1 if function is expensive to evaluate, iexp = 0 otherwise.

Definition at line 530 of file Uncmin.h.

{
  this->iexp = iexp;

template<class V, class M, class FUNC>

int Uncmin< V, M, FUNC >::SetScaleArg

(

V

typsiz

)

[inline]

Assigns typical magnitude of each argument to function.

Returns zero if dimension matches, otherwise returns 1.

The default is to set all elements of typsiz to 1 if this function is not called.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

typsiz

Vector describing the magnitude of all function arguments.

Definition at line 553 of file Uncmin.h.

{
  if (typsiz.size() != n)
    return 1;

  this->typsiz = typsiz;

  return 0;

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetScaleFunc

(

double

fscale

)

[inline]

Assigns typical magnitude of function near minimum.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

fscale

Magnitude of function values near minimum. A default value of 1 is used for fscale if this function is not called.

Definition at line 579 of file Uncmin.h.

{
  this->fscale = fscale;

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetNumDigits

(

double

ndigit

)

[inline]

Assigns the number of reliable digits returned by f_to_minimize.

If the argument to the function is -1 this means that f_to_minimize is expected to provide within one or two of the full number of significant digits available.

The default value of -1 is used for ndigit when this function is not called.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

ndigit

Number of digits precision required for the solution.

Definition at line 606 of file Uncmin.h.

{
  this->ndigit = ndigit;

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetMaxIter

(

int

maxiter

)

[inline]

Assigns the maximum number of iterations.

The default value of 150 is used if this function is not called.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

maxiter

Maximum number of iterations.

Definition at line 627 of file Uncmin.h.

{
  this->itnlim = maxiter;

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetTolerances	(	double	step,
		double	grad,
		double	macheps = -1.0
	)			[inline]

Assigns step tolerance, gradient tolerance, and the machine epsilon.

Note: For any of these values <= zero, default values are used.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]	step	Tolerance at which scaled distance between two successive iterates is considered close enough to zero to terminate algorithm. If the value of step is <= zero a default value is used.
[in]	grad	Tolerance at which gradient is considered close enough to zero to terminate algorithm. If the value of grad is <= zero a default value is used.
[in]	macheps	Largest relative spacing. Machine epsilon == 2**(-T+1) where (1 + 2**-T) == 1. This argument has a default value of -1 if not included in function call.

Definition at line 656 of file Uncmin.h.

{
  if (macheps <= 0.0) // use default value
  {

#ifdef BOOST_NO_LIMITS
    epsm = DBL_EPSILON; // from float.h
#else
    // use epsilon from numeric_limits in standard C++ library
    epsm = std::numeric_limits<double>::epsilon();
#endif

  }
  else
  {
    epsm = macheps;
  }

  if (grad <= 0.0)
  {
    gradtl = std::pow(epsm, 1.0/3.0); // default value
  }
  else
  {
    gradtl = grad;
  }

  if (step <= 0.0)
  {
    steptl = std::sqrt(epsm); // default value
  }
  else
  {
    steptl = step;
  }

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetMaxStep

(

double

stepmx

)

[inline]

Assigns maximum allowable scaled step length at any iteration.

The maximum step length is used to prevent steps that would cause the optimization algorithm to overflow or leave the domain of iterest, as well as to detect divergence. It should be chosen small enough to prevent the first two of these occurrences, but larger than any anticipated reasonable step size. The algorithm will halt if it takes steps larger than the maximum allowable step length on 5 consecutive iterations.

If the argument to the function is <= 0 then a default value of stepmx will be computed in optchk.

A default value of 0 is used for stepmx when this function is not called.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

stepmx

Maximum (scaled) step size.

Definition at line 723 of file Uncmin.h.

{
  this->stepmx = stepmx;

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetTrustRegionRadius

(

double

dlt

)

[inline]

Assigns initial trust region radius.

Used when method = 2 or 3, ignored when method = 1. The value should be what the user considers a reasonable scaled step length for the first iteration, and should be less than the maximum step length.

If dlt = -1, then the length of the initial scaled gradient is used instead.

A default value of -1 is used if this function is not called.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

dlt

Maximum (scaled) step size of first iteration.

Definition at line 751 of file Uncmin.h.

{
  this->mdlt = dlt;

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetChecks	(	int	check_gradient,
		int	check_hessian = 0
	)			[inline]

Assigns flags to check analytic gradient and hessian.

The default is to not check the gradient and hessian, if this function is not called (fCheckGradient = 0 and fCheckHessian = 0).

Note that check_hessian can be left off function call in which case default value of 0 is used.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]	check_gradient	Flag to check analytic gradient of function: 1 = yes, 0 = no.
[in]	check_hessian	Flag to check analytic hessian of function: 1 = yes, 0 = no.

Definition at line 820 of file Uncmin.h.

{
  fCheckGradient = check_gradient;
  fCheckHessian = check_hessian;

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetPrint	(	std::FILE *	file,
		int	print_results,
		int	print_iterations = 0
	)			[inline]

Assigns flags to indicate whether results are printed and specify which file is receive the print output.

Printing is done to open file indicated by first argument.

The default action is not to print any output.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.
	FILE	Type of file for writing print output to.

Function Parameters

Parameters:

[in]	*file	Pointer to the open file that will receive the printed results.
[in]	print_results	Flag (if non-zero) to print standard results.
[in]	print_iterations	Flag (if non-zero) to print intermediate results at each iteration (this argument can be left off function call in which case the default value of 0 is used).

Definition at line 851 of file Uncmin.h.

{

  mfile = file;

  if (!file)
  {
    fPrintResults = 0;
    fPrintIterationResults = 0;
  }
  else
  {
    fPrintResults = print_results;
    fPrintIterationResults = print_iterations;
  }

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::SetMethod

(

int

method

)

[inline]

Assigns method to use to solve minimization problem.

A default value is 1 (line search) if SetMethod is not called.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[in]

method

Method indicator: 1 = line search, 2 = double dogleg, 3 = More-Hebdon.

Definition at line 886 of file Uncmin.h.

{
  if (method == 2 || method == 3)
    algorithm = method;
  else
    algorithm = 1; // use default value of 1 for any values of argument other than 2 or 3

template<class V, class M, class FUNC>

void Uncmin< V, M, FUNC >::GetStoppingCriteria	(	double &	gradtol,
		double &	steptol,
		int &	iterations
	)			[inline]

Returns stopping criteria computed at the end of the last call to Minimize.

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Function Parameters

Parameters:

[out]	&gradtol	Address of gradient tolerance, i.e., how close the gradient is to zero.
[out]	&steptol	Address of maximum scaled difference between function parameters in consecutive iterations.
[out]	&iterations	Address of number of iterations used.

Definition at line 911 of file Uncmin.h.

{
  gradtol = mLastGradCrit;
  steptol = mLastStepCrit;
  iterations = mLastIteration;

template<class V, class M, class FUNC>

int Uncmin< V, M, FUNC >::GetMessage

(

)

[inline]

Returns message index generated in the last call to Minimize.

Returns message generated in the last call to Minimize.

Possible values of message are:

0 = Optimal solution found, terminated with gradient small. 1 = Terminated with gradient small, xpls is probably optimal. 2 = Terminated with stepsize small, xpls is probably optimal. 3 = Lower point cannot be found, xpls is probably optimal. 4 = Iteration limit (default 150) exceeded. 5 = Too many large steps, function may be unbounded. -1 = Analytic gradient check requested, but no analytic gradient supplied -2 = Analytic hessian check requested, but no analytic hessian supplied -3 = Illegal dimension -4 = Illegal tolerance -5 = Illegal iteration limit -6 = Minimization function has no good digits -7 = Iteration limit exceeded in lnsrch -20 = Function not defined at starting value -21 = Check of analytic gradient failed -22 = Check of analytic hessian failed

Template Arguments

Parameters:

	M	SCPPNT Matrix type.
	V	SCPPNT Vector type.
	FUNC	Type of function to minimize.

Definition at line 948 of file Uncmin.h.

{
  return mLastMessage;

---

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

• C:/programs/UNCMIN/src/include/Uncmin.h

---