ruby-cbc 0.1.9

data/ext/ruby-cbc/install/include/coin/Coin_C_defines.h

@@ -0,0 +1,115 @@
+/* $Id: Coin_C_defines.h 1690 2014-03-13 17:45:21Z mlubin $ */
+/*
+  Copyright (C) 2002, 2003 International Business Machines Corporation
+  and others.  All Rights Reserved.
+
+  This code is licensed under the terms of the Eclipse Public License (EPL).
+*/
+#ifndef CoinCDefine_H
+#define CoinCDefine_H
+
+/** This has #defines etc for the "C" interface to Coin.
+    If COIN_EXTERN_C defined then an extra extern C
+*/
+
+#if defined (CLP_EXTERN_C)
+#define COIN_EXTERN_C
+#define COIN_NO_SBB
+#define COIN_NO_CBC
+#endif
+#if defined (SBB_EXTERN_C)
+#define COIN_EXTERN_C
+#define COIN_NO_CLP
+#endif
+#if defined (CBC_EXTERN_C)
+#define COIN_EXTERN_C
+#define COIN_NO_CLP
+#endif
+/* We need to allow for Microsoft */
+#ifndef COINLIBAPI
+
+#if defined(CBCCINTERFACEDLL_EXPORTS) || defined(CLPMSDLL)
+#if defined (COIN_EXTERN_C)
+#   define COINLIBAPI __declspec(dllexport)
+#else
+#   define COINLIBAPI __declspec(dllexport)
+#endif
+#   define COINLINKAGE  __stdcall
+#   define COINLINKAGE_CB  __cdecl
+#else
+#if defined (COIN_EXTERN_C)
+#   define COINLIBAPI extern "C"
+#else
+#   define COINLIBAPI 
+#endif
+#   define COINLINKAGE
+#   define COINLINKAGE_CB 
+#endif
+
+#endif
+/** User does not need to see structure of model but C++ code does */
+#if defined (CLP_EXTERN_C)
+/* Real typedef for structure */
+class CMessageHandler;
+typedef struct {
+  ClpSimplex * model_;
+  CMessageHandler * handler_;
+} Clp_Simplex;
+#else
+typedef void Clp_Simplex;
+#endif
+
+#ifndef COIN_NO_CLP
+/** typedef for user call back.
+ The cvec are constructed so don't need to be const*/
+typedef  void (COINLINKAGE_CB *clp_callback) (Clp_Simplex * model,int  msgno, int ndouble,
+                            const double * dvec, int nint, const int * ivec,
+                            int nchar, char ** cvec);
+#endif
+/** User does not need to see structure of model but C++ code does */
+#if defined (SBB_EXTERN_C)
+/* Real typedef for structure */
+class Sbb_MessageHandler;
+typedef struct {
+  OsiClpSolverInterface * solver_;
+  SbbModel              * model_;
+  Sbb_MessageHandler    * handler_;
+  char                  * information_;
+} Sbb_Model;
+#else
+typedef void Sbb_Model;
+#endif
+#if defined (CBC_EXTERN_C)
+/* Real typedef for structure */
+class Cbc_MessageHandler;
+typedef struct {
+  OsiClpSolverInterface * solver_;
+  CbcModel              * model_;
+  Cbc_MessageHandler    * handler_;
+  std::vector<std::string> cmdargs_;
+} Cbc_Model;
+#else
+typedef void Cbc_Model;
+#endif
+#ifndef COIN_NO_SBB
+/** typedef for user call back.
+ The cvec are constructed so don't need to be const*/
+typedef  void (COINLINKAGE_CB *sbb_callback) (Sbb_Model * model,int  msgno, int ndouble,
+                            const double * dvec, int nint, const int * ivec,
+                            int nchar, char ** cvec);
+typedef  void (COINLINKAGE_CB *cbc_callback) (Cbc_Model * model,int  msgno, int ndouble,
+                            const double * dvec, int nint, const int * ivec,
+                            int nchar, char ** cvec);
+#endif
+#if COIN_BIG_INDEX==0
+typedef int CoinBigIndex;
+#elif COIN_BIG_INDEX==1
+typedef long CoinBigIndex;
+#else
+typedef long long CoinBigIndex;
+#endif
+/* just in case used somewhere */
+#undef COIN_NO_CLP
+#undef COIN_NO_SBB
+#undef COIN_NO_CBC
+#endif

data/ext/ruby-cbc/install/include/coin/Idiot.hpp

@@ -0,0 +1,298 @@
+/* $Id: Idiot.hpp 2143 2015-05-20 15:49:17Z 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).
+
+// "Idiot" as the name of this algorithm is copylefted.  If you want to change
+// the name then it should be something equally stupid (but not "Stupid") or
+// even better something witty.
+
+#ifndef Idiot_H
+#define Idiot_H
+#ifndef OSI_IDIOT
+#include "ClpSimplex.hpp"
+#define OsiSolverInterface ClpSimplex
+#else
+#include "OsiSolverInterface.hpp"
+typedef int CoinBigIndex;
+#endif
+class CoinMessageHandler;
+class CoinMessages;
+/// for use internally
+typedef struct {
+     double infeas;
+     double objval;
+     double dropThis;
+     double weighted;
+     double sumSquared;
+     double djAtBeginning;
+     double djAtEnd;
+     int iteration;
+} IdiotResult;
+/** This class implements a very silly algorithm.  It has no merit
+    apart from the fact that it gets an approximate solution to
+    some classes of problems.  Better if vaguely homogeneous.
+    It works on problems where volume algorithm works and often
+    gets a better primal solution but it has no dual solution.
+
+    It can also be used as a "crash" to get a problem started.  This
+    is probably its most useful function.
+
+    It is based on the idea that algorithms with terrible convergence
+    properties may be okay at first.  Throw in some random dubious tricks
+    and the resulting code may be worth keeping as long as you don't
+    look at it.
+
+*/
+
+class Idiot {
+
+public:
+
+     /**@name Constructors and destructor
+        Just a pointer to model is kept
+      */
+     //@{
+     /// Default constructor
+     Idiot (  );
+     /// Constructor with model
+     Idiot ( OsiSolverInterface & model );
+
+     /// Copy constructor.
+     Idiot(const Idiot &);
+     /// Assignment operator. This copies the data
+     Idiot & operator=(const Idiot & rhs);
+     /// Destructor
+     ~Idiot (  );
+     //@}
+
+
+     /**@name Algorithmic calls
+      */
+     //@{
+     /// Get an approximate solution with the idiot code
+     void solve();
+     /// Lightweight "crash"
+     void crash(int numberPass, CoinMessageHandler * handler,
+                const CoinMessages * messages, bool doCrossover = true);
+     /** Use simplex to get an optimal solution
+         mode is how many steps the simplex crossover should take to
+         arrive to an extreme point:
+         0 - chosen,all ever used, all
+         1 - chosen, all
+         2 - all
+         3 - do not do anything  - maybe basis
+         + 16 do presolves
+     */
+     void crossOver(int mode);
+     //@}
+
+
+     /**@name Gets and sets of most useful data
+      */
+     //@{
+     /** Starting weight - small emphasizes feasibility,
+         default 1.0e-4 */
+     inline double getStartingWeight() const {
+          return mu_;
+     }
+     inline void setStartingWeight(double value) {
+          mu_ = value;
+     }
+     /** Weight factor - weight multiplied by this when changes,
+         default 0.333 */
+     inline double getWeightFactor() const {
+          return muFactor_;
+     }
+     inline void setWeightFactor(double value) {
+          muFactor_ = value;
+     }
+     /** Feasibility tolerance - problem essentially feasible if
+         individual infeasibilities less than this.
+         default 0.1 */
+     inline double getFeasibilityTolerance() const {
+          return smallInfeas_;
+     }
+     inline void setFeasibilityTolerance(double value) {
+          smallInfeas_ = value;
+     }
+     /** Reasonably feasible.  Dubious method concentrates more on
+         objective when sum of infeasibilities less than this.
+         Very dubious default value of (Number of rows)/20 */
+     inline double getReasonablyFeasible() const {
+          return reasonableInfeas_;
+     }
+     inline void setReasonablyFeasible(double value) {
+          reasonableInfeas_ = value;
+     }
+     /** Exit infeasibility - exit if sum of infeasibilities less than this.
+         Default -1.0 (i.e. switched off) */
+     inline double getExitInfeasibility() const {
+          return exitFeasibility_;
+     }
+     inline void setExitInfeasibility(double value) {
+          exitFeasibility_ = value;
+     }
+     /** Major iterations.  stop after this number.
+         Default 30.  Use 2-5 for "crash" 50-100 for serious crunching */
+     inline int getMajorIterations() const {
+          return majorIterations_;
+     }
+     inline void setMajorIterations(int value) {
+          majorIterations_ = value;
+     }
+     /** Minor iterations.  Do this number of tiny steps before
+         deciding whether to change weights etc.
+         Default - dubious sqrt(Number of Rows).
+         Good numbers 105 to 405 say (5 is dubious method of making sure
+         idiot is not trying to be clever which it may do every 10 minor
+         iterations) */
+     inline int getMinorIterations() const {
+          return maxIts2_;
+     }
+     inline void setMinorIterations(int value) {
+          maxIts2_ = value;
+     }
+     // minor iterations for first time
+     inline int getMinorIterations0() const {
+          return maxIts_;
+     }
+     inline void setMinorIterations0(int value) {
+          maxIts_ = value;
+     }
+     /** Reduce weight after this many major iterations.  It may
+         get reduced before this but this is a maximum.
+         Default 3.  3-10 plausible. */
+     inline int getReduceIterations() const {
+          return maxBigIts_;
+     }
+     inline void setReduceIterations(int value) {
+          maxBigIts_ = value;
+     }
+     /// Amount of information - default of 1 should be okay
+     inline int getLogLevel() const {
+          return logLevel_;
+     }
+     inline void setLogLevel(int value) {
+          logLevel_ = value;
+     }
+     /// How lightweight - 0 not, 1 yes, 2 very lightweight
+     inline int getLightweight() const {
+          return lightWeight_;
+     }
+     inline void setLightweight(int value) {
+          lightWeight_ = value;
+     }
+     /// strategy
+     inline int getStrategy() const {
+          return strategy_;
+     }
+     inline void setStrategy(int value) {
+          strategy_ = value;
+     }
+     /// Fine tuning - okay if feasibility drop this factor
+     inline double getDropEnoughFeasibility() const {
+          return dropEnoughFeasibility_;
+     }
+     inline void setDropEnoughFeasibility(double value) {
+          dropEnoughFeasibility_ = value;
+     }
+     /// Fine tuning - okay if weighted obj drop this factor
+     inline double getDropEnoughWeighted() const {
+          return dropEnoughWeighted_;
+     }
+     inline void setDropEnoughWeighted(double value) {
+          dropEnoughWeighted_ = value;
+     }
+     /// Set model
+     inline void setModel(OsiSolverInterface * model) {
+       model_ = model;
+     };
+     //@}
+
+
+/// Stuff for internal use
+private:
+
+     /// Does actual work
+     // allow public!
+public:
+     void solve2(CoinMessageHandler * handler, const CoinMessages *messages);
+private:
+     IdiotResult IdiSolve(
+          int nrows, int ncols, double * rowsol , double * colsol,
+          double * pi, double * djs, const double * origcost ,
+          double * rowlower,
+          double * rowupper, const double * lower,
+          const double * upper, const double * element,
+          const int * row, const CoinBigIndex * colcc,
+          const int * length, double * lambda,
+          int maxIts, double mu, double drop,
+          double maxmin, double offset,
+          int strategy, double djTol, double djExit, double djFlag,
+          CoinThreadRandom * randomNumberGenerator);
+     int dropping(IdiotResult result,
+                  double tolerance,
+                  double small,
+                  int *nbad);
+     IdiotResult objval(int nrows, int ncols, double * rowsol , double * colsol,
+                        double * pi, double * djs, const double * cost ,
+                        const double * rowlower,
+                        const double * rowupper, const double * lower,
+                        const double * upper, const double * elemnt,
+                        const int * row, const CoinBigIndex * columnStart,
+                        const int * length, int extraBlock, int * rowExtra,
+                        double * solExtra, double * elemExtra, double * upperExtra,
+                        double * costExtra, double weight);
+     // Deals with whenUsed and slacks
+     int cleanIteration(int iteration, int ordinaryStart, int ordinaryEnd,
+                        double * colsol, const double * lower, const double * upper,
+                        const double * rowLower, const double * rowUpper,
+                        const double * cost, const double * element, double fixTolerance, double & objChange,
+                        double & infChange, double & maxInfeasibility);
+private:
+     /// Underlying model
+     OsiSolverInterface * model_;
+
+     double djTolerance_;
+     double mu_;  /* starting mu */
+     double drop_; /* exit if drop over 5 checks less than this */
+     double muFactor_; /* reduce mu by this */
+     double stopMu_; /* exit if mu gets smaller than this */
+     double smallInfeas_; /* feasibility tolerance */
+     double reasonableInfeas_; /* use lambdas if feasibility less than this */
+     double exitDrop_; /* candidate for stopping after a major iteration */
+     double muAtExit_; /* mu on exit */
+     double exitFeasibility_; /* exit if infeasibility less than this */
+     double dropEnoughFeasibility_; /* okay if feasibility drop this factor */
+     double dropEnoughWeighted_; /* okay if weighted obj drop this factor */
+     int * whenUsed_; /* array to say what was used */
+     int maxBigIts_; /* always reduce mu after this */
+     int maxIts_; /* do this many iterations on first go */
+     int majorIterations_;
+     int logLevel_;
+     int logFreq_;
+     int checkFrequency_; /* can exit after 5 * this iterations (on drop) */
+     int lambdaIterations_; /* do at least this many lambda iterations */
+     int maxIts2_; /* do this many iterations on subsequent goes */
+     int strategy_;   /* 0 - default strategy
+		     1 - do accelerator step but be cautious
+		     2 - do not do accelerator step
+		     4 - drop, exitDrop and djTolerance all relative
+		     8 - keep accelerator step to theta=10.0
+
+                    32 - Scale
+		   512 - crossover
+                  2048 - keep lambda across mu change
+		  4096 - return best solution (not last found)
+		  8192 - always do a presolve in crossover
+		 16384 - costed slacks found - so whenUsed_ longer 
+		 32768 - experimental 1
+		 65536 - experimental 2
+		 131072 - experimental 3 
+		 262144 - just values pass etc 
+		 524288 - don't treat structural slacks as slacks */
+                 
+     int lightWeight_; // 0 - normal, 1 lightweight
+};
+#endif

data/ext/ruby-cbc/install/include/coin/OsiAuxInfo.hpp

@@ -0,0 +1,206 @@
+// Copyright (C) 2006, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef OsiAuxInfo_H
+#define OsiAuxInfo_H
+
+class OsiSolverInterface;
+
+//#############################################################################
+/** This class allows for a more structured use of algorithmic tweaking to
+    an OsiSolverInterface.  It is designed to replace the simple use of
+    appData_ pointer.
+
+    This has been done to make it easier to use NonLinear solvers and other
+    exotic beasts in a branch and bound mode.  After this class definition
+    there is one for a derived class for just such a purpose.
+
+*/
+
+class OsiAuxInfo {
+public:
+  // Default Constructor 
+  OsiAuxInfo (void * appData = NULL);
+
+  // Copy Constructor 
+  OsiAuxInfo (const OsiAuxInfo & rhs);
+  // Destructor
+  virtual ~OsiAuxInfo();
+  
+  /// Clone
+  virtual OsiAuxInfo * clone() const;
+  /// Assignment operator 
+  OsiAuxInfo & operator=(const OsiAuxInfo& rhs);
+  
+  /// Get application data
+  inline void * getApplicationData() const
+  { return appData_;}
+protected:
+    /// Pointer to user-defined data structure
+    void * appData_;
+};
+//#############################################################################
+/** This class allows for the use of more exotic solvers e.g. Non-Linear or Volume.
+
+    You can derive from this although at present I can't see the need.
+*/
+
+class OsiBabSolver : public OsiAuxInfo {
+public:
+  // Default Constructor 
+  OsiBabSolver (int solverType=0);
+
+  // Copy Constructor 
+  OsiBabSolver (const OsiBabSolver & rhs);
+  // Destructor
+  virtual ~OsiBabSolver();
+  
+  /// Clone
+  virtual OsiAuxInfo * clone() const;
+  /// Assignment operator 
+  OsiBabSolver & operator=(const OsiBabSolver& rhs);
+  
+  /// Update solver 
+  inline void setSolver(const OsiSolverInterface * solver)
+  { solver_ = solver;}
+  /// Update solver 
+  inline void setSolver(const OsiSolverInterface & solver)
+  { solver_ = &solver;}
+
+  /** returns 0 if no heuristic solution, 1 if valid solution
+      with better objective value than one passed in
+      Sets solution values if good, sets objective value 
+      numberColumns is size of newSolution
+  */
+  int solution(double & objectiveValue,
+		       double * newSolution, int numberColumns);
+  /** Set solution and objective value.
+      Number of columns and optimization direction taken from current solver.
+      Size of solution is numberColumns (may be padded or truncated in function) */
+  void setSolution(const double * solution, int numberColumns, double objectiveValue);
+
+  /** returns true if the object stores a solution, false otherwise. If there
+	  is a solution then solutionValue and solution will be filled out as well.
+      In that case the user needs to allocate solution to be a big enough
+	  array.
+  */
+  bool hasSolution(double & solutionValue, double * solution);
+
+  /** Sets solver type
+      0 - normal LP solver
+      1 - DW - may also return heuristic solutions
+      2 - NLP solver or similar - can't compute objective value just from solution
+          check solver to see if feasible and what objective value is
+          - may also return heuristic solution
+      3 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is.
+          Using Outer Approximation so called lp based
+          - may also return heuristic solution
+      4 - normal solver but cuts are needed for integral solution    
+  */
+  inline void setSolverType(int value)
+  { solverType_=value;}
+  /** gets solver type
+      0 - normal LP solver
+      1 - DW - may also return heuristic solutions
+      2 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is
+          - may also return heuristic solution
+      3 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is.
+          Using Outer Approximation so called lp based
+          - may also return heuristic solution
+      4 - normal solver but cuts are needed for integral solution    
+  */
+  inline int solverType() const
+  { return solverType_;}
+  /** Return true if getting solution may add cuts so hot start etc will
+      be obsolete */
+  inline bool solutionAddsCuts() const
+  { return solverType_==3;}
+  /// Return true if we should try cuts at root even if looks satisfied
+  inline bool alwaysTryCutsAtRootNode() const
+  { return solverType_==4;}
+  /** Returns true if can use solver objective or feasible values,
+      otherwise use mipBound etc */
+  inline bool solverAccurate() const
+  { return solverType_==0||solverType_==2||solverType_==4;}
+  /// Returns true if can use reduced costs for fixing
+  inline bool reducedCostsAccurate() const
+  { return solverType_==0||solverType_==4;}
+  /// Get objective  (well mip bound)
+  double mipBound() const;
+  /// Returns true if node feasible
+  bool mipFeasible() const;
+  /// Set mip bound (only used for some solvers)
+  inline void setMipBound(double value)
+  { mipBound_ = value;}
+  /// Get objective value of saved solution
+  inline double bestObjectiveValue() const
+  { return bestObjectiveValue_;}
+  /// Says whether we want to try cuts at all
+  inline bool tryCuts() const
+  { return solverType_!=2;}
+  /// Says whether we have a warm start (so can do strong branching)
+  inline bool warmStart() const
+  { return solverType_!=2;}
+  /** Get bit mask for odd actions of solvers
+      1 - solution or bound arrays may move in mysterious ways e.g. cplex
+      2 - solver may want bounds before branch
+  */
+  inline int extraCharacteristics() const
+  { return extraCharacteristics_;}
+  /** Set bit mask for odd actions of solvers
+      1 - solution or bound arrays may move in mysterious ways e.g. cplex
+      2 - solver may want bounds before branch
+  */
+  inline void setExtraCharacteristics(int value)
+  { extraCharacteristics_=value;}
+  /// Pointer to lower bounds before branch (only if extraCharacteristics set)
+  inline const double * beforeLower() const
+  { return beforeLower_;}
+  /// Set pointer to lower bounds before branch (only if extraCharacteristics set)
+  inline void setBeforeLower(const double * array)
+  { beforeLower_ = array;}
+  /// Pointer to upper bounds before branch (only if extraCharacteristics set)
+  inline const double * beforeUpper() const
+  { return beforeUpper_;}
+  /// Set pointer to upper bounds before branch (only if extraCharacteristics set)
+  inline void setBeforeUpper(const double * array)
+  { beforeUpper_ = array;}
+protected:
+  /// Objective value of best solution (if there is one) (minimization)
+  double bestObjectiveValue_;
+  /// Current lower bound on solution ( if > 1.0e50 infeasible)
+  double mipBound_;
+  /// Solver to use for getting/setting solutions etc
+  const OsiSolverInterface * solver_;
+  /// Best integer feasible solution
+  double * bestSolution_;
+  /// Pointer to lower bounds before branch (only if extraCharacteristics set)
+  const double * beforeLower_;
+  /// Pointer to upper bounds before branch (only if extraCharacteristics set)
+  const double * beforeUpper_;
+  /** Solver type
+      0 - normal LP solver
+      1 - DW - may also return heuristic solutions
+      2 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is
+          - may also return heuristic solution
+      3 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is.
+          Using Outer Approximation so called lp based
+          - may also return heuristic solution
+  */
+  int solverType_;
+  /// Size of solution
+  int sizeSolution_;
+  /** Bit mask for odd actions of solvers
+      1 - solution or bound arrays may move in mysterious ways e.g. cplex
+      2 - solver may want bounds before branch
+  */
+  int extraCharacteristics_;
+};
+
+#endif