NewtonDescent.hpp

Go to the documentation of this file.

/*
 * $Id: NewtonDescent.hpp 105 2013-06-02 15:46:43Z jdl3 $
 * Copyright (C) 2011, 2013 John D Lamb
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef IPO_DETAIL_NEWTONDESCENT_HPP
#define IPO_DETAIL_NEWTONDESCENT_HPP

#include<cmath>
#include<limits>
#include<ostream>
#include<iomanip>
#include<ccgsl/blas.hpp>
#include<ccgsl/linalg.hpp>
#include"LineSearch.hpp"
#include"../../ipo_function/DerivativesEstimates.hpp"
#include"GSL.hpp"
#include"../IPOException.hpp"

namespace ipo {
  namespace detail {
  
    class NewtonDescent {
    public:
      class Parameters {
      public:
    Parameters();
    void setOutputStream( std::ostream* outputStream );
    std::ostream* getOutputStream() const;
    bool getPhaseI() const { return phaseI; }
    void setPhaseI( bool const phaseI ){ this->phaseI = phaseI; }
    void setGradTol( double const gradTol ){ this->gradTol = gradTol; }
    void setStepTol( double const stepTol ){ this->stepTol = stepTol; }
    void setIterMax( size_t const iterMax ){ this->iterMax = iterMax; }
    void setf_typ( double const f_typ ){ this->f_typ = f_typ; }
    void setx_typ( gsl::vector x_typ ){ this->x_typ = x_typ; }
    double getGradTol() const { return gradTol; }
    double getStepTol() const { return stepTol; }
    size_t getIterMax() const { return iterMax; }
    double getf_typ() const { return f_typ; }
    gsl::vector getx_typ() const { return x_typ; }
    void setVectorDigits( size_t const vectorDigits ){
      this->vectorDigits = vectorDigits; }
    size_t getVectorDigits() const { return vectorDigits; }
      private:
    std::ostream* outputStream;
    bool phaseI;
    double gradTol;
    double stepTol;
    size_t iterMax;
    double f_typ;
    gsl::vector x_typ;
    size_t vectorDigits;
      };
    private:
      Parameters parameters;
    public:
      NewtonDescent( ipo_function::Function& function, ipo_function::DerivativesEstimates& de,
             gsl::matrix const equalityConstraintsMatrix = gsl::matrix(),
             gsl::vector const equalityConstraintsBounds = gsl::vector() );
      double operator()( gsl::vector& x, double objectiveValue );
      void setFunctionScale( double const functionScale ){
    this->functionScale = functionScale; }
      enum struct StoppingCondition {
    gradTol, 
      stepTol, 
      iterMax, 
      noStopping 
      };
      StoppingCondition getLastStoppingCondition() const;
      Parameters& getParameters();
      LineSearch::Parameters& getLineSearchParameters();
    protected:
      // Forward declaration
      class Stopping;
      friend class Stopping;
      mutable StoppingCondition lastStoppingCondition = StoppingCondition::noStopping;
      gsl::matrix const equalityConstraintsMatrix;
      ipo_function::Function& function;
      ipo_function::DerivativesEstimates& de;
      LineSearch lineSearch;
      double functionScale;
      gsl::matrix A;
      gsl::matrix V;
      gsl::vector S;
      gsl::vector work;
      gsl::vector b;
    };

    class NewtonDescent::Stopping {
    public:
      Stopping( NewtonDescent const& newtonDescent );
      bool operator()( size_t const iteration, double const fValue, gsl::vector const& gradient,
               gsl::vector const& vector, gsl::vector const& lastVector ) const;
    private:
      NewtonDescent const& newtonDescent;
    };
  }
}

#endif