first minimiser implementation

latan/Makefile.am

@@ -38,6 +38,7 @@ liblatan_la_SOURCES =   \
     MathInterpreter.cpp \
     MathParser.ypp      \
     MathLexer.lpp       \
+    Minimizer.cpp       \
     Plot.cpp            \
     RandGen.cpp         \
     Sample.cpp          \
@@ -53,11 +54,18 @@ liblatan_la_HEADERS =   \
     Mat.hpp             \
     Math.hpp            \
     MathInterpreter.hpp \
+    Minimizer.hpp       \
     ParserState.hpp     \
     Plot.hpp            \
     RandGen.hpp         \
     Sample.hpp          \
     StatArray.hpp
+    
+if HAVE_MINUIT
+liblatan_la_SOURCES += MinuitMinimizer.cpp
+liblatan_la_HEADERS += MinuitMinimizer.hpp
+endif
+
 liblatan_la_CFLAGS = $(COM_CFLAGS)
 liblatan_la_CXXFLAGS = $(COM_CXXFLAGS)
 

latan/Minimizer.cpp

@@ -0,0 +1,58 @@
+/*
+ * Minimizer.cpp, part of LatAnalyze 3
+ *
+ * Copyright (C) 2013 - 2014 Antonin Portelli
+ *
+ * LatAnalyze 3 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LatAnalyze 3 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 LatAnalyze 3.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <latan/Minimizer.hpp>
+#include <latan/includes.hpp>
+
+using namespace std;
+using namespace Latan;
+
+/******************************************************************************
+ *                       Minimizer implementation                             *
+ ******************************************************************************/
+// constructor /////////////////////////////////////////////////////////////////
+Minimizer::Minimizer(Verbosity verbosity)
+: verbosity_(verbosity)
+{}
+
+// access //////////////////////////////////////////////////////////////////////
+unsigned int Minimizer::getDim(void) const
+{
+    return static_cast<unsigned int>(x_.size());
+}
+
+DVec & Minimizer::getState(void)
+{
+    return x_;
+}
+
+Minimizer::Verbosity Minimizer::getVerbosity(void) const
+{
+    return verbosity_;
+}
+
+void Minimizer::setInit(const DVec &x0)
+{
+    x_ = x0;
+}
+
+void Minimizer::setVerbosity(const Verbosity verbosity)
+{
+    verbosity_ = verbosity;
+}

latan/Minimizer.hpp

@@ -0,0 +1,64 @@
+/*
+ * Minimizer.hpp, part of LatAnalyze 3
+ *
+ * Copyright (C) 2013 - 2014 Antonin Portelli
+ *
+ * LatAnalyze 3 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LatAnalyze 3 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 LatAnalyze 3.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef Latan_Minimizer_hpp_
+#define Latan_Minimizer_hpp_
+
+#include <latan/Global.hpp>
+#include <latan/Function.hpp>
+#include <latan/Mat.hpp>
+
+BEGIN_NAMESPACE
+
+/******************************************************************************
+ *                        Abstract minimizer class                            *
+ ******************************************************************************/
+
+class Minimizer
+{
+public:
+    enum class Verbosity
+    {
+        Silent = 0,
+        Normal = 1,
+        Debug  = 2
+    };
+public:
+    // constructor
+    Minimizer(Verbosity verbosity = Verbosity::Silent);
+    // destructor
+    virtual ~Minimizer(void) = default;
+    // access
+    unsigned int getDim(void) const;
+    Verbosity    getVerbosity(void) const;
+    void         setInit(const DVec &x0);
+    void         setVerbosity(const Verbosity verbosity);
+    // minimization
+    virtual const DVec & operator()(const DoubleFunction &f) = 0;
+protected:
+    // access
+    DVec & getState(void);
+private:
+    DVec      x_;
+    Verbosity verbosity_;
+};
+
+END_NAMESPACE
+
+#endif // Latan_Minimizer_hpp_

latan/MinuitMinimizer.cpp

@@ -0,0 +1,129 @@
+/*
+ * MinuitMinimizer.cpp, part of LatAnalyze 3
+ *
+ * Copyright (C) 2013 - 2014 Antonin Portelli
+ *
+ * LatAnalyze 3 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LatAnalyze 3 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 LatAnalyze 3.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <latan/MinuitMinimizer.hpp>
+#include <latan/includes.hpp>
+#include <Minuit2/FCNBase.h>
+#include <Minuit2/FunctionMinimum.h>
+#include <Minuit2/MnMigrad.h>
+#include <Minuit2/MnPrint.h>
+#include <Minuit2/MnPlot.h>
+#include <Minuit2/MnScan.h>
+#include <Minuit2/MnSimplex.h>
+#include <Minuit2/ScanMinimizer.h>
+#include <Minuit2/SimplexMinimizer.h>
+#include <Minuit2/VariableMetricMinimizer.h>
+
+using namespace std;
+using namespace ROOT;
+using namespace Minuit2;
+using namespace Latan;
+
+/******************************************************************************
+ *                    MinuitMinimizer implementation                          *
+ ******************************************************************************/
+// MinuitFunction constructor //////////////////////////////////////////////////
+MinuitMinimizer::MinuitFunction::MinuitFunction(const DoubleFunction &f)
+: f_(&f)
+{}
+
+// MinuitFunction minuit members ///////////////////////////////////////////////
+double MinuitMinimizer::MinuitFunction::operator()
+    (const vector<double> &x) const
+{
+    return f_->evaluate(x);
+}
+
+double MinuitMinimizer::MinuitFunction::Up(void) const
+{
+    return 1.;
+}
+
+// minimization ////////////////////////////////////////////////////////////////
+const DVec & MinuitMinimizer::operator()(const DoubleFunction &f)
+{
+    DVec &x = getState();
+    Verbosity verbosity = getVerbosity();
+    
+    if (f.getNArg() != x.size())
+    {
+        x.conservativeResize(f.getNArg());
+    }
+    
+    // set parameters
+    MinuitFunction minuitF(f);
+    MnUserParameters parameters;
+    
+    for (unsigned int i = 0; i < x.size(); ++i)
+    {
+        parameters.Add("x_" + strFrom(i), x(i), 0.1*fabs(x(i)));
+    }
+    
+    // pre-minimization
+    MnMigrad migrad0(minuitF, parameters, 0);
+    FunctionMinimum min = migrad0();
+    
+    if (verbosity >= Verbosity::Debug)
+    {
+        cout << "-- MINUIT pre-minimization -----------------------------";
+        cout << min;
+        cout << "--------------------------------------------------------";
+        cout << endl;
+    }
+    for (unsigned int i = 0; i < x.size(); ++i)
+    {
+        parameters.SetValue(i, min.UserParameters().Value(i));
+        parameters.SetError(i, min.UserParameters().Error(i));
+    }
+    
+    // minimization and output
+    MnMigrad  migrad2(minuitF, parameters, 2);
+    
+    min = migrad2();
+    for (unsigned int i = 0; i < x.size(); ++i)
+    {
+        x(i) = min.UserParameters().Value(i);
+    }
+    if (verbosity >= Verbosity::Normal)
+    {
+        cout << "-- MINUIT minimization ---------------------------------";
+        cout << min;
+        cout << "--------------------------------------------------------";
+        cout << endl;
+    }
+    if (verbosity >= Verbosity::Debug)
+    {
+        vector<pair<double, double>> scanRes;
+        MnPlot plot;
+        MnScan scanner(minuitF, min.UserParameters(), 2);
+        
+        cout << "-- MINUIT scan -----------------------------------------";
+        cout << endl;
+        for (unsigned int i = 0; i < x.size(); i++)
+        {
+            cout << "Parameter x_" << i << endl;
+            scanRes = scanner.Scan(i);
+            plot(scanRes);
+        }
+        cout << "--------------------------------------------------------";
+        cout << endl;
+    }
+    
+    return x;
+}

latan/MinuitMinimizer.hpp

@@ -0,0 +1,61 @@
+/*
+ * MinuitMinimizer.hpp, part of LatAnalyze 3
+ *
+ * Copyright (C) 2013 - 2014 Antonin Portelli
+ *
+ * LatAnalyze 3 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LatAnalyze 3 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 LatAnalyze 3.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef Latan_MinuitMinimizer_hpp_
+#define Latan_MinuitMinimizer_hpp_
+
+#include <latan/Global.hpp>
+#include <latan/Function.hpp>
+#include <latan/Minimizer.hpp>
+#include <Minuit2/FCNBase.h>
+
+BEGIN_NAMESPACE
+
+/******************************************************************************
+ *                             Minuit minimizer                               *
+ ******************************************************************************/
+
+class MinuitMinimizer: public Minimizer
+{
+private:
+    class MinuitFunction: public ROOT::Minuit2::FCNBase
+    {
+    public:
+        // constructor
+        explicit MinuitFunction(const DoubleFunction &f);
+        // destructor
+        virtual ~MinuitFunction(void) = default;
+        // minuit members
+        virtual double operator()(const std::vector<double> &x) const;
+        virtual double Up(void) const;
+    private:
+        const DoubleFunction *f_;
+    };
+public:
+    // constructors
+    using Minimizer::Minimizer;
+    // destructor
+    virtual ~MinuitMinimizer(void) = default;
+    // minimization
+    virtual const DVec & operator()(const DoubleFunction &f);
+};
+
+END_NAMESPACE
+
+#endif // Latan_MinuitMinimizer_hpp_