leastsquare.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2001, 2002, 2003 Nicolas Di Césaré
 Copyright (C) 2005, 2007 StatPro Italia srl
 
 This file is part of QuantLib, a free-software/open-source library
 for financial quantitative analysts and developers - http://quantlib.org/
 
 QuantLib is free software: you can redistribute it and/or modify it
 under the terms of the QuantLib license.  You should have received a
 copy of the license along with this program; if not, please email
 <quantlib-dev@lists.sf.net>. The license is also available online at
 <http://quantlib.org/license.shtml>.
 
 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 license for more details.
*/
 
#ifndef quantlib_least_square_hpp
#define quantlib_least_square_hpp
 
#include <ql/math/optimization/problem.hpp>
#include <ql/math/optimization/conjugategradient.hpp>
#include <ql/math/matrix.hpp>
 
namespace QuantLib {
 
    class Constraint;
    class OptimizationMethod;
 
    class LeastSquareProblem {
      public:
        virtual ~LeastSquareProblem() = default;
        virtual Size size() = 0;
        virtual void targetAndValue(const Array& x,
                                    Array& target,
                                    Array& fct2fit) = 0;
        virtual void targetValueAndGradient(const Array& x,
                                            Matrix& grad_fct2fit,
                                            Array& target,
                                            Array& fct2fit) = 0;
    };
 
 
    class LeastSquareFunction : public CostFunction {
      public:
        LeastSquareFunction(LeastSquareProblem& lsp) : lsp_(lsp) {}
        ~LeastSquareFunction() override = default;
 
        Real value(const Array& x) const override;
        Array values(const Array&) const override;
        void gradient(Array& grad_f, const Array& x) const override;
        Real valueAndGradient(Array& grad_f, const Array& x) const override;
 
      protected:
        LeastSquareProblem &lsp_;
    };
 
 
    class NonLinearLeastSquare {
      public:
        NonLinearLeastSquare(Constraint& c,
                             Real accuracy = 1e-4,
                             Size maxiter = 100);
        NonLinearLeastSquare(Constraint& c,
                             Real accuracy,
                             Size maxiter,
                             ext::shared_ptr<OptimizationMethod> om);
        ~NonLinearLeastSquare() = default;
 
        Array& perform(LeastSquareProblem& lsProblem);
 
        void setInitialValue(const Array& initialValue) {
            initialValue_ = initialValue;
        }
 
        Array& results() { return results_; }
 
        Real residualNorm() const { return resnorm_; }
 
        Real lastValue() const { return bestAccuracy_; }
 
        Integer exitFlag() const { return exitFlag_; }
 
        Integer iterationsNumber() const { return nbIterations_; }
 
      private:
        Array results_, initialValue_;
        Real resnorm_;
        Integer exitFlag_;
        Real accuracy_, bestAccuracy_;
        Size maxIterations_, nbIterations_;
        ext::shared_ptr<OptimizationMethod> om_;
        //constraint
        Constraint& c_;
 
    };
 
}
 
#endif