Login  Register

Re: Hi, I'm the user of QuantLib

Posted by 蔡宗儒-風險管理處-銀行 on Mar 28, 2011; 2:17am
URL: http://quantlib.414.s1.nabble.com/Hi-I-m-the-user-of-QuantLib-tp13330p13332.html

Hello,
    I deeply appreciate for your reply.(you are right about 0.6180)
 
    Actually, in E1, the root is not real and the min is (-0.5, 0.75)
                     in E2, the root is (-1.6180,0) ,(0.6180,0) and the min is (-0.5,-1.25)
 
    When using LevenbergMarquardt the result is the min in E1 but root in E2.
    When using ConjugateGradient the result is the min in E1 and also min in E2.
 
    I got a little confused about these two optimization method.
    The method ConjugateGradient in Qunatlib is actully to find the min.
    But I don't know how to read the LevenbergMarquardt result.
    Can you tell me LevenbergMarquardt  in Qunatlib is goal to find min or root?
    Thanks for you reply again!!!!
 
 
 
Here is my code in c#(sorry about not c++)
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using QLNet;
class Program
{
    static void Main(string[] args)
    {
        Vector coefficients = new Vector();
        coefficients.Add(-1);
        coefficients.Add(1);
        coefficients.Add(1);
 
        CostFunction costFunction = new OneDimensionalPolynomialDegreeN(coefficients);
        Constraint constraint = new NoConstraint();
        Vector initialValue = new Vector(1, 2);
        Problem problem = new Problem(costFunction, constraint, initialValue);
 
        double epslon = 1.0e-10;
        OptimizationMethod optimizationMethod = new LevenbergMarquardt(epslon, epslon, epslon);
        //OptimizationMethod optimizationMethod = new ConjugateGradient();
        EndCriteria endCriteria = new EndCriteria(1000, 100, epslon, epslon, epslon);
 
        EndCriteria.Type endCriteriaType = optimizationMethod.minimize(problem, endCriteria);
 
        Vector x = problem.currentValue();
        Vector y = problem.values(x);
            
        Console.WriteLine("endCriteriaType : " + endCriteriaType.ToString());
        Console.WriteLine("x : " + x[0]);
        Console.WriteLine("y : " + y[0]);
        Console.Read();

    }
 
 
    public class OneDimensionalPolynomialDegreeN : CostFunction
    {
        private Vector coefficients_;
        private int polynomialDegree_;
 
        public OneDimensionalPolynomialDegreeN(Vector coefficients)
        {
            coefficients_ = new Vector(coefficients);
            polynomialDegree_ = coefficients.size() - 1;
        }
 
        public override double value(Vector x)
        {
            if (x.size() != 1) throw new ApplicationException("independent variable must be 1 dimensional");
            double y = 0;
            for (int i = 0; i <= polynomialDegree_; ++i)
                y += coefficients_[i] * Utils.Pow(x[0], i);
            return y;
        }
 
        public override Vector values(Vector x)
        {
            if (x.size() != 1) throw new ApplicationException("independent variable must be 1 dimensional");
            Vector y = new Vector(1);
            y[0] = value(x);
            return y;
        }
    }
}
 
    Thank you very much!!!!
 
Regards,
 
蔡宗儒   Jason Tsai
永豐銀行風險管理處
TEL:81618681
FAX:81618482
 


From: Kim Kuen Tang [mailto:[hidden email]]
Sent: Monday, March 28, 2011 3:37 AM
To: [hidden email]; 蔡宗儒-風險管理處-銀行
Subject: Re: [Quantlib-dev] Hi, I'm the user of QuantLib


Hi Jason,

can you provide a standalone example the next time?

Am 25.03.2011 05:09, schrieb 蔡宗儒-風險管理處-銀行:
Hello,
    I'm the user of QuantLib.
    I have some question about optimization.
 
    I use the optimization method LevenbergMarquardt and the cost function OneDimensionalPolynomialDegreeN in optimizers.cpp
    I solve the following eqtions seperately(I did not solve together) 
        E1 = 1+x+x^2
        E2 = -1+x+x^2
    In E1, I get the right solution, (x ,E1)=(-0.5 , 0.75)
    In E2, I get the wrong solution, (x,E2)=(-0.6180 , 0)
 
    I think the reason why E2 get the wrong answear is that LevenbergMarquardt method use "MINPACK.lmdif".The MINPACK.lmdif seems to minize the sum of square.

This is true according to the documentation for minpack subroutine lmdif. So the procedure will terminate when especially a root is founded. This is also the reason why you got 0.6180 ( you really mean 0.6180 and not -0.6180) as a result since this is a root from E2.

Below a standalone example is provided:


# include <iostream>
# include <ql/math/optimization/levenbergmarquardt.hpp>
# include <ql/math/optimization/constraint.hpp>
# include <ql/math/optimization/costfunction.hpp>
# include <boost/foreach.hpp>


using namespace QuantLib;

class OneDimensionalPolynomialDegreeN : public CostFunction {
      public:
        OneDimensionalPolynomialDegreeN(const Array& coefficients)
        : coefficients_(coefficients),
          polynomialDegree_(coefficients.size()-1) {}

        Real value(const Array& x) const {
            QL_REQUIRE(x.size()==1,"independent variable must be 1 dimensional");
            Real y = 0;
            for (Size i=0; i<=polynomialDegree_; ++i) y += coefficients_[i]*std::pow(x[0],static_cast<int>(i));
            return y;
        }

        Disposable<Array> values(const Array& x) const{
            QL_REQUIRE(x.size()==1,"independent variable must be 1 dimensional");
            Array y(1);
            y[0] = value(x);
            return y;
        }

      private:
        Array const coefficients_;
        Size const polynomialDegree_;
    };


int main()
{

    Array c(3, 1.0); c[0]=-1.0;
    OneDimensionalPolynomialDegreeN p(c);
    NoConstraint n;

    Real ps[] = { -3.0,-2.0,-1.5,-1.0,-0.5,0.0,0.5,1.0,1.5,2.0,3.0 };

    std::cout<< "init" << "\t" << "result" << "\t" << "value" << "\t" << "ec" << "\n";
    BOOST_FOREACH(Real init,ps)
    {
        Array i(1, init);
        LevenbergMarquardt o;
        EndCriteria e(1000, 100, 1e-5, 1e-5, 1e-5);
        Problem pp(p, n,i);
        EndCriteria::Type ec = o.minimize(pp, e);
        Array xM = pp.currentValue();
        Array yM = pp.values(xM);

        std::cout<< init << "\t" << xM[0] << "\t" << yM[0] << "\t" << ec << "\n";
    }


    return 1;
}

    That means it dose not minize the equation but MSE.
 
    Therefore,I think LevenbergMarquardt in QuantLib seems to min the value (E1-0)^2 in E1 and  min the value (E2-0)^2 in E2.Hence I got the wrong solution.
 
    So, did I use the method wrong ?
    Or QuantLib use the wrong methd "MINPACK.lmdif" ?
 
 
Regards,
 
蔡宗 儒   Jason Tsai
永豐銀行 風險管理處
TEL:81618681
FAX:81618482
 
------------------------------------------------------------------------------ Enable your software for Intel(R) Active Management Technology to meet the growing manageability and security demands of your customers. Businesses are taking advantage of Intel(R) vPro (TM) technology - will your software be a part of the solution? Download the Intel(R) Manageability Checker today! http://p.sf.net/sfu/intel-dev2devmar
_______________________________________________ QuantLib-dev mailing list [hidden email] https://lists.sourceforge.net/lists/listinfo/quantlib-dev


------------------------------------------------------------------------------
Enable your software for Intel(R) Active Management Technology to meet the
growing manageability and security demands of your customers. Businesses
are taking advantage of Intel(R) vPro (TM) technology - will your software
be a part of the solution? Download the Intel(R) Manageability Checker
today! http://p.sf.net/sfu/intel-dev2devmar
_______________________________________________
QuantLib-dev mailing list
[hidden email]
https://lists.sourceforge.net/lists/listinfo/quantlib-dev