// @(#)root/mathcore:$Id$
// Author: L. Moneta Fri Sep 22 15:06:47 2006

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2006  LCG ROOT Math Team, CERN/PH-SFT                *
 *                                                                    *
 *                                                                    *
 **********************************************************************/

// Header file for class Minimizer

#ifndef ROOT_Math_Minimizer
#define ROOT_Math_Minimizer

#ifndef ROOT_Math_IFunction
#include "Math/IFunction.h"
#endif

#ifndef ROOT_Math_MinimizerOptions
#include "Math/MinimizerOptions.h"
#endif

#ifndef ROOT_Math_Util
#include "Math/Util.h"
#endif

#ifndef ROOT_Math_Error
#include "Math/Error.h"
#endif



#include <vector>
#include <string>

#include <limits>
#include <cmath>


namespace ROOT {

   namespace Fit {
      class ParameterSettings;
   }


   namespace Math {

/**
   @defgroup MultiMin Multi-dimensional Minimization
   @ingroup NumAlgo

   Classes implementing algorithms for multi-dimensional minimization
 */



//_______________________________________________________________________________
/**
   Abstract Minimizer class, defining  the interface for the various minimizer
   (like Minuit2, Minuit, GSL, etc..)
   Plug-in's exist in ROOT to be able to instantiate the derived classes like
   ROOT::Math::GSLMinimizer or ROOT::Math::Minuit2Minimizer via the
   plug-in manager.

   Provides interface for setting the function to be minimized.
   The function must  implemente the multi-dimensional generic interface
   ROOT::Math::IBaseFunctionMultiDim.
   If the function provides gradient calculation
   (implements the ROOT::Math::IGradientFunctionMultiDim interface) this will be
   used by the Minimizer.

   It Defines also interface for setting the initial values for the function variables (which are the parameters in
   of the model function in case of solving for fitting) and especifying their limits.

   It defines the interface to set and retrieve basic minimization parameters
   (for specific Minimizer parameters one must use the derived classes).

   Then it defines the interface to retrieve the result of minimization ( minimum X values, function value,
   gradient, error on the mimnimum, etc...)

   @ingroup MultiMin
*/

class Minimizer {

public:

   /**
      Default constructor
   */
   Minimizer () :
      fValidError(false),
      fStatus(-1)
   {}

   /**
      Destructor (no operations)
   */
   virtual ~Minimizer ()  {}




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

   /**
      Copy constructor
   */
   Minimizer(const Minimizer &) {}

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

public:

   /// reset for consecutive minimizations - implement if needed
   virtual void Clear() {}

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

   /// set a function to minimize using gradient
   virtual void SetFunction(const ROOT::Math::IMultiGradFunction & func)
   {
      SetFunction(static_cast<const ::ROOT::Math::IMultiGenFunction &> (func));
   }


   /// add variables  . Return number of variables successfully added
   template<class VariableIterator>
   int SetVariables(const VariableIterator & begin, const VariableIterator & end) {
      unsigned int ivar = 0;
      for ( VariableIterator vitr = begin; vitr != end; ++vitr) {
         bool iret = false;
         if (vitr->IsFixed() )
            iret = SetFixedVariable(ivar,  vitr->Name(), vitr->Value() );
         else if (vitr->IsDoubleBound() )
            iret = SetLimitedVariable(ivar,  vitr->Name(), vitr->Value(), vitr->StepSize(), vitr->LowerLimit(), vitr->UpperLimit() );
         else if (vitr->HasLowerLimit() )
            iret = SetLowerLimitedVariable(ivar,  vitr->Name(), vitr->Value(), vitr->StepSize(), vitr->LowerLimit() );
         else if (vitr->HasUpperLimit() )
            iret = SetUpperLimitedVariable(ivar,  vitr->Name(), vitr->Value(), vitr->StepSize(), vitr->UpperLimit() );
         else
            iret = SetVariable( ivar, vitr->Name(), vitr->Value(), vitr->StepSize() );

         if (iret) ivar++;

         // an error message should be eventually be reported in the virtual single SetVariable methods
      }
      return ivar;
   }
   /// set a new free variable
   virtual bool SetVariable(unsigned int ivar, const std::string & name, double val, double step) = 0;
   /// set a new lower limit variable  (override if minimizer supports them )
   virtual bool SetLowerLimitedVariable(unsigned int  ivar , const std::string & name , double val , double step , double lower ) {
      return SetLimitedVariable(ivar, name, val, step, lower, std::numeric_limits<double>::infinity() );
   }
   /// set a new upper limit variable (override if minimizer supports them )
   virtual bool SetUpperLimitedVariable(unsigned int ivar , const std::string & name , double val , double step , double upper ) {
      return SetLimitedVariable(ivar, name, val, step, - std::numeric_limits<double>::infinity(), upper );
   }
   /// set a new upper/lower limited variable (override if minimizer supports them ) otherwise as default set an unlimited variable
   virtual bool SetLimitedVariable(unsigned int ivar  , const std::string & name  , double val  , double  step ,
                                   double lower , double  upper ) {
      MATH_WARN_MSG("Minimizer::SetLimitedVariable","Setting of limited variable not implemented - set as unlimited");
      MATH_UNUSED(lower); MATH_UNUSED(upper);
      return SetVariable(ivar, name, val, step);
   }
   /// set a new fixed variable (override if minimizer supports them )
   virtual bool SetFixedVariable(unsigned int  ivar  , const std::string &  name , double val  ) {
      MATH_ERROR_MSG("Minimizer::SetFixedVariable","Setting of fixed variable not implemented");
      MATH_UNUSED(ivar); MATH_UNUSED(name); MATH_UNUSED(val);
      return false;
   }
   /// set the value of an already existing variable
   virtual bool SetVariableValue(unsigned int ivar , double value) {
      MATH_ERROR_MSG("Minimizer::SetVariableValue","Set of a variable value not implemented");
      MATH_UNUSED(ivar); MATH_UNUSED(value);
      return false;
   }
   /// set the values of all existing variables (array must be dimensioned to the size of the existing parameters)
   virtual bool SetVariableValues(const double * x) {
      bool ret = true;
      unsigned int i = 0;
      while ( i <= NDim() && ret) {
         ret &= SetVariableValue(i,x[i] ); i++;
      }
      return ret;
   }
   /// set the step size of an already existing variable
   virtual bool SetVariableStepSize(unsigned int ivar, double value ) {
      MATH_ERROR_MSG("Minimizer::SetVariableStepSize","Setting an existing variable step size not implemented");
      MATH_UNUSED(ivar); MATH_UNUSED(value);
      return false;
   }
   /// set the lower-limit of an already existing variable
   virtual bool SetVariableLowerLimit(unsigned int ivar, double lower) {
      MATH_ERROR_MSG("Minimizer::SetVariableLowerLimit","Setting an existing variable limit not implemented");
      MATH_UNUSED(ivar); MATH_UNUSED(lower);
      return false;
   }
   /// set the upper-limit of an already existing variable
   virtual bool SetVariableUpperLimit(unsigned int ivar, double upper) {
      MATH_ERROR_MSG("Minimizer::SetVariableUpperLimit","Setting an existing variable limit not implemented");
      MATH_UNUSED(ivar); MATH_UNUSED(upper);
      return false;
   }
   /// set the limits of an already existing variable
   virtual bool SetVariableLimits(unsigned int ivar, double lower, double upper) {
      return SetVariableLowerLimit(ivar,lower) && SetVariableUpperLimit(ivar,upper);
   }
   /// fix an existing variable
   virtual bool FixVariable(unsigned int ivar) {
      MATH_ERROR_MSG("Minimizer::FixVariable","Fixing an existing variable not implemented");
      MATH_UNUSED(ivar);
      return false;
   }
   /// release an existing variable
   virtual bool ReleaseVariable(unsigned int ivar) {
      MATH_ERROR_MSG("Minimizer::ReleaseVariable","Releasing an existing variable not implemented");
      MATH_UNUSED(ivar);
      return false;
   }
   /// query if an existing variable is fixed (i.e. considered constant in the minimization)
   /// note that by default all variables are not fixed
   virtual bool IsFixedVariable(unsigned int ivar) const {
      MATH_ERROR_MSG("Minimizer::IsFixedVariable","Quering an existing variable not implemented");
      MATH_UNUSED(ivar);
      return false;
   }
   /// get variable settings in a variable object (like ROOT::Fit::ParamsSettings)
   virtual bool GetVariableSettings(unsigned int ivar, ROOT::Fit::ParameterSettings & pars) const {
      MATH_ERROR_MSG("Minimizer::GetVariableSettings","Quering an existing variable not implemented");
      MATH_UNUSED(ivar); MATH_UNUSED(pars);
      return false;
   }


   /// set the initial range of an existing variable
   virtual bool SetVariableInitialRange(unsigned int /* ivar */, double /* mininitial */, double /* maxinitial */) {
     return false;
   }

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

   /// return minimum function value
   virtual double MinValue() const = 0;

   /// return  pointer to X values at the minimum
   virtual const double *  X() const = 0;

   /// return expected distance reached from the minimum (re-implement if minimizer provides it
   virtual double Edm() const { return -1; }

   /// return pointer to gradient values at the minimum
   virtual const double *  MinGradient() const { return NULL; }

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

   /// number of iterations to reach the minimum
   virtual unsigned int NIterations() const { return NCalls(); }

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

   /// number of free variables (real dimension of the problem)
   /// this is <= Function().NDim() which is the total
   /// (re-implement if minimizer supports bounded parameters)
   virtual unsigned int NFree() const { return NDim(); }

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

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

   /** return covariance matrices element for variables ivar,jvar
       if the variable is fixed the return value is zero
       The ordering of the variables is the same as in the parameter and errors vectors
   */
   virtual double CovMatrix(unsigned int  ivar , unsigned int jvar ) const {
      MATH_UNUSED(ivar); MATH_UNUSED(jvar);
      return 0;
   }

   /**
       Fill the passed array with the  covariance matrix elements
       if the variable is fixed or const the value is zero.
       The array will be filled as cov[i *ndim + j]
       The ordering of the variables is the same as in errors and parameter value.
       This is different from the direct interface of Minuit2 or TMinuit where the
       values were obtained only to variable parameters
   */
   virtual bool GetCovMatrix(double * covMat) const {
      MATH_UNUSED(covMat);
      return false;
   }

   /**
       Fill the passed array with the Hessian matrix elements
       The Hessian matrix is the matrix of the second derivatives
       and is the inverse of the covariance matrix
       If the variable is fixed or const the values for that variables are zero.
       The array will be filled as h[i *ndim + j]
   */
   virtual bool GetHessianMatrix(double * hMat) const {
      MATH_UNUSED(hMat);
      return false;
   }


   ///return status of covariance matrix
   /// using Minuit convention {0 not calculated 1 approximated 2 made pos def , 3 accurate}
   /// Minimizer who implements covariance matrix calculation will re-implement the method
   virtual int CovMatrixStatus() const {
      return 0;
   }

   /**
      return correlation coefficient between variable i and j.
      If the variable is fixed or const the return value is zero
    */
   virtual double Correlation(unsigned int i, unsigned int j ) const {
      double tmp = CovMatrix(i,i) * CovMatrix(j,j);
      return ( tmp < 0) ? 0 : CovMatrix(i,j) / std::sqrt( tmp );
   }

   /**
      return global correlation coefficient for variable i
      This is a number between zero and one which gives
      the correlation between the i-th parameter  and that linear combination of all
      other parameters which is most strongly correlated with i.
      Minimizer must overload method if implemented
    */
   virtual double GlobalCC(unsigned int ivar) const {
      MATH_UNUSED(ivar);
      return -1;
   }

   /**
      minos error for variable i, return false if Minos failed or not supported
      and the lower and upper errors are returned in errLow and errUp
      An extra flag  specifies if only the lower (option=-1) or the upper (option=+1) error calculation is run
      (This feature is not yet implemented)
   */
   virtual bool GetMinosError(unsigned int ivar , double & errLow, double & errUp, int option = 0) {
      MATH_ERROR_MSG("Minimizer::GetMinosError","Minos Error not implemented");
      MATH_UNUSED(ivar); MATH_UNUSED(errLow); MATH_UNUSED(errUp); MATH_UNUSED(option);
      return false;
   }

   /**
      perform a full calculation of the Hessian matrix for error calculation
    */
   virtual bool Hesse() {
      MATH_ERROR_MSG("Minimizer::Hesse","Hesse not implemented");
      return false;
   }

   /**
      scan function minimum for variable i. Variable and function must be set before using Scan
      Return false if an error or if minimizer does not support this functionality
    */
   virtual bool Scan(unsigned int ivar , unsigned int & nstep , double * x , double * y ,
                     double xmin = 0, double xmax = 0) {
      MATH_ERROR_MSG("Minimizer::Scan","Scan not implemented");
      MATH_UNUSED(ivar); MATH_UNUSED(nstep); MATH_UNUSED(x); MATH_UNUSED(y);
      MATH_UNUSED(xmin); MATH_UNUSED(xmax);
      return false;
   }

   /**
      find the contour points (xi, xj) of the function for parameter ivar and jvar around the minimum
      The contour will be find for value of the function = Min + ErrorUp();
    */
   virtual bool Contour(unsigned int ivar , unsigned int jvar, unsigned int & npoints,
                        double *  xi , double * xj ) {
      MATH_ERROR_MSG("Minimizer::Contour","Contour not implemented");
      MATH_UNUSED(ivar); MATH_UNUSED(jvar); MATH_UNUSED(npoints);
      MATH_UNUSED(xi); MATH_UNUSED(xj);
      return false;
   }

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

   /// print the result according to set level (implemented for TMinuit for mantaining Minuit-style printing)
   virtual void PrintResults() {}

   /// get name of variables (override if minimizer support storing of variable names)
   /// return an empty string if variable is not found
   virtual std::string VariableName(unsigned int ivar) const {
      MATH_UNUSED(ivar);
      return std::string(); // return empty string
   }

   /// get index of variable given a variable given a name
   /// return -1 if variable is not found
   virtual int VariableIndex(const std::string & name) const {
      MATH_ERROR_MSG("Minimizer::VariableIndex","Getting variable index from name not implemented");
      MATH_UNUSED(name);
      return -1;
   }

   /** minimizer configuration parameters **/

   /// set print level
   int PrintLevel() const { return fOptions.PrintLevel(); }

   ///  max number of function calls
   unsigned int MaxFunctionCalls() const { return fOptions.MaxFunctionCalls(); }

   /// max iterations
   unsigned int MaxIterations() const { return fOptions.MaxIterations(); }

   /// absolute tolerance
   double Tolerance() const { return  fOptions.Tolerance(); }

   /// precision of minimizer in the evaluation of the objective function
   /// ( a value <=0 corresponds to the let the minimizer choose its default one)
   double Precision() const { return fOptions.Precision(); }

   /// strategy
   int Strategy() const { return fOptions.Strategy(); }

   /// status code of minimizer
   int Status() const { return fStatus; }

   /// return the statistical scale used for calculate the error
   /// is typically 1 for Chi2 and 0.5 for likelihood minimization
   double ErrorDef() const { return fOptions.ErrorDef(); }

   ///return true if Minimizer has performed a detailed error validation (e.g. run Hesse for Minuit)
   bool IsValidError() const { return fValidError; }

   /// retrieve the minimizer options (implement derived class if needed)
   virtual MinimizerOptions  Options() const {
      return fOptions;
   }

   /// set print level
   void SetPrintLevel(int level) { fOptions.SetPrintLevel(level); }

   ///set maximum of function calls
   void SetMaxFunctionCalls(unsigned int maxfcn) { if (maxfcn > 0) fOptions.SetMaxFunctionCalls(maxfcn); }

   /// set maximum iterations (one iteration can have many function calls)
   void SetMaxIterations(unsigned int maxiter) { if (maxiter > 0) fOptions.SetMaxIterations(maxiter); }

   /// set the tolerance
   void SetTolerance(double tol) { fOptions.SetTolerance(tol); }

   /// set in the minimizer the objective function evaluation precision
   /// ( a value <=0 means the minimizer will choose its optimal value automatically, i.e. default case)
   void SetPrecision(double prec) { fOptions.SetPrecision(prec); }

   ///set the strategy
   void SetStrategy(int strategyLevel) { fOptions.SetStrategy(strategyLevel); }

   /// set scale for calculating the errors
   void SetErrorDef(double up) { fOptions.SetErrorDef(up); }

   /// flag to check if minimizer needs to perform accurate error analysis (e.g. run Hesse for Minuit)
   void SetValidError(bool on) { fValidError = on; }

   /// set all options in one go
   void SetOptions(const MinimizerOptions & opt) {
      fOptions = opt;
   }

   /// reset the defaut options (defined in MinimizerOptions)
   void SetDefaultOptions() {
      fOptions.ResetToDefaultOptions();
   }

protected:


//private:


   // keep protected to be accessible by the derived classes


   bool fValidError;            // flag to control if errors have been validated (Hesse has been run in case of Minuit)
   MinimizerOptions fOptions;   // minimizer options
   int fStatus;                 // status of minimizer
};

   } // end namespace Math

} // end namespace ROOT


#endif /* ROOT_Math_Minimizer */
 Minimizer.h:1
 Minimizer.h:2
 Minimizer.h:3
 Minimizer.h:4
 Minimizer.h:5
 Minimizer.h:6
 Minimizer.h:7
 Minimizer.h:8
 Minimizer.h:9
 Minimizer.h:10
 Minimizer.h:11
 Minimizer.h:12
 Minimizer.h:13
 Minimizer.h:14
 Minimizer.h:15
 Minimizer.h:16
 Minimizer.h:17
 Minimizer.h:18
 Minimizer.h:19
 Minimizer.h:20
 Minimizer.h:21
 Minimizer.h:22
 Minimizer.h:23
 Minimizer.h:24
 Minimizer.h:25
 Minimizer.h:26
 Minimizer.h:27
 Minimizer.h:28
 Minimizer.h:29
 Minimizer.h:30
 Minimizer.h:31
 Minimizer.h:32
 Minimizer.h:33
 Minimizer.h:34
 Minimizer.h:35
 Minimizer.h:36
 Minimizer.h:37
 Minimizer.h:38
 Minimizer.h:39
 Minimizer.h:40
 Minimizer.h:41
 Minimizer.h:42
 Minimizer.h:43
 Minimizer.h:44
 Minimizer.h:45
 Minimizer.h:46
 Minimizer.h:47
 Minimizer.h:48
 Minimizer.h:49
 Minimizer.h:50
 Minimizer.h:51
 Minimizer.h:52
 Minimizer.h:53
 Minimizer.h:54
 Minimizer.h:55
 Minimizer.h:56
 Minimizer.h:57
 Minimizer.h:58
 Minimizer.h:59
 Minimizer.h:60
 Minimizer.h:61
 Minimizer.h:62
 Minimizer.h:63
 Minimizer.h:64
 Minimizer.h:65
 Minimizer.h:66
 Minimizer.h:67
 Minimizer.h:68
 Minimizer.h:69
 Minimizer.h:70
 Minimizer.h:71
 Minimizer.h:72
 Minimizer.h:73
 Minimizer.h:74
 Minimizer.h:75
 Minimizer.h:76
 Minimizer.h:77
 Minimizer.h:78
 Minimizer.h:79
 Minimizer.h:80
 Minimizer.h:81
 Minimizer.h:82
 Minimizer.h:83
 Minimizer.h:84
 Minimizer.h:85
 Minimizer.h:86
 Minimizer.h:87
 Minimizer.h:88
 Minimizer.h:89
 Minimizer.h:90
 Minimizer.h:91
 Minimizer.h:92
 Minimizer.h:93
 Minimizer.h:94
 Minimizer.h:95
 Minimizer.h:96
 Minimizer.h:97
 Minimizer.h:98
 Minimizer.h:99
 Minimizer.h:100
 Minimizer.h:101
 Minimizer.h:102
 Minimizer.h:103
 Minimizer.h:104
 Minimizer.h:105
 Minimizer.h:106
 Minimizer.h:107
 Minimizer.h:108
 Minimizer.h:109
 Minimizer.h:110
 Minimizer.h:111
 Minimizer.h:112
 Minimizer.h:113
 Minimizer.h:114
 Minimizer.h:115
 Minimizer.h:116
 Minimizer.h:117
 Minimizer.h:118
 Minimizer.h:119
 Minimizer.h:120
 Minimizer.h:121
 Minimizer.h:122
 Minimizer.h:123
 Minimizer.h:124
 Minimizer.h:125
 Minimizer.h:126
 Minimizer.h:127
 Minimizer.h:128
 Minimizer.h:129
 Minimizer.h:130
 Minimizer.h:131
 Minimizer.h:132
 Minimizer.h:133
 Minimizer.h:134
 Minimizer.h:135
 Minimizer.h:136
 Minimizer.h:137
 Minimizer.h:138
 Minimizer.h:139
 Minimizer.h:140
 Minimizer.h:141
 Minimizer.h:142
 Minimizer.h:143
 Minimizer.h:144
 Minimizer.h:145
 Minimizer.h:146
 Minimizer.h:147
 Minimizer.h:148
 Minimizer.h:149
 Minimizer.h:150
 Minimizer.h:151
 Minimizer.h:152
 Minimizer.h:153
 Minimizer.h:154
 Minimizer.h:155
 Minimizer.h:156
 Minimizer.h:157
 Minimizer.h:158
 Minimizer.h:159
 Minimizer.h:160
 Minimizer.h:161
 Minimizer.h:162
 Minimizer.h:163
 Minimizer.h:164
 Minimizer.h:165
 Minimizer.h:166
 Minimizer.h:167
 Minimizer.h:168
 Minimizer.h:169
 Minimizer.h:170
 Minimizer.h:171
 Minimizer.h:172
 Minimizer.h:173
 Minimizer.h:174
 Minimizer.h:175
 Minimizer.h:176
 Minimizer.h:177
 Minimizer.h:178
 Minimizer.h:179
 Minimizer.h:180
 Minimizer.h:181
 Minimizer.h:182
 Minimizer.h:183
 Minimizer.h:184
 Minimizer.h:185
 Minimizer.h:186
 Minimizer.h:187
 Minimizer.h:188
 Minimizer.h:189
 Minimizer.h:190
 Minimizer.h:191
 Minimizer.h:192
 Minimizer.h:193
 Minimizer.h:194
 Minimizer.h:195
 Minimizer.h:196
 Minimizer.h:197
 Minimizer.h:198
 Minimizer.h:199
 Minimizer.h:200
 Minimizer.h:201
 Minimizer.h:202
 Minimizer.h:203
 Minimizer.h:204
 Minimizer.h:205
 Minimizer.h:206
 Minimizer.h:207
 Minimizer.h:208
 Minimizer.h:209
 Minimizer.h:210
 Minimizer.h:211
 Minimizer.h:212
 Minimizer.h:213
 Minimizer.h:214
 Minimizer.h:215
 Minimizer.h:216
 Minimizer.h:217
 Minimizer.h:218
 Minimizer.h:219
 Minimizer.h:220
 Minimizer.h:221
 Minimizer.h:222
 Minimizer.h:223
 Minimizer.h:224
 Minimizer.h:225
 Minimizer.h:226
 Minimizer.h:227
 Minimizer.h:228
 Minimizer.h:229
 Minimizer.h:230
 Minimizer.h:231
 Minimizer.h:232
 Minimizer.h:233
 Minimizer.h:234
 Minimizer.h:235
 Minimizer.h:236
 Minimizer.h:237
 Minimizer.h:238
 Minimizer.h:239
 Minimizer.h:240
 Minimizer.h:241
 Minimizer.h:242
 Minimizer.h:243
 Minimizer.h:244
 Minimizer.h:245
 Minimizer.h:246
 Minimizer.h:247
 Minimizer.h:248
 Minimizer.h:249
 Minimizer.h:250
 Minimizer.h:251
 Minimizer.h:252
 Minimizer.h:253
 Minimizer.h:254
 Minimizer.h:255
 Minimizer.h:256
 Minimizer.h:257
 Minimizer.h:258
 Minimizer.h:259
 Minimizer.h:260
 Minimizer.h:261
 Minimizer.h:262
 Minimizer.h:263
 Minimizer.h:264
 Minimizer.h:265
 Minimizer.h:266
 Minimizer.h:267
 Minimizer.h:268
 Minimizer.h:269
 Minimizer.h:270
 Minimizer.h:271
 Minimizer.h:272
 Minimizer.h:273
 Minimizer.h:274
 Minimizer.h:275
 Minimizer.h:276
 Minimizer.h:277
 Minimizer.h:278
 Minimizer.h:279
 Minimizer.h:280
 Minimizer.h:281
 Minimizer.h:282
 Minimizer.h:283
 Minimizer.h:284
 Minimizer.h:285
 Minimizer.h:286
 Minimizer.h:287
 Minimizer.h:288
 Minimizer.h:289
 Minimizer.h:290
 Minimizer.h:291
 Minimizer.h:292
 Minimizer.h:293
 Minimizer.h:294
 Minimizer.h:295
 Minimizer.h:296
 Minimizer.h:297
 Minimizer.h:298
 Minimizer.h:299
 Minimizer.h:300
 Minimizer.h:301
 Minimizer.h:302
 Minimizer.h:303
 Minimizer.h:304
 Minimizer.h:305
 Minimizer.h:306
 Minimizer.h:307
 Minimizer.h:308
 Minimizer.h:309
 Minimizer.h:310
 Minimizer.h:311
 Minimizer.h:312
 Minimizer.h:313
 Minimizer.h:314
 Minimizer.h:315
 Minimizer.h:316
 Minimizer.h:317
 Minimizer.h:318
 Minimizer.h:319
 Minimizer.h:320
 Minimizer.h:321
 Minimizer.h:322
 Minimizer.h:323
 Minimizer.h:324
 Minimizer.h:325
 Minimizer.h:326
 Minimizer.h:327
 Minimizer.h:328
 Minimizer.h:329
 Minimizer.h:330
 Minimizer.h:331
 Minimizer.h:332
 Minimizer.h:333
 Minimizer.h:334
 Minimizer.h:335
 Minimizer.h:336
 Minimizer.h:337
 Minimizer.h:338
 Minimizer.h:339
 Minimizer.h:340
 Minimizer.h:341
 Minimizer.h:342
 Minimizer.h:343
 Minimizer.h:344
 Minimizer.h:345
 Minimizer.h:346
 Minimizer.h:347
 Minimizer.h:348
 Minimizer.h:349
 Minimizer.h:350
 Minimizer.h:351
 Minimizer.h:352
 Minimizer.h:353
 Minimizer.h:354
 Minimizer.h:355
 Minimizer.h:356
 Minimizer.h:357
 Minimizer.h:358
 Minimizer.h:359
 Minimizer.h:360
 Minimizer.h:361
 Minimizer.h:362
 Minimizer.h:363
 Minimizer.h:364
 Minimizer.h:365
 Minimizer.h:366
 Minimizer.h:367
 Minimizer.h:368
 Minimizer.h:369
 Minimizer.h:370
 Minimizer.h:371
 Minimizer.h:372
 Minimizer.h:373
 Minimizer.h:374
 Minimizer.h:375
 Minimizer.h:376
 Minimizer.h:377
 Minimizer.h:378
 Minimizer.h:379
 Minimizer.h:380
 Minimizer.h:381
 Minimizer.h:382
 Minimizer.h:383
 Minimizer.h:384
 Minimizer.h:385
 Minimizer.h:386
 Minimizer.h:387
 Minimizer.h:388
 Minimizer.h:389
 Minimizer.h:390
 Minimizer.h:391
 Minimizer.h:392
 Minimizer.h:393
 Minimizer.h:394
 Minimizer.h:395
 Minimizer.h:396
 Minimizer.h:397
 Minimizer.h:398
 Minimizer.h:399
 Minimizer.h:400
 Minimizer.h:401
 Minimizer.h:402
 Minimizer.h:403
 Minimizer.h:404
 Minimizer.h:405
 Minimizer.h:406
 Minimizer.h:407
 Minimizer.h:408
 Minimizer.h:409
 Minimizer.h:410
 Minimizer.h:411
 Minimizer.h:412
 Minimizer.h:413
 Minimizer.h:414
 Minimizer.h:415
 Minimizer.h:416
 Minimizer.h:417
 Minimizer.h:418
 Minimizer.h:419
 Minimizer.h:420
 Minimizer.h:421
 Minimizer.h:422
 Minimizer.h:423
 Minimizer.h:424
 Minimizer.h:425
 Minimizer.h:426
 Minimizer.h:427
 Minimizer.h:428
 Minimizer.h:429
 Minimizer.h:430
 Minimizer.h:431
 Minimizer.h:432
 Minimizer.h:433
 Minimizer.h:434
 Minimizer.h:435
 Minimizer.h:436
 Minimizer.h:437
 Minimizer.h:438
 Minimizer.h:439
 Minimizer.h:440
 Minimizer.h:441
 Minimizer.h:442
 Minimizer.h:443
 Minimizer.h:444
 Minimizer.h:445
 Minimizer.h:446
 Minimizer.h:447
 Minimizer.h:448
 Minimizer.h:449
 Minimizer.h:450
 Minimizer.h:451
 Minimizer.h:452
 Minimizer.h:453
 Minimizer.h:454
 Minimizer.h:455
 Minimizer.h:456
 Minimizer.h:457
 Minimizer.h:458
 Minimizer.h:459
 Minimizer.h:460
 Minimizer.h:461
 Minimizer.h:462
 Minimizer.h:463
 Minimizer.h:464
 Minimizer.h:465
 Minimizer.h:466
 Minimizer.h:467
 Minimizer.h:468
 Minimizer.h:469
 Minimizer.h:470
 Minimizer.h:471
 Minimizer.h:472
 Minimizer.h:473
 Minimizer.h:474
 Minimizer.h:475
 Minimizer.h:476
 Minimizer.h:477
 Minimizer.h:478
 Minimizer.h:479
 Minimizer.h:480
 Minimizer.h:481
 Minimizer.h:482
 Minimizer.h:483
 Minimizer.h:484
 Minimizer.h:485
 Minimizer.h:486
 Minimizer.h:487
 Minimizer.h:488
 Minimizer.h:489
 Minimizer.h:490
 Minimizer.h:491
 Minimizer.h:492
 Minimizer.h:493
 Minimizer.h:494
 Minimizer.h:495
 Minimizer.h:496
 Minimizer.h:497
 Minimizer.h:498
 Minimizer.h:499
 Minimizer.h:500
 Minimizer.h:501
 Minimizer.h:502
 Minimizer.h:503
 Minimizer.h:504
 Minimizer.h:505
 Minimizer.h:506