ruby-cbc 0.1.9 → 0.2.1

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

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

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

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