ruby-cbc 0.1.9

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

@@ -0,0 +1,299 @@
+/* $Id: ClpPresolve.hpp 2134 2015-03-22 16:40:43Z 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).
+
+#ifndef ClpPresolve_H
+#define ClpPresolve_H
+#include "ClpSimplex.hpp"
+
+class CoinPresolveAction;
+#include "CoinPresolveMatrix.hpp"
+/** This is the Clp interface to CoinPresolve
+
+*/
+class ClpPresolve {
+public:
+     /**@name Main Constructor, destructor */
+     //@{
+     /// Default constructor
+     ClpPresolve();
+
+     /// Virtual destructor
+     virtual ~ClpPresolve();
+     //@}
+     /**@name presolve - presolves a model, transforming the model
+      * and saving information in the ClpPresolve object needed for postsolving.
+      * This underlying (protected) method is virtual; the idea is that in the future,
+      * one could override this method to customize how the various
+      * presolve techniques are applied.
+
+      This version of presolve returns a pointer to a new presolved
+         model.  NULL if infeasible or unbounded.
+         This should be paired with postsolve
+         below.  The advantage of going back to original model is that it
+         will be exactly as it was i.e. 0.0 will not become 1.0e-19.
+         If keepIntegers is true then bounds may be tightened in
+         original.  Bounds will be moved by up to feasibilityTolerance
+         to try and stay feasible.
+         Names will be dropped in presolved model if asked
+     */
+     ClpSimplex * presolvedModel(ClpSimplex & si,
+                                 double feasibilityTolerance = 0.0,
+                                 bool keepIntegers = true,
+                                 int numberPasses = 5,
+                                 bool dropNames = false,
+                                 bool doRowObjective = false,
+				 const char * prohibitedRows=NULL,
+				 const char * prohibitedColumns=NULL);
+#ifndef CLP_NO_STD
+     /** This version saves data in a file.  The passed in model
+         is updated to be presolved model.  
+         Returns non-zero if infeasible*/
+     int presolvedModelToFile(ClpSimplex &si, std::string fileName,
+                              double feasibilityTolerance = 0.0,
+                              bool keepIntegers = true,
+                              int numberPasses = 5,
+			      bool dropNames = false,
+                              bool doRowObjective = false);
+#endif
+     /** Return pointer to presolved model,
+         Up to user to destroy */
+     ClpSimplex * model() const;
+     /// Return pointer to original model
+     ClpSimplex * originalModel() const;
+     /// Set pointer to original model
+     void setOriginalModel(ClpSimplex * model);
+
+     /// return pointer to original columns
+     const int * originalColumns() const;
+     /// return pointer to original rows
+     const int * originalRows() const;
+     /** "Magic" number. If this is non-zero then any elements with this value
+         may change and so presolve is very limited in what can be done
+         to the row and column.  This is for non-linear problems.
+     */
+     inline void setNonLinearValue(double value) {
+          nonLinearValue_ = value;
+     }
+     inline double nonLinearValue() const {
+          return nonLinearValue_;
+     }
+     /// Whether we want to do dual part of presolve
+     inline bool doDual() const {
+          return (presolveActions_ & 1) == 0;
+     }
+     inline void setDoDual(bool doDual) {
+          if (doDual) presolveActions_  &= ~1;
+          else presolveActions_ |= 1;
+     }
+     /// Whether we want to do singleton part of presolve
+     inline bool doSingleton() const {
+          return (presolveActions_ & 2) == 0;
+     }
+     inline void setDoSingleton(bool doSingleton) {
+          if (doSingleton) presolveActions_  &= ~2;
+          else presolveActions_ |= 2;
+     }
+     /// Whether we want to do doubleton part of presolve
+     inline bool doDoubleton() const {
+          return (presolveActions_ & 4) == 0;
+     }
+     inline void setDoDoubleton(bool doDoubleton) {
+          if (doDoubleton) presolveActions_  &= ~4;
+          else presolveActions_ |= 4;
+     }
+     /// Whether we want to do tripleton part of presolve
+     inline bool doTripleton() const {
+          return (presolveActions_ & 8) == 0;
+     }
+     inline void setDoTripleton(bool doTripleton) {
+          if (doTripleton) presolveActions_  &= ~8;
+          else presolveActions_ |= 8;
+     }
+     /// Whether we want to do tighten part of presolve
+     inline bool doTighten() const {
+          return (presolveActions_ & 16) == 0;
+     }
+     inline void setDoTighten(bool doTighten) {
+          if (doTighten) presolveActions_  &= ~16;
+          else presolveActions_ |= 16;
+     }
+     /// Whether we want to do forcing part of presolve
+     inline bool doForcing() const {
+          return (presolveActions_ & 32) == 0;
+     }
+     inline void setDoForcing(bool doForcing) {
+          if (doForcing) presolveActions_  &= ~32;
+          else presolveActions_ |= 32;
+     }
+     /// Whether we want to do impliedfree part of presolve
+     inline bool doImpliedFree() const {
+          return (presolveActions_ & 64) == 0;
+     }
+     inline void setDoImpliedFree(bool doImpliedfree) {
+          if (doImpliedfree) presolveActions_  &= ~64;
+          else presolveActions_ |= 64;
+     }
+     /// Whether we want to do dupcol part of presolve
+     inline bool doDupcol() const {
+          return (presolveActions_ & 128) == 0;
+     }
+     inline void setDoDupcol(bool doDupcol) {
+          if (doDupcol) presolveActions_  &= ~128;
+          else presolveActions_ |= 128;
+     }
+     /// Whether we want to do duprow part of presolve
+     inline bool doDuprow() const {
+          return (presolveActions_ & 256) == 0;
+     }
+     inline void setDoDuprow(bool doDuprow) {
+          if (doDuprow) presolveActions_  &= ~256;
+          else presolveActions_ |= 256;
+     }
+     /// Whether we want to do dependency part of presolve
+     inline bool doDependency() const {
+          return (presolveActions_ & 32768) != 0;
+     }
+     inline void setDoDependency(bool doDependency) {
+          if (doDependency) presolveActions_  |= 32768;
+          else presolveActions_ &= ~32768;
+     }
+     /// Whether we want to do singleton column part of presolve
+     inline bool doSingletonColumn() const {
+          return (presolveActions_ & 512) == 0;
+     }
+     inline void setDoSingletonColumn(bool doSingleton) {
+          if (doSingleton) presolveActions_  &= ~512;
+          else presolveActions_ |= 512;
+     }
+     /// Whether we want to do gubrow part of presolve
+     inline bool doGubrow() const {
+          return (presolveActions_ & 1024) == 0;
+     }
+     inline void setDoGubrow(bool doGubrow) {
+          if (doGubrow) presolveActions_  &= ~1024;
+          else presolveActions_ |= 1024;
+     }
+     /// Whether we want to do twoxtwo part of presolve
+     inline bool doTwoxTwo() const {
+          return (presolveActions_ & 2048) != 0;
+     }
+     inline void setDoTwoxtwo(bool doTwoxTwo) {
+          if (!doTwoxTwo) presolveActions_  &= ~2048;
+          else presolveActions_ |= 2048;
+     }
+     /// Whether we want to allow duplicate intersections
+     inline bool doIntersection() const {
+          return (presolveActions_ & 4096) != 0;
+     }
+     inline void setDoIntersection(bool doIntersection) {
+          if (doIntersection) presolveActions_  &= ~4096;
+          else presolveActions_ |= 4096;
+     }
+     /** How much we want to zero small values from aggregation - ratio
+	 0 - 1.0e-12, 1 1.0e-11, 2 1.0e-10, 3 1.0e-9 */
+     inline int zeroSmall() const {
+          return (presolveActions_&(8192|16384))>>13;
+     }
+     inline void setZeroSmall(int value) {
+         presolveActions_  &= ~(8192|16384);
+	 presolveActions_ |= value<<13;
+     }
+     /// Set whole group
+     inline int presolveActions() const {
+          return presolveActions_ & 0xffff;
+     }
+     inline void setPresolveActions(int action) {
+          presolveActions_  = (presolveActions_ & 0xffff0000) | (action & 0xffff);
+     }
+     /// Substitution level
+     inline void setSubstitution(int value) {
+          substitution_ = value;
+     }
+     /// Asks for statistics
+     inline void statistics() {
+          presolveActions_ |= 0x80000000;
+     }
+     /// Return presolve status (0,1,2)
+     int presolveStatus() const;
+
+     /**@name postsolve - postsolve the problem.  If the problem
+       has not been solved to optimality, there are no guarantees.
+      If you are using an algorithm like simplex that has a concept
+      of "basic" rows/cols, then set updateStatus
+
+      Note that if you modified the original problem after presolving,
+      then you must ``undo'' these modifications before calling postsolve.
+     This version updates original*/
+     virtual void postsolve(bool updateStatus = true);
+
+     /// Gets rid of presolve actions (e.g.when infeasible)
+     void destroyPresolve();
+
+     /**@name private or protected data */
+private:
+     /// Original model - must not be destroyed before postsolve
+     ClpSimplex * originalModel_;
+
+     /// ClpPresolved model - up to user to destroy by deleteClpPresolvedModel
+     ClpSimplex * presolvedModel_;
+     /** "Magic" number. If this is non-zero then any elements with this value
+         may change and so presolve is very limited in what can be done
+         to the row and column.  This is for non-linear problems.
+         One could also allow for cases where sign of coefficient is known.
+     */
+     double nonLinearValue_;
+     /// Original column numbers
+     int * originalColumn_;
+     /// Original row numbers
+     int * originalRow_;
+     /// Row objective
+     double * rowObjective_;
+     /// The list of transformations applied.
+     const CoinPresolveAction *paction_;
+
+     /// The postsolved problem will expand back to its former size
+     /// as postsolve transformations are applied.
+     /// It is efficient to allocate data structures for the final size
+     /// of the problem rather than expand them as needed.
+     /// These fields give the size of the original problem.
+     int ncols_;
+     int nrows_;
+     CoinBigIndex nelems_;
+     /// Number of major passes
+     int numberPasses_;
+     /// Substitution level
+     int substitution_;
+#ifndef CLP_NO_STD
+     /// Name of saved model file
+     std::string saveFile_;
+#endif
+     /** Whether we want to skip dual part of presolve etc.
+         512 bit allows duplicate column processing on integer columns
+         and dual stuff on integers
+     */
+     int presolveActions_;
+protected:
+     /// If you want to apply the individual presolve routines differently,
+     /// or perhaps add your own to the mix,
+     /// define a derived class and override this method
+     virtual const CoinPresolveAction *presolve(CoinPresolveMatrix *prob);
+
+     /// Postsolving is pretty generic; just apply the transformations
+     /// in reverse order.
+     /// You will probably only be interested in overriding this method
+     /// if you want to add code to test for consistency
+     /// while debugging new presolve techniques.
+     virtual void postsolve(CoinPostsolveMatrix &prob);
+     /** This is main part of Presolve */
+     virtual ClpSimplex * gutsOfPresolvedModel(ClpSimplex * originalModel,
+               double feasibilityTolerance,
+               bool keepIntegers,
+               int numberPasses,
+               bool dropNames,
+					       bool doRowObjective,
+					       const char * prohibitedRows=NULL,
+					       const char * prohibitedColumns=NULL);
+};
+#endif

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

@@ -0,0 +1,72 @@
+/* $Id: ClpPrimalColumnDantzig.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// 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).
+
+#ifndef ClpPrimalColumnDantzig_H
+#define ClpPrimalColumnDantzig_H
+
+#include "ClpPrimalColumnPivot.hpp"
+
+//#############################################################################
+
+/** Primal Column Pivot Dantzig Algorithm Class
+
+This is simplest choice - choose largest infeasibility
+
+*/
+
+class ClpPrimalColumnDantzig : public ClpPrimalColumnPivot {
+
+public:
+
+     ///@name Algorithmic methods
+     //@{
+
+     /** Returns pivot column, -1 if none.
+         Lumbers over all columns - slow
+         The Packed CoinIndexedVector updates has cost updates - for normal LP
+         that is just +-weight where a feasibility changed.  It also has
+         reduced cost from last iteration in pivot row
+         Can just do full price if you really want to be slow
+     */
+     virtual int pivotColumn(CoinIndexedVector * updates,
+                             CoinIndexedVector * spareRow1,
+                             CoinIndexedVector * spareRow2,
+                             CoinIndexedVector * spareColumn1,
+                             CoinIndexedVector * spareColumn2);
+
+     /// Just sets model
+     virtual void saveWeights(ClpSimplex * model, int) {
+          model_ = model;
+     }
+     //@}
+
+
+     ///@name Constructors and destructors
+     //@{
+     /// Default Constructor
+     ClpPrimalColumnDantzig();
+
+     /// Copy constructor
+     ClpPrimalColumnDantzig(const ClpPrimalColumnDantzig &);
+
+     /// Assignment operator
+     ClpPrimalColumnDantzig & operator=(const ClpPrimalColumnDantzig& rhs);
+
+     /// Destructor
+     virtual ~ClpPrimalColumnDantzig ();
+
+     /// Clone
+     virtual ClpPrimalColumnPivot * clone(bool copyData = true) const;
+
+     //@}
+
+     //---------------------------------------------------------------------------
+
+private:
+     ///@name Private member data
+     //@}
+};
+
+#endif

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

@@ -0,0 +1,155 @@
+/* $Id: ClpPrimalColumnPivot.hpp 1732 2011-05-31 08:09:41Z 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).
+
+#ifndef ClpPrimalcolumnPivot_H
+#define ClpPrimalcolumnPivot_H
+
+class ClpSimplex;
+class CoinIndexedVector;
+
+//#############################################################################
+
+/** Primal Column Pivot Abstract Base Class
+
+Abstract Base Class for describing an interface to an algorithm
+to choose column pivot in primal simplex algorithm.  For some algorithms
+e.g. Dantzig choice then some functions may be null.  For Dantzig
+the only one of any importance is pivotColumn.
+
+If  you wish to inherit from this look at ClpPrimalColumnDantzig.cpp
+as that is simplest version.
+*/
+
+class ClpPrimalColumnPivot  {
+
+public:
+
+     ///@name Algorithmic methods
+     //@{
+
+     /** Returns pivot column, -1 if none
+
+         Normally updates reduced costs using result of last iteration
+         before selecting incoming column.
+
+         The Packed CoinIndexedVector updates has cost updates - for normal LP
+         that is just +-weight where a feasibility changed.  It also has
+         reduced cost from last iteration in pivot row
+
+         Inside pivotColumn the pivotRow_ and reduced cost from last iteration
+         are also used.
+
+         So in the simplest case i.e. feasible we compute the row of the
+         tableau corresponding to last pivot and add a multiple of this
+         to current reduced costs.
+
+         We can use other arrays to help updates
+     */
+     virtual int pivotColumn(CoinIndexedVector * updates,
+                             CoinIndexedVector * spareRow1,
+                             CoinIndexedVector * spareRow2,
+                             CoinIndexedVector * spareColumn1,
+                             CoinIndexedVector * spareColumn2) = 0;
+
+     /// Updates weights - part 1 (may be empty)
+     virtual void updateWeights(CoinIndexedVector * input);
+
+     /** Saves any weights round factorization as pivot rows may change
+         Will be empty unless steepest edge (will save model)
+         May also recompute infeasibility stuff
+         1) before factorization
+         2) after good factorization (if weights empty may initialize)
+         3) after something happened but no factorization
+            (e.g. check for infeasible)
+         4) as 2 but restore weights from previous snapshot
+         5) forces some initialization e.g. weights
+         Also sets model
+     */
+     virtual void saveWeights(ClpSimplex * model, int mode) = 0;
+     /** Signals pivot row choice:
+         -2 (default) - use normal pivot row choice
+         -1 to numberRows-1 - use this (will be checked)
+         way should be -1 to go to lower bound, +1 to upper bound
+     */
+     virtual int pivotRow(double & way) {
+          way = 0;
+          return -2;
+     }
+     /// Gets rid of all arrays (may be empty)
+     virtual void clearArrays();
+     /// Returns true if would not find any column
+     virtual bool looksOptimal() const {
+          return looksOptimal_;
+     }
+     /// Sets optimality flag (for advanced use)
+     virtual void setLooksOptimal(bool flag) {
+          looksOptimal_ = flag;
+     }
+     //@}
+
+
+     ///@name Constructors and destructors
+     //@{
+     /// Default Constructor
+     ClpPrimalColumnPivot();
+
+     /// Copy constructor
+     ClpPrimalColumnPivot(const ClpPrimalColumnPivot &);
+
+     /// Assignment operator
+     ClpPrimalColumnPivot & operator=(const ClpPrimalColumnPivot& rhs);
+
+     /// Destructor
+     virtual ~ClpPrimalColumnPivot ();
+
+     /// Clone
+     virtual ClpPrimalColumnPivot * clone(bool copyData = true) const = 0;
+
+     //@}
+
+     ///@name Other
+     //@{
+     /// Returns model
+     inline ClpSimplex * model() {
+          return model_;
+     }
+     /// Sets model
+     inline void setModel(ClpSimplex * newmodel) {
+          model_ = newmodel;
+     }
+
+     /// Returns type (above 63 is extra information)
+     inline int type() {
+          return type_;
+     }
+
+     /** Returns number of extra columns for sprint algorithm - 0 means off.
+         Also number of iterations before recompute
+     */
+     virtual int numberSprintColumns(int & numberIterations) const;
+     /// Switch off sprint idea
+     virtual void switchOffSprint();
+     /// Called when maximum pivots changes
+     virtual void maximumPivotsChanged() {}
+
+     //@}
+
+     //---------------------------------------------------------------------------
+
+protected:
+     ///@name Protected member data
+     //@{
+     /// Pointer to model
+     ClpSimplex * model_;
+     /// Type of column pivot algorithm
+     int type_;
+     /// Says if looks optimal (normally computed)
+     bool looksOptimal_;
+     //@}
+};
+#ifndef CLP_PRIMAL_SLACK_MULTIPLIER
+#define CLP_PRIMAL_SLACK_MULTIPLIER 1.01
+#endif
+#endif