ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,115 +0,0 @@
-/* $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

@@ -1,298 +0,0 @@
-/* $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

@@ -1,206 +0,0 @@
-// 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