ROOT logo
// @(#)root/mathmore:$Id: GSLSimAnMinimizer.h 29068 2009-06-17 16:28:51Z moneta $
// Author: L. Moneta Wed Dec 20 17:16:32 2006

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2006  LCG ROOT Math Team, CERN/PH-SFT                *
 *                                                                    *
 * This library 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 library 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 library (see file COPYING); if not, write          *
 * to the Free Software Foundation, Inc., 59 Temple Place, Suite      *
 * 330, Boston, MA 02111-1307 USA, or contact the author.             *
 *                                                                    *
 **********************************************************************/

// Header file for class GSLSimAnMinimizer

#ifndef ROOT_Math_GSLSimAnMinimizer
#define ROOT_Math_GSLSimAnMinimizer



#ifndef ROOT_Math_Minimizer
#include "Math/Minimizer.h"
#endif


#ifndef ROOT_Math_IFunctionfwd
#include "Math/IFunctionfwd.h"
#endif

#ifndef ROOT_Math_IParamFunctionfwd
#include "Math/IParamFunctionfwd.h"
#endif



#ifndef ROOT_Math_GSLSimAnnealing
#include "Math/GSLSimAnnealing.h"
#endif

#ifndef ROOT_Math_MinimizerVariable
#include "Math/MinimizerVariable.h"
#endif

#include <vector>
#include <map>



namespace ROOT { 

   namespace Math { 

      class  MinimTransformFunction;


//_____________________________________________________________________________________
/** 
   GSLSimAnMinimizer class for minimization using simulated annealing
   using the algorithm from 
   <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Simulated-Annealing.html">
   GSL</A>.
   It implements the ROOT::Minimizer interface and 
   a plug-in (name "GSLSimAn") exists to instantiate this class via the plug-in manager

   @ingroup Min1D
*/ 
class GSLSimAnMinimizer : public  ROOT::Math::Minimizer {

public: 

   /** 
      Default constructor
   */ 
   GSLSimAnMinimizer (int type = 0); 

   /** 
      Destructor (no operations)
   */ 
   ~GSLSimAnMinimizer ();  

private:
   // usually copying is non trivial, so we make this unaccessible

   /** 
      Copy constructor
   */ 
   GSLSimAnMinimizer(const GSLSimAnMinimizer &) : ROOT::Math::Minimizer() {} 

   /** 
      Assignment operator
   */ 
   GSLSimAnMinimizer & operator = (const GSLSimAnMinimizer & rhs)  {
      if (this == &rhs) return *this;  // time saving self-test
      return *this;
   }

public: 

   /// set the function to minimize
   virtual void SetFunction(const ROOT::Math::IMultiGenFunction & func); 

   /// set gradient the function to minimize
   virtual void SetFunction(const ROOT::Math::IMultiGradFunction & func); 

   /// set free variable 
   virtual bool SetVariable(unsigned int ivar, const std::string & name, double val, double step); 

   /// set fixed variable (override if minimizer supports them )
   virtual bool SetFixedVariable(unsigned int /* ivar */, const std::string & /* name */, double /* val */);  

   /// set lower limit variable  (override if minimizer supports them )
   virtual bool SetLowerLimitedVariable(unsigned int  ivar , const std::string & name , double val , double step , double lower );
   /// set upper limit variable (override if minimizer supports them )
   virtual bool SetUpperLimitedVariable(unsigned int ivar , const std::string & name , double val , double step , double upper ); 
   /// set upper/lower limited variable (override if minimizer supports them )
   virtual bool SetLimitedVariable(unsigned int ivar , const std::string & name , double val , double step , double /* lower */, double /* upper */); 

   /// set the value of an existing variable 
   virtual bool SetVariableValue(unsigned int ivar, double val );
   /// set the values of all existing variables (array must be dimensioned to the size of the existing parameters)
   virtual bool SetVariableValues(const double * x);


   /// method to perform the minimization
   virtual  bool Minimize(); 

   /// return minimum function value
   virtual double MinValue() const { return fMinVal; } 

   /// return expected distance reached from the minimum
   virtual double Edm() const { return 0; } // not impl. }

   /// return  pointer to X values at the minimum 
   virtual const double *  X() const { return &fValues.front(); } 

   /// return pointer to gradient values at the minimum 
   virtual const double *  MinGradient() const { return 0; } // not impl.  

   /// number of function calls to reach the minimum 
   virtual unsigned int NCalls() const { return 0; } // not yet ipl.  

   /// this is <= Function().NDim() which is the total 
   /// number of variables (free+ constrained ones) 
   virtual unsigned int NDim() const { return fDim; }   

   /// number of free variables (real dimension of the problem) 
   /// this is <= Function().NDim() which is the total 
   virtual unsigned int NFree() const { return fDim; }  

   /// minimizer provides error and error matrix
   virtual bool ProvidesError() const { return false; } 

   /// return errors at the minimum 
   virtual const double * Errors() const { return 0; }

   /** return covariance matrices elements 
       if the variable is fixed the matrix is zero
       The ordering of the variables is the same as in errors
   */ 
   virtual double CovMatrix(unsigned int , unsigned int ) const { return 0; }

   /// minos error for variable i, return false if Minos failed
   virtual bool GetMinosError(unsigned int , double & /* errLow */ , double & /* errUp */ ) { return false; }

   /// return reference to the objective function
   ///virtual const ROOT::Math::IGenFunction & Function() const; 


protected: 

private: 
   
   unsigned int fDim;     // dimension of the function to be minimized 
   bool fOwnFunc;        // flag to indicate if objective function is managed 

   ROOT::Math::GSLSimAnnealing  fSolver; 
   const ROOT::Math::IMultiGenFunction * fObjFunc; 
   
   double fMinVal;                    // minimum values 

   mutable std::vector<double> fValues;

   std::vector<double> fSteps;
   std::vector<std::string> fNames;
   std::vector<ROOT::Math::EMinimVariableType> fVarTypes;  // vector specifyng the type of variables
   std::map< unsigned int, std::pair<double, double> > fBounds; // map specifying the bound using as key the parameter index

}; 

   } // end namespace Math

} // end namespace ROOT


#endif /* ROOT_Math_GSLSimAnMinimizer */
 GSLSimAnMinimizer.h:1
 GSLSimAnMinimizer.h:2
 GSLSimAnMinimizer.h:3
 GSLSimAnMinimizer.h:4
 GSLSimAnMinimizer.h:5
 GSLSimAnMinimizer.h:6
 GSLSimAnMinimizer.h:7
 GSLSimAnMinimizer.h:8
 GSLSimAnMinimizer.h:9
 GSLSimAnMinimizer.h:10
 GSLSimAnMinimizer.h:11
 GSLSimAnMinimizer.h:12
 GSLSimAnMinimizer.h:13
 GSLSimAnMinimizer.h:14
 GSLSimAnMinimizer.h:15
 GSLSimAnMinimizer.h:16
 GSLSimAnMinimizer.h:17
 GSLSimAnMinimizer.h:18
 GSLSimAnMinimizer.h:19
 GSLSimAnMinimizer.h:20
 GSLSimAnMinimizer.h:21
 GSLSimAnMinimizer.h:22
 GSLSimAnMinimizer.h:23
 GSLSimAnMinimizer.h:24
 GSLSimAnMinimizer.h:25
 GSLSimAnMinimizer.h:26
 GSLSimAnMinimizer.h:27
 GSLSimAnMinimizer.h:28
 GSLSimAnMinimizer.h:29
 GSLSimAnMinimizer.h:30
 GSLSimAnMinimizer.h:31
 GSLSimAnMinimizer.h:32
 GSLSimAnMinimizer.h:33
 GSLSimAnMinimizer.h:34
 GSLSimAnMinimizer.h:35
 GSLSimAnMinimizer.h:36
 GSLSimAnMinimizer.h:37
 GSLSimAnMinimizer.h:38
 GSLSimAnMinimizer.h:39
 GSLSimAnMinimizer.h:40
 GSLSimAnMinimizer.h:41
 GSLSimAnMinimizer.h:42
 GSLSimAnMinimizer.h:43
 GSLSimAnMinimizer.h:44
 GSLSimAnMinimizer.h:45
 GSLSimAnMinimizer.h:46
 GSLSimAnMinimizer.h:47
 GSLSimAnMinimizer.h:48
 GSLSimAnMinimizer.h:49
 GSLSimAnMinimizer.h:50
 GSLSimAnMinimizer.h:51
 GSLSimAnMinimizer.h:52
 GSLSimAnMinimizer.h:53
 GSLSimAnMinimizer.h:54
 GSLSimAnMinimizer.h:55
 GSLSimAnMinimizer.h:56
 GSLSimAnMinimizer.h:57
 GSLSimAnMinimizer.h:58
 GSLSimAnMinimizer.h:59
 GSLSimAnMinimizer.h:60
 GSLSimAnMinimizer.h:61
 GSLSimAnMinimizer.h:62
 GSLSimAnMinimizer.h:63
 GSLSimAnMinimizer.h:64
 GSLSimAnMinimizer.h:65
 GSLSimAnMinimizer.h:66
 GSLSimAnMinimizer.h:67
 GSLSimAnMinimizer.h:68
 GSLSimAnMinimizer.h:69
 GSLSimAnMinimizer.h:70
 GSLSimAnMinimizer.h:71
 GSLSimAnMinimizer.h:72
 GSLSimAnMinimizer.h:73
 GSLSimAnMinimizer.h:74
 GSLSimAnMinimizer.h:75
 GSLSimAnMinimizer.h:76
 GSLSimAnMinimizer.h:77
 GSLSimAnMinimizer.h:78
 GSLSimAnMinimizer.h:79
 GSLSimAnMinimizer.h:80
 GSLSimAnMinimizer.h:81
 GSLSimAnMinimizer.h:82
 GSLSimAnMinimizer.h:83
 GSLSimAnMinimizer.h:84
 GSLSimAnMinimizer.h:85
 GSLSimAnMinimizer.h:86
 GSLSimAnMinimizer.h:87
 GSLSimAnMinimizer.h:88
 GSLSimAnMinimizer.h:89
 GSLSimAnMinimizer.h:90
 GSLSimAnMinimizer.h:91
 GSLSimAnMinimizer.h:92
 GSLSimAnMinimizer.h:93
 GSLSimAnMinimizer.h:94
 GSLSimAnMinimizer.h:95
 GSLSimAnMinimizer.h:96
 GSLSimAnMinimizer.h:97
 GSLSimAnMinimizer.h:98
 GSLSimAnMinimizer.h:99
 GSLSimAnMinimizer.h:100
 GSLSimAnMinimizer.h:101
 GSLSimAnMinimizer.h:102
 GSLSimAnMinimizer.h:103
 GSLSimAnMinimizer.h:104
 GSLSimAnMinimizer.h:105
 GSLSimAnMinimizer.h:106
 GSLSimAnMinimizer.h:107
 GSLSimAnMinimizer.h:108
 GSLSimAnMinimizer.h:109
 GSLSimAnMinimizer.h:110
 GSLSimAnMinimizer.h:111
 GSLSimAnMinimizer.h:112
 GSLSimAnMinimizer.h:113
 GSLSimAnMinimizer.h:114
 GSLSimAnMinimizer.h:115
 GSLSimAnMinimizer.h:116
 GSLSimAnMinimizer.h:117
 GSLSimAnMinimizer.h:118
 GSLSimAnMinimizer.h:119
 GSLSimAnMinimizer.h:120
 GSLSimAnMinimizer.h:121
 GSLSimAnMinimizer.h:122
 GSLSimAnMinimizer.h:123
 GSLSimAnMinimizer.h:124
 GSLSimAnMinimizer.h:125
 GSLSimAnMinimizer.h:126
 GSLSimAnMinimizer.h:127
 GSLSimAnMinimizer.h:128
 GSLSimAnMinimizer.h:129
 GSLSimAnMinimizer.h:130
 GSLSimAnMinimizer.h:131
 GSLSimAnMinimizer.h:132
 GSLSimAnMinimizer.h:133
 GSLSimAnMinimizer.h:134
 GSLSimAnMinimizer.h:135
 GSLSimAnMinimizer.h:136
 GSLSimAnMinimizer.h:137
 GSLSimAnMinimizer.h:138
 GSLSimAnMinimizer.h:139
 GSLSimAnMinimizer.h:140
 GSLSimAnMinimizer.h:141
 GSLSimAnMinimizer.h:142
 GSLSimAnMinimizer.h:143
 GSLSimAnMinimizer.h:144
 GSLSimAnMinimizer.h:145
 GSLSimAnMinimizer.h:146
 GSLSimAnMinimizer.h:147
 GSLSimAnMinimizer.h:148
 GSLSimAnMinimizer.h:149
 GSLSimAnMinimizer.h:150
 GSLSimAnMinimizer.h:151
 GSLSimAnMinimizer.h:152
 GSLSimAnMinimizer.h:153
 GSLSimAnMinimizer.h:154
 GSLSimAnMinimizer.h:155
 GSLSimAnMinimizer.h:156
 GSLSimAnMinimizer.h:157
 GSLSimAnMinimizer.h:158
 GSLSimAnMinimizer.h:159
 GSLSimAnMinimizer.h:160
 GSLSimAnMinimizer.h:161
 GSLSimAnMinimizer.h:162
 GSLSimAnMinimizer.h:163
 GSLSimAnMinimizer.h:164
 GSLSimAnMinimizer.h:165
 GSLSimAnMinimizer.h:166
 GSLSimAnMinimizer.h:167
 GSLSimAnMinimizer.h:168
 GSLSimAnMinimizer.h:169
 GSLSimAnMinimizer.h:170
 GSLSimAnMinimizer.h:171
 GSLSimAnMinimizer.h:172
 GSLSimAnMinimizer.h:173
 GSLSimAnMinimizer.h:174
 GSLSimAnMinimizer.h:175
 GSLSimAnMinimizer.h:176
 GSLSimAnMinimizer.h:177
 GSLSimAnMinimizer.h:178
 GSLSimAnMinimizer.h:179
 GSLSimAnMinimizer.h:180
 GSLSimAnMinimizer.h:181
 GSLSimAnMinimizer.h:182
 GSLSimAnMinimizer.h:183
 GSLSimAnMinimizer.h:184
 GSLSimAnMinimizer.h:185
 GSLSimAnMinimizer.h:186
 GSLSimAnMinimizer.h:187
 GSLSimAnMinimizer.h:188
 GSLSimAnMinimizer.h:189
 GSLSimAnMinimizer.h:190
 GSLSimAnMinimizer.h:191
 GSLSimAnMinimizer.h:192
 GSLSimAnMinimizer.h:193
 GSLSimAnMinimizer.h:194
 GSLSimAnMinimizer.h:195
 GSLSimAnMinimizer.h:196
 GSLSimAnMinimizer.h:197
 GSLSimAnMinimizer.h:198
 GSLSimAnMinimizer.h:199
 GSLSimAnMinimizer.h:200
 GSLSimAnMinimizer.h:201
 GSLSimAnMinimizer.h:202
 GSLSimAnMinimizer.h:203
 GSLSimAnMinimizer.h:204
 GSLSimAnMinimizer.h:205
 GSLSimAnMinimizer.h:206