ROL_Types.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//               Rapid Optimization Library (ROL) Package
//
// Copyright 2014 NTESS and the ROL contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef ROL_TYPES_HPP
#define ROL_TYPES_HPP

#ifdef  HAVE_ROL_DEBUG
#define ROL_VALIDATE( A )  A
#else
#define ROL_VALIDATE( A ) /* empty */
#endif

#include <algorithm>
#include <complex>
#include <exception>
#include <string>
#include <sstream>
#include <limits>
#include <type_traits>
#include <ROL_stacktrace.hpp>
#include "ROL_ScalarTraits.hpp"
#include <ROL_Ptr.hpp>
#include <ROL_Vector.hpp>
#include <ROL_config.h>

#define ROL_NUM_CHECKDERIV_STEPS 13



namespace ROL {

  template<class T>
  std::string NumberToString( T Number )
  {
    std::ostringstream ss;
    ss << Number;
    return ss.str();
  }

  template<class Real>
  inline Real ROL_EPSILON(void) { return std::abs(ROL::ScalarTraits<Real>::eps()); }
  //static const Real ROL_EPSILON<Real>() = std::abs(ROL::ScalarTraits<Real>::eps());

  template<class Real>
  inline Real ROL_THRESHOLD(void) { return 10.0 * ROL_EPSILON<Real>(); }

  template<class Real>
  inline Real ROL_OVERFLOW(void) { return std::abs(ROL::ScalarTraits<Real>::rmax()); }

  template<class Real>
  inline Real ROL_INF(void) { return 0.1*ROL_OVERFLOW<Real>(); }

  template<class Real>
  inline Real ROL_NINF(void) { return -ROL_INF<Real>(); }

  template<class Real>
  inline Real ROL_UNDERFLOW(void) { return std::abs(ROL::ScalarTraits<Real>::rmin()); }

  enum EExitStatus {
    EXITSTATUS_CONVERGED = 0,
    EXITSTATUS_MAXITER,
    EXITSTATUS_STEPTOL,
    EXITSTATUS_NAN,
    EXITSTATUS_USERDEFINED,
    EXITSTATUS_LAST
  };

  inline std::string EExitStatusToString(EExitStatus tr) {
    std::string retString;
    switch(tr) {
      case EXITSTATUS_CONVERGED:   retString = "Converged";                          break;
      case EXITSTATUS_MAXITER:     retString = "Iteration Limit Exceeded";           break;
      case EXITSTATUS_STEPTOL:     retString = "Step Tolerance Met";                 break;
      case EXITSTATUS_NAN:         retString = "Step and/or Gradient Returned NaN";  break;
      case EXITSTATUS_USERDEFINED: retString = "User Defined";                       break;
      case EXITSTATUS_LAST:        retString = "Last Type (Dummy)";                  break;
      default:                     retString = "INVALID EExitStatus";
    }
    return retString;
  }

  template<class Real>
  struct AlgorithmState {
    int  iter;
    int  minIter;
    int  nfval;
    int  ncval;
    int  ngrad;
    Real value;
    Real minValue;
    Real gnorm;
    Real cnorm;
    Real snorm;
    Real aggregateGradientNorm;
    Real aggregateModelError;
    bool flag;
    ROL::Ptr<Vector<Real> > iterateVec;
    ROL::Ptr<Vector<Real> > lagmultVec;
    ROL::Ptr<Vector<Real> > minIterVec;
    EExitStatus statusFlag;

    AlgorithmState(void) : iter(0), minIter(0), nfval(0), ngrad(0), value(0), minValue(0), 
      gnorm(std::numeric_limits<Real>::max()),
      cnorm(std::numeric_limits<Real>::max()),
      snorm(std::numeric_limits<Real>::max()), 
      aggregateGradientNorm(std::numeric_limits<Real>::max()),
      aggregateModelError(std::numeric_limits<Real>::max()),
      flag(false),
      iterateVec(ROL::nullPtr), lagmultVec(ROL::nullPtr), minIterVec(ROL::nullPtr),
      statusFlag(EXITSTATUS_LAST) {}
    
    virtual ~AlgorithmState() {}

    void reset(void) {
      iter                  = 0;
      minIter               = 0;
      nfval                 = 0;
      ncval                 = 0;
      ngrad                 = 0;
      value                 = ROL_INF<Real>();
      minValue              = ROL_INF<Real>();
      gnorm                 = ROL_INF<Real>();
      cnorm                 = ROL_INF<Real>();
      snorm                 = ROL_INF<Real>();
      aggregateGradientNorm = ROL_INF<Real>();
      aggregateModelError   = ROL_INF<Real>();
      flag                  = false;
      if (iterateVec != ROL::nullPtr) {
        iterateVec->zero();
      }
      if (lagmultVec != ROL::nullPtr) {
        lagmultVec->zero();
      }
      if (minIterVec != ROL::nullPtr) {
        minIterVec->zero();
      }
    }
  };

  template<class Real>
  struct StepState {
    ROL::Ptr<Vector<Real> > gradientVec;
    ROL::Ptr<Vector<Real> > descentVec;
    ROL::Ptr<Vector<Real> > constraintVec;
    int nfval;
    int ngrad;
    Real searchSize; // line search parameter (alpha) or trust-region radius (delta)
    int flag; // Was step successful?
    int SPiter; // Subproblem iteration count
    int SPflag; // Subproblem termination flag

    StepState(void) : gradientVec(ROL::nullPtr),
                      descentVec(ROL::nullPtr),
                      constraintVec(ROL::nullPtr),
                      nfval(0),
                      ngrad(0),
                      searchSize(0),
                      flag(0),
                      SPiter(0),
                      SPflag(0) {}

    void reset(const Real searchSizeInput = 1.0) {
      if (gradientVec != ROL::nullPtr) {
        gradientVec->zero();
      }
      if (descentVec != ROL::nullPtr) {
        descentVec->zero();
      }
      if (constraintVec != ROL::nullPtr) {
        constraintVec->zero();
      }
      nfval = 0;
      ngrad = 0;
      searchSize = searchSizeInput;
      flag = 0;
      SPiter = 0;
      SPflag = 0;
    }
  };

  struct removeSpecialCharacters {
    bool operator()(char c) {
      return (c ==' ' || c =='-' || c == '(' || c == ')' || c=='\'' || c=='\r' || c=='\n' || c=='\t');
    }
  };

  inline std::string removeStringFormat( std::string s ) {
    std::string output = s;
    output.erase( std::remove_if( output.begin(), output.end(), removeSpecialCharacters()), output.end() );
    std::transform( output.begin(), output.end(), output.begin(), ::tolower );
    return output;
  }

  // Types of optimization problem
  enum EProblem {
    TYPE_U = 0,
    TYPE_P,
    TYPE_B,
    TYPE_E,
    TYPE_EB,
    TYPE_LAST
  };

  enum EStep{
    STEP_AUGMENTEDLAGRANGIAN = 0,
    STEP_BUNDLE,
    STEP_COMPOSITESTEP,
    STEP_LINESEARCH,
    STEP_MOREAUYOSIDAPENALTY,
    STEP_PRIMALDUALACTIVESET,
    STEP_TRUSTREGION,
    STEP_INTERIORPOINT,
    STEP_FLETCHER,
    STEP_LAST
  };

  inline std::string EStepToString(EStep tr) {
    std::string retString;
    switch(tr) {
      case STEP_AUGMENTEDLAGRANGIAN: retString = "Augmented Lagrangian";   break;
      case STEP_BUNDLE:              retString = "Bundle";                 break;
      case STEP_COMPOSITESTEP:       retString = "Composite Step";         break;
      case STEP_LINESEARCH:          retString = "Line Search";            break;
      case STEP_MOREAUYOSIDAPENALTY: retString = "Moreau-Yosida Penalty";  break;
      case STEP_PRIMALDUALACTIVESET: retString = "Primal Dual Active Set"; break;
      case STEP_TRUSTREGION:         retString = "Trust Region";           break;
      case STEP_INTERIORPOINT:       retString = "Interior Point";         break;
      case STEP_FLETCHER:            retString = "Fletcher";               break;
      case STEP_LAST:                retString = "Last Type (Dummy)";      break;
      default:                       retString = "INVALID EStep";
    }
    return retString;
  }

  inline bool isCompatibleStep( EProblem p, EStep s ) {
    bool comp = false;
    switch(p) {

      case TYPE_U:    comp = ( (s == STEP_LINESEARCH) ||
                               (s == STEP_TRUSTREGION) ||
                               (s == STEP_BUNDLE) );
        break;
      case TYPE_P:    comp = ( (s == STEP_LINESEARCH) ||
                               (s == STEP_TRUSTREGION));
        break; 
      case TYPE_B:    comp = ( (s == STEP_LINESEARCH)  ||
                               (s == STEP_TRUSTREGION) ||
                               (s == STEP_MOREAUYOSIDAPENALTY) ||
                               (s == STEP_PRIMALDUALACTIVESET) ||
                               (s == STEP_INTERIORPOINT) );
        break;

      case TYPE_E:    comp = ( (s == STEP_COMPOSITESTEP) ||
                               (s == STEP_AUGMENTEDLAGRANGIAN) ||
                               (s == STEP_FLETCHER) );
        break;

      case TYPE_EB:   comp = ( (s == STEP_AUGMENTEDLAGRANGIAN) ||
                               (s == STEP_MOREAUYOSIDAPENALTY) ||
                               (s == STEP_INTERIORPOINT) ||
                               (s == STEP_FLETCHER) );
        break;

      case TYPE_LAST: comp = false; break;
      default:        comp = false;
    }
    return comp;
  }

  inline std::string EProblemToString( EProblem p ) {
    std::string retString;
    switch(p) {
      case TYPE_U:     retString = "Type-U";             break;
      case TYPE_P:     retString = "Type-P";             break;
      case TYPE_E:     retString = "Type-E";             break;
      case TYPE_B:     retString = "Type-B";             break;
      case TYPE_EB:    retString = "Type-EB";            break;
      case TYPE_LAST:  retString = "Type-Last (Dummy)";  break;
      default:         retString = "Invalid EProblem";
    }
    return retString;
  }
  
 
  inline int isValidStep(EStep ls) {
    return( (ls == STEP_AUGMENTEDLAGRANGIAN) ||
            (ls == STEP_BUNDLE) ||
            (ls == STEP_COMPOSITESTEP) ||
            (ls == STEP_LINESEARCH) ||
            (ls == STEP_MOREAUYOSIDAPENALTY) ||
            (ls == STEP_PRIMALDUALACTIVESET) ||
            (ls == STEP_TRUSTREGION) || 
            (ls == STEP_INTERIORPOINT) ||
            (ls == STEP_FLETCHER) ) ;
  }

  inline EStep & operator++(EStep &type) {
    return type = static_cast<EStep>(type+1);
  }

  inline EStep operator++(EStep &type, int) {
    EStep oldval = type;
    ++type;
    return oldval;
  }

  inline EStep & operator--(EStep &type) {
    return type = static_cast<EStep>(type-1);
  }

  inline EStep operator--(EStep &type, int) {
    EStep oldval = type;
    --type;
    return oldval;
  }

  inline EStep StringToEStep(std::string s) {
    s = removeStringFormat(s);
    for ( EStep st = STEP_AUGMENTEDLAGRANGIAN; st < STEP_LAST; ++st ) {
      if ( !s.compare(removeStringFormat(EStepToString(st))) ) {
        return st;
      }
    }
    return STEP_LAST;
  }

  enum EDescent{
    DESCENT_STEEPEST = 0,
    DESCENT_NONLINEARCG,
    DESCENT_SECANT,
    DESCENT_NEWTON,
    DESCENT_NEWTONKRYLOV,
    DESCENT_LAST
  };

  inline std::string EDescentToString(EDescent tr) {
    std::string retString;
    switch(tr) {
      case DESCENT_STEEPEST:             retString = "Steepest Descent";                          break;
      case DESCENT_NONLINEARCG:          retString = "Nonlinear CG";                              break;
      case DESCENT_SECANT:               retString = "Quasi-Newton Method";                       break;
      case DESCENT_NEWTON:               retString = "Newton's Method";                           break;
      case DESCENT_NEWTONKRYLOV:         retString = "Newton-Krylov";                             break;
      case DESCENT_LAST:                 retString = "Last Type (Dummy)";                         break;
      default:                           retString = "INVALID ESecant";
    }
    return retString;
  }

  inline int isValidDescent(EDescent d){
    return( (d == DESCENT_STEEPEST)      ||
            (d == DESCENT_NONLINEARCG)   ||
            (d == DESCENT_SECANT)        ||
            (d == DESCENT_NEWTON)        ||
            (d == DESCENT_NEWTONKRYLOV)
          );
  }

  inline EDescent & operator++(EDescent &type) {
    return type = static_cast<EDescent>(type+1);
  }

  inline EDescent operator++(EDescent &type, int) {
    EDescent oldval = type;
    ++type;
    return oldval;
  }

  inline EDescent & operator--(EDescent &type) {
    return type = static_cast<EDescent>(type-1);
  }

  inline EDescent operator--(EDescent &type, int) {
    EDescent oldval = type;
    --type;
    return oldval;
  }

  inline EDescent StringToEDescent(std::string s) {
    s = removeStringFormat(s);
    for ( EDescent des = DESCENT_STEEPEST; des < DESCENT_LAST; des++ ) {
      if ( !s.compare(removeStringFormat(EDescentToString(des))) ) {
        return des;
      }
    }
    return DESCENT_SECANT;
  }
  
  enum ESecant{
    SECANT_LBFGS = 0,
    SECANT_LDFP,
    SECANT_LSR1,
    SECANT_BARZILAIBORWEIN,
    SECANT_USERDEFINED,
    SECANT_LAST
  };

  inline std::string ESecantToString(ESecant tr) {
    std::string retString;
    switch(tr) {
      case SECANT_LBFGS:           retString = "Limited-Memory BFGS"; break;
      case SECANT_LDFP:            retString = "Limited-Memory DFP";  break;
      case SECANT_LSR1:            retString = "Limited-Memory SR1";  break;
      case SECANT_BARZILAIBORWEIN: retString = "Barzilai-Borwein";    break;
      case SECANT_USERDEFINED:     retString = "User-Defined";        break;
      case SECANT_LAST:            retString = "Last Type (Dummy)";   break;
      default:                     retString = "INVALID ESecant";
    }
    return retString;
  }
  
  inline int isValidSecant(ESecant s) {
    return( (s == SECANT_LBFGS)           ||
            (s == SECANT_LDFP)            ||
            (s == SECANT_LSR1)            ||
            (s == SECANT_BARZILAIBORWEIN) ||
            (s == SECANT_USERDEFINED)
          );
  }

  inline ESecant & operator++(ESecant &type) {
    return type = static_cast<ESecant>(type+1);
  }

  inline ESecant operator++(ESecant &type, int) {
    ESecant oldval = type;
    ++type;
    return oldval;
  }

  inline ESecant & operator--(ESecant &type) {
    return type = static_cast<ESecant>(type-1);
  }

  inline ESecant operator--(ESecant &type, int) {
    ESecant oldval = type;
    --type;
    return oldval;
  }

  inline ESecant StringToESecant(std::string s) {
    s = removeStringFormat(s);
    for ( ESecant sec = SECANT_LBFGS; sec < SECANT_LAST; sec++ ) {
      if ( !s.compare(removeStringFormat(ESecantToString(sec))) ) {
        return sec;
      }
    }
    return SECANT_LBFGS;
  }
  
  enum ENonlinearCG{
    NONLINEARCG_HESTENES_STIEFEL = 0,
    NONLINEARCG_FLETCHER_REEVES,
    NONLINEARCG_DANIEL,
    NONLINEARCG_POLAK_RIBIERE,
    NONLINEARCG_FLETCHER_CONJDESC,
    NONLINEARCG_LIU_STOREY,
    NONLINEARCG_DAI_YUAN,
    NONLINEARCG_HAGER_ZHANG,
    NONLINEARCG_OREN_LUENBERGER,
    NONLINEARCG_USERDEFINED,
    NONLINEARCG_LAST
  };

  inline std::string ENonlinearCGToString(ENonlinearCG tr) {
    std::string retString;
    switch(tr) {
      case NONLINEARCG_HESTENES_STIEFEL:      retString = "Hestenes-Stiefel";            break;
      case NONLINEARCG_FLETCHER_REEVES:       retString = "Fletcher-Reeves";             break;
      case NONLINEARCG_DANIEL:                retString = "Daniel (uses Hessian)";       break;
      case NONLINEARCG_POLAK_RIBIERE:         retString = "Polak-Ribiere";               break;
      case NONLINEARCG_FLETCHER_CONJDESC:     retString = "Fletcher Conjugate Descent";  break;
      case NONLINEARCG_LIU_STOREY:            retString = "Liu-Storey";                  break;
      case NONLINEARCG_DAI_YUAN:              retString = "Dai-Yuan";                    break;
      case NONLINEARCG_HAGER_ZHANG:           retString = "Hager-Zhang";                 break;
      case NONLINEARCG_OREN_LUENBERGER:       retString = "Oren-Luenberger";             break;
      case NONLINEARCG_USERDEFINED:           retString = "User Defined";                break;
      case NONLINEARCG_LAST:                  retString = "Last Type (Dummy)";           break;
      default:                                retString = "INVALID ENonlinearCG";
    }
    return retString;
  }
  
  inline int isValidNonlinearCG(ENonlinearCG s) {
    return( (s == NONLINEARCG_HESTENES_STIEFEL)  ||
            (s == NONLINEARCG_FLETCHER_REEVES)   ||
            (s == NONLINEARCG_DANIEL)            ||
            (s == NONLINEARCG_POLAK_RIBIERE)     ||
            (s == NONLINEARCG_FLETCHER_CONJDESC) ||
            (s == NONLINEARCG_LIU_STOREY)        ||
            (s == NONLINEARCG_DAI_YUAN)          ||
            (s == NONLINEARCG_HAGER_ZHANG)       ||
            (s == NONLINEARCG_OREN_LUENBERGER)   ||
            (s == NONLINEARCG_USERDEFINED)
          );
  }

  inline ENonlinearCG & operator++(ENonlinearCG &type) {
    return type = static_cast<ENonlinearCG>(type+1);
  }

  inline ENonlinearCG operator++(ENonlinearCG &type, int) {
    ENonlinearCG oldval = type;
    ++type;
    return oldval;
  }

  inline ENonlinearCG & operator--(ENonlinearCG &type) {
    return type = static_cast<ENonlinearCG>(type-1);
  }

  inline ENonlinearCG operator--(ENonlinearCG &type, int) {
    ENonlinearCG oldval = type;
    --type;
    return oldval;
  }

  inline ENonlinearCG StringToENonlinearCG(std::string s) {
    s = removeStringFormat(s);
    for ( ENonlinearCG nlcg = NONLINEARCG_HESTENES_STIEFEL; nlcg < NONLINEARCG_LAST; nlcg++ ) {
      if ( !s.compare(removeStringFormat(ENonlinearCGToString(nlcg))) ) {
        return nlcg;
      }
    }
    return NONLINEARCG_HESTENES_STIEFEL;
  }
  
  enum ELineSearch{
    LINESEARCH_ITERATIONSCALING = 0,
    LINESEARCH_PATHBASEDTARGETLEVEL,
    LINESEARCH_BACKTRACKING,
    LINESEARCH_BISECTION,
    LINESEARCH_GOLDENSECTION,
    LINESEARCH_CUBICINTERP,
    LINESEARCH_BRENTS,
    LINESEARCH_USERDEFINED,
    LINESEARCH_LAST
  };

  inline std::string ELineSearchToString(ELineSearch ls) {
    std::string retString;
    switch(ls) {
      case LINESEARCH_ITERATIONSCALING:     retString = "Iteration Scaling";       break;
      case LINESEARCH_PATHBASEDTARGETLEVEL: retString = "Path-Based Target Level"; break;
      case LINESEARCH_BACKTRACKING:         retString = "Backtracking";            break;
      case LINESEARCH_BISECTION:            retString = "Bisection";               break;
      case LINESEARCH_GOLDENSECTION:        retString = "Golden Section";          break;
      case LINESEARCH_CUBICINTERP:          retString = "Cubic Interpolation";     break;
      case LINESEARCH_BRENTS:               retString = "Brent's";                 break;
      case LINESEARCH_USERDEFINED:          retString = "User Defined";            break;
      case LINESEARCH_LAST:                 retString = "Last Type (Dummy)";       break;
      default:                              retString = "INVALID ELineSearch";
    }
    return retString;
  }
  
  inline int isValidLineSearch(ELineSearch ls){
    return( (ls == LINESEARCH_BACKTRACKING)         ||
            (ls == LINESEARCH_ITERATIONSCALING)     ||
            (ls == LINESEARCH_PATHBASEDTARGETLEVEL) ||
            (ls == LINESEARCH_BISECTION)            ||
            (ls == LINESEARCH_GOLDENSECTION)        ||
            (ls == LINESEARCH_CUBICINTERP)          ||
            (ls == LINESEARCH_BRENTS)               ||
            (ls == LINESEARCH_USERDEFINED)
          );
  }

  inline ELineSearch & operator++(ELineSearch &type) {
    return type = static_cast<ELineSearch>(type+1);
  }

  inline ELineSearch operator++(ELineSearch &type, int) {
    ELineSearch oldval = type;
    ++type;
    return oldval;
  }

  inline ELineSearch & operator--(ELineSearch &type) {
    return type = static_cast<ELineSearch>(type-1);
  }

  inline ELineSearch operator--(ELineSearch &type, int) {
    ELineSearch oldval = type;
    --type;
    return oldval;
  }

  inline ELineSearch StringToELineSearch(std::string s) {
    s = removeStringFormat(s);
    for ( ELineSearch ls = LINESEARCH_ITERATIONSCALING; ls < LINESEARCH_LAST; ls++ ) {
      if ( !s.compare(removeStringFormat(ELineSearchToString(ls))) ) {
        return ls;
      }
    }
    return LINESEARCH_ITERATIONSCALING;
  }

  enum ECurvatureCondition{
    CURVATURECONDITION_WOLFE = 0,
    CURVATURECONDITION_STRONGWOLFE,
    CURVATURECONDITION_GENERALIZEDWOLFE,
    CURVATURECONDITION_APPROXIMATEWOLFE,
    CURVATURECONDITION_GOLDSTEIN,
    CURVATURECONDITION_NULL,
    CURVATURECONDITION_LAST
  };

  inline std::string ECurvatureConditionToString(ECurvatureCondition ls) {
    std::string retString;
    switch(ls) {
      case CURVATURECONDITION_WOLFE:            retString = "Wolfe Conditions";             break;
      case CURVATURECONDITION_STRONGWOLFE:      retString = "Strong Wolfe Conditions";      break;
      case CURVATURECONDITION_GENERALIZEDWOLFE: retString = "Generalized Wolfe Conditions"; break;
      case CURVATURECONDITION_APPROXIMATEWOLFE: retString = "Approximate Wolfe Conditions"; break;
      case CURVATURECONDITION_GOLDSTEIN:        retString = "Goldstein Conditions";         break;
      case CURVATURECONDITION_NULL:             retString = "Null Curvature Condition";     break;
      case CURVATURECONDITION_LAST:             retString = "Last Type (Dummy)";            break;
      default:                                  retString = "INVALID ECurvatureCondition";
    }
    return retString;
  }
  
  inline int isValidCurvatureCondition(ECurvatureCondition ls){
    return( (ls == CURVATURECONDITION_WOLFE)            ||
            (ls == CURVATURECONDITION_STRONGWOLFE)      ||
            (ls == CURVATURECONDITION_GENERALIZEDWOLFE) ||
            (ls == CURVATURECONDITION_APPROXIMATEWOLFE) ||
            (ls == CURVATURECONDITION_GOLDSTEIN)        ||
            (ls == CURVATURECONDITION_NULL)
          );
  }

  inline ECurvatureCondition & operator++(ECurvatureCondition &type) {
    return type = static_cast<ECurvatureCondition>(type+1);
  }

  inline ECurvatureCondition operator++(ECurvatureCondition &type, int) {
    ECurvatureCondition oldval = type;
    ++type;
    return oldval;
  }

  inline ECurvatureCondition & operator--(ECurvatureCondition &type) {
    return type = static_cast<ECurvatureCondition>(type-1);
  }

  inline ECurvatureCondition operator--(ECurvatureCondition &type, int) {
    ECurvatureCondition oldval = type;
    --type;
    return oldval;
  }

  inline ECurvatureCondition StringToECurvatureCondition(std::string s) {
    s = removeStringFormat(s);
    for ( ECurvatureCondition cc = CURVATURECONDITION_WOLFE; cc < CURVATURECONDITION_LAST; cc++ ) {
      if ( !s.compare(removeStringFormat(ECurvatureConditionToString(cc))) ) {
        return cc;
      }
    }
    return CURVATURECONDITION_WOLFE;
  }

  enum ECGFlag {
    CG_FLAG_SUCCESS = 0,
    CG_FLAG_ITEREXCEED,
    CG_FLAG_NEGCURVE,
    CG_FLAG_TRRADEX,
    CG_FLAG_ZERORHS,
    CG_FLAG_UNDEFINED 
  };


  inline std::string ECGFlagToString(ECGFlag cgf) {
    std::string retString;
    switch(cgf) {
      case CG_FLAG_SUCCESS:
        retString = "Residual tolerance met";
        break;
      case CG_FLAG_ITEREXCEED:
        retString = "Iteration limit exceeded";
        break;
      case CG_FLAG_NEGCURVE:
        retString = "Negative curvature detected";
        break;
      case CG_FLAG_TRRADEX:   
        retString = "Trust-Region radius exceeded";
        break;
      case CG_FLAG_ZERORHS:
        retString = "Initial right hand side is zero";
        break;
      default:
        retString = "INVALID ECGFlag";  
    }
    return retString;
  }



  // For use in gradient and Hessian checks
  namespace Finite_Difference_Arrays {

    // Finite difference steps in axpy form    
    const int shifts[4][4] = { {  1,  0,  0, 0 },  // First order
                               { -1,  2,  0, 0 },  // Second order
                               { -1,  2,  1, 0 },  // Third order
                               { -1, -1,  3, 1 }   // Fourth order
                             };

      // Finite difference weights     
     const double weights[4][5] = { { -1.0,          1.0, 0.0,      0.0,      0.0      },  // First order
                                    {  0.0,     -1.0/2.0, 1.0/2.0,  0.0,      0.0      },  // Second order
                                    { -1.0/2.0, -1.0/3.0, 1.0,     -1.0/6.0,  0.0      },  // Third order
                                    {  0.0,     -2.0/3.0, 1.0/12.0, 2.0/3.0, -1.0/12.0 }   // Fourth order
                                  };

  }


// Generic conversion from Element type to Real type
template<class Real, class Element>
struct TypeCaster {
  static Real ElementToReal( const Element &val ) {
    return Real(0);
  }
};

// Partially specialize for complex<Real>
template<class Real>
struct TypeCaster<Real, std::complex<Real> > {
  static Real ElementToReal( const std::complex<Real> &val ) {
    return val.real();
  } 
};

// Fully specialize for double,float
template<>
struct TypeCaster<double,float> {
  static double ElementToReal( const float &val ) {
    return static_cast<double>(val);
  }
};

// Cast from Element type to Real type
template<class Element, class Real>
Real rol_cast(const Element &val) {
  return TypeCaster<Real,Element>::ElementToReal(val);
}






namespace Exception {

class NotImplemented : public std::logic_error {
public:
  NotImplemented( const std::string& what_arg ) :
    std::logic_error(what_arg) {}


}; // class NotImplemented
 

#if __cplusplus >= 201402L // using C++14

using std::enable_if_t;

#else // No C++14

template<bool B, class T=void>
using enable_if_t = typename std::enable_if<B,T>::type;

#endif





} // namespace Exception


} // namespace ROL


#endif