path: root/thirdparty/linux/include/coin1/CbcOrClpParam.hpp

/* $Id: CbcOrClpParam.hpp 2070 2014-11-18 11:12:54Z forrest $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifdef USE_CBCCONFIG
# include "CbcConfig.h"
#else
# include "ClpConfig.h"
#endif

#ifndef CbcOrClpParam_H
#define CbcOrClpParam_H
/**
   This has parameter handling stuff which can be shared between Cbc and Clp (and Dylp etc).

   This (and .cpp) should be copied so that it is the same in Cbc/Test and Clp/Test.
   I know this is not elegant but it seems simplest.

   It uses COIN_HAS_CBC for parameters wanted by CBC
   It uses COIN_HAS_CLP for parameters wanted by CLP (or CBC using CLP)
   It could use COIN_HAS_DYLP for parameters wanted by DYLP
   It could use COIN_HAS_DYLP_OR_CLP for parameters wanted by DYLP or CLP etc etc

 */
class OsiSolverInterface;
class CbcModel;
class ClpSimplex;
/*! \brief Parameter codes

  Parameter type ranges are allocated as follows
  <ul>
    <li>   1 -- 100	double parameters
    <li> 101 -- 200	integer parameters
    <li> 201 -- 250	string parameters
    <li> 251 -- 300	cuts etc(string but broken out for clarity)
    <li> 301 -- 400	`actions'
  </ul>

  `Actions' do not necessarily invoke an immediate action; it's just that they
  don't fit neatly into the parameters array.

  This coding scheme is in flux.
*/

enum CbcOrClpParameterType

{
     CBC_PARAM_GENERALQUERY = -100,
     CBC_PARAM_FULLGENERALQUERY,

     CLP_PARAM_DBL_PRIMALTOLERANCE = 1,
     CLP_PARAM_DBL_DUALTOLERANCE,
     CLP_PARAM_DBL_TIMELIMIT,
     CLP_PARAM_DBL_DUALBOUND,
     CLP_PARAM_DBL_PRIMALWEIGHT,
     CLP_PARAM_DBL_OBJSCALE,
     CLP_PARAM_DBL_RHSSCALE,
     CLP_PARAM_DBL_ZEROTOLERANCE,

     CBC_PARAM_DBL_INFEASIBILITYWEIGHT = 51,
     CBC_PARAM_DBL_CUTOFF,
     CBC_PARAM_DBL_INTEGERTOLERANCE,
     CBC_PARAM_DBL_INCREMENT,
     CBC_PARAM_DBL_ALLOWABLEGAP,
     CBC_PARAM_DBL_TIMELIMIT_BAB,
     CBC_PARAM_DBL_GAPRATIO,

     CBC_PARAM_DBL_DJFIX = 81,
     CBC_PARAM_DBL_TIGHTENFACTOR,
     CLP_PARAM_DBL_PRESOLVETOLERANCE,
     CLP_PARAM_DBL_OBJSCALE2,
     CBC_PARAM_DBL_FAKEINCREMENT,
     CBC_PARAM_DBL_FAKECUTOFF,
     CBC_PARAM_DBL_ARTIFICIALCOST,
     CBC_PARAM_DBL_DEXTRA3,
     CBC_PARAM_DBL_SMALLBAB,
     CBC_PARAM_DBL_DEXTRA4,
     CBC_PARAM_DBL_DEXTRA5,

     CLP_PARAM_INT_SOLVERLOGLEVEL = 101,
#ifndef COIN_HAS_CBC
     CLP_PARAM_INT_LOGLEVEL = 101,
#endif
     CLP_PARAM_INT_MAXFACTOR,
     CLP_PARAM_INT_PERTVALUE,
     CLP_PARAM_INT_MAXITERATION,
     CLP_PARAM_INT_PRESOLVEPASS,
     CLP_PARAM_INT_IDIOT,
     CLP_PARAM_INT_SPRINT,
     CLP_PARAM_INT_OUTPUTFORMAT,
     CLP_PARAM_INT_SLPVALUE,
     CLP_PARAM_INT_PRESOLVEOPTIONS,
     CLP_PARAM_INT_PRINTOPTIONS,
     CLP_PARAM_INT_SPECIALOPTIONS,
     CLP_PARAM_INT_SUBSTITUTION,
     CLP_PARAM_INT_DUALIZE,
     CLP_PARAM_INT_VERBOSE,
     CLP_PARAM_INT_CPP,
     CLP_PARAM_INT_PROCESSTUNE,
     CLP_PARAM_INT_USESOLUTION,
     CLP_PARAM_INT_RANDOMSEED,
     CLP_PARAM_INT_MORESPECIALOPTIONS,
     CLP_PARAM_INT_DECOMPOSE_BLOCKS,

     CBC_PARAM_INT_STRONGBRANCHING = 151,
     CBC_PARAM_INT_CUTDEPTH,
     CBC_PARAM_INT_MAXNODES,
     CBC_PARAM_INT_NUMBERBEFORE,
     CBC_PARAM_INT_NUMBERANALYZE,
     CBC_PARAM_INT_MIPOPTIONS,
     CBC_PARAM_INT_MOREMIPOPTIONS,
     CBC_PARAM_INT_MAXHOTITS,
     CBC_PARAM_INT_FPUMPITS,
     CBC_PARAM_INT_MAXSOLS,
     CBC_PARAM_INT_FPUMPTUNE,
     CBC_PARAM_INT_TESTOSI,
     CBC_PARAM_INT_EXTRA1,
     CBC_PARAM_INT_EXTRA2,
     CBC_PARAM_INT_EXTRA3,
     CBC_PARAM_INT_EXTRA4,
     CBC_PARAM_INT_DEPTHMINIBAB,
     CBC_PARAM_INT_CUTPASSINTREE,
     CBC_PARAM_INT_THREADS,
     CBC_PARAM_INT_CUTPASS,
     CBC_PARAM_INT_VUBTRY,
     CBC_PARAM_INT_DENSE,
     CBC_PARAM_INT_EXPERIMENT,
     CBC_PARAM_INT_DIVEOPT,
     CBC_PARAM_INT_DIVEOPTSOLVES,
     CBC_PARAM_INT_STRATEGY,
     CBC_PARAM_INT_SMALLFACT,
     CBC_PARAM_INT_HOPTIONS,
     CBC_PARAM_INT_CUTLENGTH,
     CBC_PARAM_INT_FPUMPTUNE2,
#ifdef COIN_HAS_CBC
     CLP_PARAM_INT_LOGLEVEL ,
#endif
     CBC_PARAM_INT_MAXSAVEDSOLS,
     CBC_PARAM_INT_RANDOMSEED,
     CBC_PARAM_INT_MULTIPLEROOTS,
     CBC_PARAM_INT_STRONG_STRATEGY,
     CBC_PARAM_INT_EXTRA_VARIABLES,
     CBC_PARAM_INT_MAX_SLOW_CUTS,
     CBC_PARAM_INT_MOREMOREMIPOPTIONS,

     CLP_PARAM_STR_DIRECTION = 201,
     CLP_PARAM_STR_DUALPIVOT,
     CLP_PARAM_STR_SCALING,
     CLP_PARAM_STR_ERRORSALLOWED,
     CLP_PARAM_STR_KEEPNAMES,
     CLP_PARAM_STR_SPARSEFACTOR,
     CLP_PARAM_STR_PRIMALPIVOT,
     CLP_PARAM_STR_PRESOLVE,
     CLP_PARAM_STR_CRASH,
     CLP_PARAM_STR_BIASLU,
     CLP_PARAM_STR_PERTURBATION,
     CLP_PARAM_STR_MESSAGES,
     CLP_PARAM_STR_AUTOSCALE,
     CLP_PARAM_STR_CHOLESKY,
     CLP_PARAM_STR_KKT,
     CLP_PARAM_STR_BARRIERSCALE,
     CLP_PARAM_STR_GAMMA,
     CLP_PARAM_STR_CROSSOVER,
     CLP_PARAM_STR_PFI,
     CLP_PARAM_STR_INTPRINT,
     CLP_PARAM_STR_VECTOR,
     CLP_PARAM_STR_FACTORIZATION,
     CLP_PARAM_STR_ALLCOMMANDS,
     CLP_PARAM_STR_TIME_MODE,
     CLP_PARAM_STR_ABCWANTED,

     CBC_PARAM_STR_NODESTRATEGY = 251,
     CBC_PARAM_STR_BRANCHSTRATEGY,
     CBC_PARAM_STR_CUTSSTRATEGY,
     CBC_PARAM_STR_HEURISTICSTRATEGY,
     CBC_PARAM_STR_GOMORYCUTS,
     CBC_PARAM_STR_PROBINGCUTS,
     CBC_PARAM_STR_KNAPSACKCUTS,
     CBC_PARAM_STR_REDSPLITCUTS,
     CBC_PARAM_STR_ROUNDING,
     CBC_PARAM_STR_SOLVER,
     CBC_PARAM_STR_CLIQUECUTS,
     CBC_PARAM_STR_COSTSTRATEGY,
     CBC_PARAM_STR_FLOWCUTS,
     CBC_PARAM_STR_MIXEDCUTS,
     CBC_PARAM_STR_TWOMIRCUTS,
     CBC_PARAM_STR_PREPROCESS,
     CBC_PARAM_STR_FPUMP,
     CBC_PARAM_STR_GREEDY,
     CBC_PARAM_STR_COMBINE,
     CBC_PARAM_STR_PROXIMITY,
     CBC_PARAM_STR_LOCALTREE,
     CBC_PARAM_STR_SOS,
     CBC_PARAM_STR_LANDPCUTS,
     CBC_PARAM_STR_RINS,
     CBC_PARAM_STR_RESIDCUTS,
     CBC_PARAM_STR_RENS,
     CBC_PARAM_STR_DIVINGS,
     CBC_PARAM_STR_DIVINGC,
     CBC_PARAM_STR_DIVINGF,
     CBC_PARAM_STR_DIVINGG,
     CBC_PARAM_STR_DIVINGL,
     CBC_PARAM_STR_DIVINGP,
     CBC_PARAM_STR_DIVINGV,
     CBC_PARAM_STR_DINS,
     CBC_PARAM_STR_PIVOTANDFIX,
     CBC_PARAM_STR_RANDROUND,
     CBC_PARAM_STR_NAIVE,
     CBC_PARAM_STR_ZEROHALFCUTS,
     CBC_PARAM_STR_CPX,
     CBC_PARAM_STR_CROSSOVER2,
     CBC_PARAM_STR_PIVOTANDCOMPLEMENT,
     CBC_PARAM_STR_VND,
     CBC_PARAM_STR_LAGOMORYCUTS,
     CBC_PARAM_STR_LATWOMIRCUTS,
     CBC_PARAM_STR_REDSPLIT2CUTS,
     CBC_PARAM_STR_GMICUTS,
     CBC_PARAM_STR_CUTOFF_CONSTRAINT,
     CBC_PARAM_STR_DW,
     CBC_PARAM_STR_ORBITAL,

     CLP_PARAM_ACTION_DIRECTORY = 301,
     CLP_PARAM_ACTION_DIRSAMPLE,
     CLP_PARAM_ACTION_DIRNETLIB,
     CBC_PARAM_ACTION_DIRMIPLIB,
     CLP_PARAM_ACTION_IMPORT,
     CLP_PARAM_ACTION_EXPORT,
     CLP_PARAM_ACTION_RESTORE,
     CLP_PARAM_ACTION_SAVE,
     CLP_PARAM_ACTION_DUALSIMPLEX,
     CLP_PARAM_ACTION_PRIMALSIMPLEX,
     CLP_PARAM_ACTION_EITHERSIMPLEX,
     CLP_PARAM_ACTION_MAXIMIZE,
     CLP_PARAM_ACTION_MINIMIZE,
     CLP_PARAM_ACTION_EXIT,
     CLP_PARAM_ACTION_STDIN,
     CLP_PARAM_ACTION_UNITTEST,
     CLP_PARAM_ACTION_NETLIB_EITHER,
     CLP_PARAM_ACTION_NETLIB_DUAL,
     CLP_PARAM_ACTION_NETLIB_PRIMAL,
     CLP_PARAM_ACTION_SOLUTION,
     CLP_PARAM_ACTION_SAVESOL,
     CLP_PARAM_ACTION_TIGHTEN,
     CLP_PARAM_ACTION_FAKEBOUND,
     CLP_PARAM_ACTION_HELP,
     CLP_PARAM_ACTION_PLUSMINUS,
     CLP_PARAM_ACTION_NETWORK,
     CLP_PARAM_ACTION_ALLSLACK,
     CLP_PARAM_ACTION_REVERSE,
     CLP_PARAM_ACTION_BARRIER,
     CLP_PARAM_ACTION_NETLIB_BARRIER,
     CLP_PARAM_ACTION_NETLIB_TUNE,
     CLP_PARAM_ACTION_REALLY_SCALE,
     CLP_PARAM_ACTION_BASISIN,
     CLP_PARAM_ACTION_BASISOUT,
     CLP_PARAM_ACTION_SOLVECONTINUOUS,
     CLP_PARAM_ACTION_CLEARCUTS,
     CLP_PARAM_ACTION_VERSION,
     CLP_PARAM_ACTION_STATISTICS,
     CLP_PARAM_ACTION_DEBUG,
     CLP_PARAM_ACTION_DUMMY,
     CLP_PARAM_ACTION_PRINTMASK,
     CLP_PARAM_ACTION_OUTDUPROWS,
     CLP_PARAM_ACTION_USERCLP,
     CLP_PARAM_ACTION_MODELIN,
     CLP_PARAM_ACTION_CSVSTATISTICS,
     CLP_PARAM_ACTION_STOREDFILE,
     CLP_PARAM_ACTION_ENVIRONMENT,
     CLP_PARAM_ACTION_PARAMETRICS,
     CLP_PARAM_ACTION_GMPL_SOLUTION,
     CLP_PARAM_ACTION_RESTORESOL,

     CBC_PARAM_ACTION_BAB = 361,
     CBC_PARAM_ACTION_MIPLIB,
     CBC_PARAM_ACTION_STRENGTHEN,
     CBC_PARAM_ACTION_PRIORITYIN,
     CBC_PARAM_ACTION_MIPSTART,
     CBC_PARAM_ACTION_USERCBC,
     CBC_PARAM_ACTION_DOHEURISTIC,
     CLP_PARAM_ACTION_NEXTBESTSOLUTION,

     CBC_PARAM_NOTUSED_OSLSTUFF = 401,
     CBC_PARAM_NOTUSED_CBCSTUFF,

     CBC_PARAM_NOTUSED_INVALID = 1000
} ;
#include <vector>
#include <string>

/// Very simple class for setting parameters

class CbcOrClpParam {
public:
     /**@name Constructor and destructor */
     //@{
     /// Constructors
     CbcOrClpParam (  );
     CbcOrClpParam (std::string name, std::string help,
                    double lower, double upper, CbcOrClpParameterType type, int display = 2);
     CbcOrClpParam (std::string name, std::string help,
                    int lower, int upper, CbcOrClpParameterType type, int display = 2);
     // Other strings will be added by insert
     CbcOrClpParam (std::string name, std::string help, std::string firstValue,
                    CbcOrClpParameterType type, int whereUsed = 7, int display = 2);
     // Action
     CbcOrClpParam (std::string name, std::string help,
                    CbcOrClpParameterType type, int whereUsed = 7, int display = 2);
     /// Copy constructor.
     CbcOrClpParam(const CbcOrClpParam &);
     /// Assignment operator. This copies the data
     CbcOrClpParam & operator=(const CbcOrClpParam & rhs);
     /// Destructor
     ~CbcOrClpParam (  );
     //@}

     /**@name stuff */
     //@{
     /// Insert string (only valid for keywords)
     void append(std::string keyWord);
     /// Adds one help line
     void addHelp(std::string keyWord);
     /// Returns name
     inline std::string  name(  ) const {
          return name_;
     }
     /// Returns short help
     inline std::string  shortHelp(  ) const {
          return shortHelp_;
     }
     /// Sets a double parameter (nonzero code if error)
     int setDoubleParameter(CbcModel & model, double value) ;
     /// Sets double parameter and returns printable string and error code
     const char * setDoubleParameterWithMessage ( CbcModel & model, double  value , int & returnCode);
     /// Gets a double parameter
     double doubleParameter(CbcModel & model) const;
     /// Sets a int parameter (nonzero code if error)
     int setIntParameter(CbcModel & model, int value) ;
     /// Sets int parameter and returns printable string and error code
     const char * setIntParameterWithMessage ( CbcModel & model, int value , int & returnCode);
     /// Gets a int parameter
     int intParameter(CbcModel & model) const;
     /// Sets a double parameter (nonzero code if error)
     int setDoubleParameter(ClpSimplex * model, double value) ;
     /// Gets a double parameter
     double doubleParameter(ClpSimplex * model) const;
     /// Sets double parameter and returns printable string and error code
     const char * setDoubleParameterWithMessage ( ClpSimplex * model, double  value , int & returnCode);
     /// Sets a int parameter (nonzero code if error)
     int setIntParameter(ClpSimplex * model, int value) ;
     /// Sets int parameter and returns printable string and error code
     const char * setIntParameterWithMessage ( ClpSimplex * model, int  value , int & returnCode);
     /// Gets a int parameter
     int intParameter(ClpSimplex * model) const;
     /// Sets a double parameter (nonzero code if error)
     int setDoubleParameter(OsiSolverInterface * model, double value) ;
     /// Sets double parameter and returns printable string and error code
     const char * setDoubleParameterWithMessage ( OsiSolverInterface * model, double  value , int & returnCode);
     /// Gets a double parameter
     double doubleParameter(OsiSolverInterface * model) const;
     /// Sets a int parameter (nonzero code if error)
     int setIntParameter(OsiSolverInterface * model, int value) ;
     /// Sets int parameter and returns printable string and error code
     const char * setIntParameterWithMessage ( OsiSolverInterface * model, int  value , int & returnCode);
     /// Gets a int parameter
     int intParameter(OsiSolverInterface * model) const;
     /// Checks a double parameter (nonzero code if error)
     int checkDoubleParameter(double value) const;
     /// Returns name which could match
     std::string matchName (  ) const;
     /// Returns length of name for ptinting
     int lengthMatchName (  ) const;
     /// Returns parameter option which matches (-1 if none)
     int parameterOption ( std::string check ) const;
     /// Prints parameter options
     void printOptions (  ) const;
     /// Returns current parameter option
     inline std::string currentOption (  ) const {
          return definedKeyWords_[currentKeyWord_];
     }
     /// Sets current parameter option
     void setCurrentOption ( int value , bool printIt = false);
     /// Sets current parameter option and returns printable string
     const char * setCurrentOptionWithMessage ( int value );
     /// Sets current parameter option using string
     void setCurrentOption (const std::string value );
     /// Sets current parameter option using string with message
     const char * setCurrentOptionWithMessage (const std::string value );
     /// Returns current parameter option position
     int currentOptionAsInteger (  ) const ;
     /** Returns current parameter option position
	 but if fake keyword returns a fake value and sets
	 fakeInteger to true value.  If not fake then fakeInteger is -COIN_INT_MAX
      */
     int currentOptionAsInteger ( int & fakeInteger ) const;
     /// Sets int value
     void setIntValue ( int value );
     /// Sets int value with message
     const char * setIntValueWithMessage ( int value );
     inline int intValue () const {
          return intValue_;
     }
     /// Sets double value
     void setDoubleValue ( double value );
     /// Sets double value with message
     const char * setDoubleValueWithMessage ( double value );
     inline double doubleValue () const {
          return doubleValue_;
     }
     /// Sets string value
     void setStringValue ( std::string value );
     inline std::string stringValue () const {
          return stringValue_;
     }
     /// Returns 1 if matches minimum, 2 if matches less, 0 if not matched
     int matches (std::string input) const;
     /// type
     inline CbcOrClpParameterType type() const {
          return type_;
     }
     /// whether to display
     inline int displayThis() const {
          return display_;
     }
     /// Set Long help
     inline void setLonghelp(const std::string help) {
          longHelp_ = help;
     }
     /// Print Long help
     void printLongHelp() const;
     /// Print action and string
     void printString() const;
     /** 7 if used everywhere,
         1 - used by clp
         2 - used by cbc
         4 - used by ampl
     */
     inline int whereUsed() const {
          return whereUsed_;
     }
     /// Gets value of fake keyword
     inline int fakeKeyWord() const
     { return fakeKeyWord_;}
     /// Sets value of fake keyword 
     inline void setFakeKeyWord(int value, int fakeValue)
     { fakeKeyWord_ = value; fakeValue_ = fakeValue;}
     /// Sets value of fake keyword to current size of keywords 
     void setFakeKeyWord(int fakeValue);

private:
     /// gutsOfConstructor
     void gutsOfConstructor();
     //@}
////////////////// data //////////////////
private:

     /**@name data
      We might as well throw all type data in - could derive?
     */
     //@{
     // Type see CbcOrClpParameterType
     CbcOrClpParameterType type_;
     /// If double == okay
     double lowerDoubleValue_;
     double upperDoubleValue_;
     /// If int == okay
     int lowerIntValue_;
     int upperIntValue_;
     // Length of name
     unsigned int lengthName_;
     // Minimum match
     unsigned int lengthMatch_;
     /// set of valid strings
     std::vector<std::string> definedKeyWords_;
     /// Name
     std::string name_;
     /// Short help
     std::string shortHelp_;
     /// Long help
     std::string longHelp_;
     /// Action
     CbcOrClpParameterType action_;
     /// Current keyWord (if a keyword parameter)
     int currentKeyWord_;
     /// Display on ?
     int display_;
     /// Integer parameter - current value
     int intValue_;
     /// Double parameter - current value
     double doubleValue_;
     /// String parameter - current value
     std::string stringValue_;
     /** 7 if used everywhere,
         1 - used by clp
         2 - used by cbc
         4 - used by ampl
     */
     int whereUsed_;
     /** If >=0 then integers allowed as a fake keyword
	 So minusnnnn would got to -nnnn in currentKeyword_
	 and plusnnnn would go to fakeKeyword_+nnnn
     */
     int fakeKeyWord_;
     /// Return this as main value if an integer
     int fakeValue_;
     //@}
};
/// Simple read stuff
std::string CoinReadNextField();

std::string CoinReadGetCommand(int argc, const char *argv[]);
std::string CoinReadGetString(int argc, const char *argv[]);
// valid 0 - okay, 1 bad, 2 not there
int CoinReadGetIntField(int argc, const char *argv[], int * valid);
double CoinReadGetDoubleField(int argc, const char *argv[], int * valid);
void CoinReadPrintit(const char * input);
void setCbcOrClpPrinting(bool yesNo);
#define CBCMAXPARAMETERS 250
/*
  Subroutine to establish the cbc parameter array. See the description of
  class CbcOrClpParam for details. Pulled from C..Main() for clarity.
*/
void establishParams (int &numberParameters, CbcOrClpParam *const parameters);
// Given a parameter type - returns its number in list
int whichParam (CbcOrClpParameterType name,
                int numberParameters, CbcOrClpParam *const parameters);
// Dump/restore a solution to file
void saveSolution(const ClpSimplex * lpSolver, std::string fileName);
void restoreSolution(ClpSimplex * lpSolver, std::string fileName, int mode);
#endif	/* CbcOrClpParam_H */