ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,187 +0,0 @@
-/* $Id: ClpEventHandler.hpp 2156 2015-08-07 14:51:42Z forrest $ */
-// Copyright (C) 2004, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef ClpEventHandler_H
-#define ClpEventHandler_H
-
-#include "ClpSimplex.hpp"
-/** Base class for Clp event handling
-
-This is just here to allow for event handling.  By event I mean a Clp event
-e.g. end of values pass.
-
-One use would be to let a user handle a system event e.g. Control-C.  This could be done
-by deriving a class MyEventHandler which knows about such events.  If one occurs
-MyEventHandler::event() could clear event status and return 3 (stopped).
-
-Clp would then return to user code.
-
-As it is called every iteration this should be fine grained enough.
-
-User can derive and construct from CbcModel  - not pretty
-
-*/
-
-class ClpEventHandler  {
-
-public:
-     /** enums for what sort of event.
-
-         These will also be returned in ClpModel::secondaryStatus() as int
-     */
-     enum Event {
-          endOfIteration = 100, // used to set secondary status
-          endOfFactorization, // after gutsOfSolution etc
-          endOfValuesPass,
-          node, // for Cbc
-          treeStatus, // for Cbc
-          solution, // for Cbc
-          theta, // hit in parametrics
-          pivotRow, // used to choose pivot row
-	  presolveStart, // ClpSolve presolve start
-	  presolveSize, // sees if ClpSolve presolve too big or too small
-	  presolveInfeasible, // ClpSolve presolve infeasible
-	  presolveBeforeSolve, // ClpSolve presolve before solve
-	  presolveAfterFirstSolve, // ClpSolve presolve after solve
-	  presolveAfterSolve, // ClpSolve presolve after solve
-	  presolveEnd, // ClpSolve presolve end
-	  goodFactorization, // before gutsOfSolution
-	  complicatedPivotIn, // in modifyCoefficients
-	  noCandidateInPrimal, // tentative end
-	  looksEndInPrimal, // About to declare victory (or defeat)
-	  endInPrimal, // Victory (or defeat)
-	  beforeStatusOfProblemInPrimal,
-	  startOfStatusOfProblemInPrimal,
-	  complicatedPivotOut, // in modifyCoefficients
-	  noCandidateInDual, // tentative end
-	  looksEndInDual, // About to declare victory (or defeat)
-	  endInDual, // Victory (or defeat)
-	  beforeStatusOfProblemInDual,
-	  startOfStatusOfProblemInDual,
-	  startOfIterationInDual,
-	  updateDualsInDual,
-	  endOfCreateRim,
-	  slightlyInfeasible,
-	  modifyMatrixInMiniPresolve,
-	  moreMiniPresolve,
-	  modifyMatrixInMiniPostsolve,
-	  startOfCrossover, // in Idiot
-	  noTheta // At end (because no pivot)
-     };
-     /**@name Virtual method that the derived classes should provide.
-      The base class instance does nothing and as event() is only useful method
-      it would not be very useful NOT providing one!
-     */
-     //@{
-     /** This can do whatever it likes.  If return code -1 then carries on
-         if 0 sets ClpModel::status() to 5 (stopped by event) and will return to user.
-         At present if <-1 carries on and if >0 acts as if 0 - this may change.
-	 For ClpSolve 2 -> too big return status of -2 and -> too small 3
-     */
-     virtual int event(Event whichEvent);
-     /** This can do whatever it likes.  Return code -1 means no action.
-	 This passes in something
-     */
-     virtual int eventWithInfo(Event whichEvent, void * info) ;
-     //@}
-
-
-     /**@name Constructors, destructor */
-
-     //@{
-     /** Default constructor. */
-     ClpEventHandler(ClpSimplex * model = NULL);
-     /** Destructor */
-     virtual ~ClpEventHandler();
-     // Copy
-     ClpEventHandler(const ClpEventHandler&);
-     // Assignment
-     ClpEventHandler& operator=(const ClpEventHandler&);
-     /// Clone
-     virtual ClpEventHandler * clone() const;
-
-     //@}
-
-     /**@name Sets/gets */
-
-     //@{
-     /** set model. */
-     void setSimplex(ClpSimplex * model);
-     /// Get model
-     inline ClpSimplex * simplex() const {
-          return model_;
-     }
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// Pointer to simplex
-     ClpSimplex * model_;
-     //@}
-};
-/** Base class for Clp disaster handling
-
-This is here to allow for disaster handling.  By disaster I mean that Clp
-would otherwise give up
-
-*/
-
-class ClpDisasterHandler  {
-
-public:
-     /**@name Virtual methods that the derived classe should provide.
-     */
-     //@{
-     /// Into simplex
-     virtual void intoSimplex() = 0;
-     /// Checks if disaster
-     virtual bool check() const = 0;
-     /// saves information for next attempt
-     virtual void saveInfo() = 0;
-     /// Type of disaster 0 can fix, 1 abort
-     virtual int typeOfDisaster();
-     //@}
-
-
-     /**@name Constructors, destructor */
-
-     //@{
-     /** Default constructor. */
-     ClpDisasterHandler(ClpSimplex * model = NULL);
-     /** Destructor */
-     virtual ~ClpDisasterHandler();
-     // Copy
-     ClpDisasterHandler(const ClpDisasterHandler&);
-     // Assignment
-     ClpDisasterHandler& operator=(const ClpDisasterHandler&);
-     /// Clone
-     virtual ClpDisasterHandler * clone() const = 0;
-
-     //@}
-
-     /**@name Sets/gets */
-
-     //@{
-     /** set model. */
-     void setSimplex(ClpSimplex * model);
-     /// Get model
-     inline ClpSimplex * simplex() const {
-          return model_;
-     }
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// Pointer to simplex
-     ClpSimplex * model_;
-     //@}
-};
-#endif

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

@@ -1,432 +0,0 @@
-/* $Id: ClpFactorization.hpp 2078 2015-01-05 12:39:49Z 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 ClpFactorization_H
-#define ClpFactorization_H
-
-
-#include "CoinPragma.hpp"
-
-#include "CoinFactorization.hpp"
-class ClpMatrixBase;
-class ClpSimplex;
-class ClpNetworkBasis;
-class CoinOtherFactorization;
-#ifndef CLP_MULTIPLE_FACTORIZATIONS
-#define CLP_MULTIPLE_FACTORIZATIONS 4
-#endif
-#ifdef CLP_MULTIPLE_FACTORIZATIONS
-#include "CoinDenseFactorization.hpp"
-#include "ClpSimplex.hpp"
-#endif
-#ifndef COIN_FAST_CODE
-#define COIN_FAST_CODE
-#endif
-#ifndef CLP_FACTORIZATION_NEW_TIMING
-#define CLP_FACTORIZATION_NEW_TIMING 1
-#endif
-
-/** This just implements CoinFactorization when an ClpMatrixBase object
-    is passed.  If a network then has a dummy CoinFactorization and
-    a genuine ClpNetworkBasis object
-*/
-class ClpFactorization
-#ifndef CLP_MULTIPLE_FACTORIZATIONS
-     : public CoinFactorization
-#endif
-{
-
-     //friend class CoinFactorization;
-
-public:
-     /**@name factorization */
-     //@{
-     /** When part of LP - given by basic variables.
-     Actually does factorization.
-     Arrays passed in have non negative value to say basic.
-     If status is okay, basic variables have pivot row - this is only needed
-     if increasingRows_ >1.
-     Allows scaling
-     If status is singular, then basic variables have pivot row
-     and ones thrown out have -1
-     returns 0 -okay, -1 singular, -2 too many in basis, -99 memory */
-     int factorize (ClpSimplex * model, int solveType, bool valuesPass);
-     //@}
-
-
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpFactorization();
-     /** Destructor */
-     ~ClpFactorization();
-     //@}
-
-     /**@name Copy method */
-     //@{
-     /** The copy constructor from an CoinFactorization. */
-     ClpFactorization(const CoinFactorization&);
-     /** The copy constructor. */
-     ClpFactorization(const ClpFactorization&, int denseIfSmaller = 0);
-#ifdef CLP_MULTIPLE_FACTORIZATIONS
-     /** The copy constructor from an CoinOtherFactorization. */
-     ClpFactorization(const CoinOtherFactorization&);
-#endif
-     ClpFactorization& operator=(const ClpFactorization&);
-     //@}
-
-     /*  **** below here is so can use networkish basis */
-     /**@name rank one updates which do exist */
-     //@{
-
-     /** Replaces one Column to basis,
-      returns 0=OK, 1=Probably OK, 2=singular, 3=no room
-         If checkBeforeModifying is true will do all accuracy checks
-         before modifying factorization.  Whether to set this depends on
-         speed considerations.  You could just do this on first iteration
-         after factorization and thereafter re-factorize
-      partial update already in U */
-     int replaceColumn ( const ClpSimplex * model,
-                         CoinIndexedVector * regionSparse,
-                         CoinIndexedVector * tableauColumn,
-                         int pivotRow,
-                         double pivotCheck ,
-                         bool checkBeforeModifying = false,
-                         double acceptablePivot = 1.0e-8);
-     //@}
-
-     /**@name various uses of factorization (return code number elements)
-      which user may want to know about */
-     //@{
-     /** Updates one column (FTRAN) from region2
-         Tries to do FT update
-         number returned is negative if no room
-         region1 starts as zero and is zero at end */
-     int updateColumnFT ( CoinIndexedVector * regionSparse,
-                          CoinIndexedVector * regionSparse2);
-     /** Updates one column (FTRAN) from region2
-         region1 starts as zero and is zero at end */
-     int updateColumn ( CoinIndexedVector * regionSparse,
-                        CoinIndexedVector * regionSparse2,
-                        bool noPermute = false) const;
-     /** Updates one column (FTRAN) from region2
-         Tries to do FT update
-         number returned is negative if no room.
-         Also updates region3
-         region1 starts as zero and is zero at end */
-     int updateTwoColumnsFT ( CoinIndexedVector * regionSparse1,
-                              CoinIndexedVector * regionSparse2,
-                              CoinIndexedVector * regionSparse3,
-                              bool noPermuteRegion3 = false) ;
-     /// For debug (no statistics update)
-     int updateColumnForDebug ( CoinIndexedVector * regionSparse,
-                                CoinIndexedVector * regionSparse2,
-                                bool noPermute = false) const;
-     /** Updates one column (BTRAN) from region2
-         region1 starts as zero and is zero at end */
-     int updateColumnTranspose ( CoinIndexedVector * regionSparse,
-                                 CoinIndexedVector * regionSparse2) const;
-     //@}
-#ifdef CLP_MULTIPLE_FACTORIZATIONS
-     /**@name Lifted from CoinFactorization */
-     //@{
-     /// Total number of elements in factorization
-     inline int numberElements (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->numberElements();
-          else return coinFactorizationB_->numberElements() ;
-     }
-     /// Returns address of permute region
-     inline int *permute (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->permute();
-          else return coinFactorizationB_->permute() ;
-     }
-     /// Returns address of pivotColumn region (also used for permuting)
-     inline int *pivotColumn (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->pivotColumn();
-          else return coinFactorizationB_->permute() ;
-     }
-     /// Maximum number of pivots between factorizations
-     inline int maximumPivots (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->maximumPivots();
-          else return coinFactorizationB_->maximumPivots() ;
-     }
-     /// Set maximum number of pivots between factorizations
-     inline void maximumPivots (  int value) {
-          if (coinFactorizationA_) coinFactorizationA_->maximumPivots(value);
-          else coinFactorizationB_->maximumPivots(value);
-     }
-     /// Returns number of pivots since factorization
-     inline int pivots (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->pivots();
-          else return coinFactorizationB_->pivots() ;
-     }
-     /// Whether larger areas needed
-     inline double areaFactor (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->areaFactor();
-          else return 0.0 ;
-     }
-     /// Set whether larger areas needed
-     inline void areaFactor ( double value) {
-          if (coinFactorizationA_) coinFactorizationA_->areaFactor(value);
-     }
-     /// Zero tolerance
-     inline double zeroTolerance (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->zeroTolerance();
-          else return coinFactorizationB_->zeroTolerance() ;
-     }
-     /// Set zero tolerance
-     inline void zeroTolerance (  double value) {
-          if (coinFactorizationA_) coinFactorizationA_->zeroTolerance(value);
-          else coinFactorizationB_->zeroTolerance(value);
-     }
-     /// Set tolerances to safer of existing and given
-     void saferTolerances (  double zeroTolerance, double pivotTolerance);
-     /**  get sparse threshold */
-     inline int sparseThreshold ( ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->sparseThreshold();
-          else return 0 ;
-     }
-     /**  Set sparse threshold */
-     inline void sparseThreshold ( int value) {
-          if (coinFactorizationA_) coinFactorizationA_->sparseThreshold(value);
-     }
-     /// Returns status
-     inline int status (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->status();
-          else return coinFactorizationB_->status() ;
-     }
-     /// Sets status
-     inline void setStatus (  int value) {
-          if (coinFactorizationA_) coinFactorizationA_->setStatus(value);
-          else coinFactorizationB_->setStatus(value) ;
-     }
-     /// Returns number of dense rows
-     inline int numberDense() const {
-          if (coinFactorizationA_) return coinFactorizationA_->numberDense();
-          else return 0 ;
-     }
-#if 1
-     /// Returns number in U area
-     inline CoinBigIndex numberElementsU (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->numberElementsU();
-          else return -1 ;
-     }
-     /// Returns number in L area
-     inline CoinBigIndex numberElementsL (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->numberElementsL();
-          else return -1 ;
-     }
-     /// Returns number in R area
-     inline CoinBigIndex numberElementsR (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->numberElementsR();
-          else return 0 ;
-     }
-#endif
-     bool timeToRefactorize() const;
-#if CLP_FACTORIZATION_NEW_TIMING>1
-     void statsRefactor(char when) const;
-#endif
-     /// Level of detail of messages
-     inline int messageLevel (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->messageLevel();
-          else return 1 ;
-     }
-     /// Set level of detail of messages
-     inline void messageLevel (  int value) {
-          if (coinFactorizationA_) coinFactorizationA_->messageLevel(value);
-     }
-     /// Get rid of all memory
-     inline void clearArrays() {
-          if (coinFactorizationA_)
-               coinFactorizationA_->clearArrays();
-          else if (coinFactorizationB_)
-               coinFactorizationB_->clearArrays();
-     }
-     /// Number of Rows after factorization
-     inline int numberRows (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->numberRows();
-          else return coinFactorizationB_->numberRows() ;
-     }
-     /// Gets dense threshold
-     inline int denseThreshold() const {
-          if (coinFactorizationA_) return coinFactorizationA_->denseThreshold();
-          else return 0 ;
-     }
-     /// Sets dense threshold
-     inline void setDenseThreshold(int value) {
-          if (coinFactorizationA_) coinFactorizationA_->setDenseThreshold(value);
-     }
-     /// Pivot tolerance
-     inline double pivotTolerance (  ) const {
-          if (coinFactorizationA_) return coinFactorizationA_->pivotTolerance();
-          else if (coinFactorizationB_) return coinFactorizationB_->pivotTolerance();
-          return 1.0e-8 ;
-     }
-     /// Set pivot tolerance
-     inline void pivotTolerance (  double value) {
-          if (coinFactorizationA_) coinFactorizationA_->pivotTolerance(value);
-          else if (coinFactorizationB_) coinFactorizationB_->pivotTolerance(value);
-     }
-     /// Allows change of pivot accuracy check 1.0 == none >1.0 relaxed
-     inline void relaxAccuracyCheck(double value) {
-          if (coinFactorizationA_) coinFactorizationA_->relaxAccuracyCheck(value);
-     }
-     /** Array persistence flag
-         If 0 then as now (delete/new)
-         1 then only do arrays if bigger needed
-         2 as 1 but give a bit extra if bigger needed
-     */
-     inline int persistenceFlag() const {
-          if (coinFactorizationA_) return coinFactorizationA_->persistenceFlag();
-          else return 0 ;
-     }
-     inline void setPersistenceFlag(int value) {
-          if (coinFactorizationA_) coinFactorizationA_->setPersistenceFlag(value);
-     }
-     /// Delete all stuff (leaves as after CoinFactorization())
-     inline void almostDestructor() {
-          if (coinFactorizationA_)
-               coinFactorizationA_->almostDestructor();
-          else if (coinFactorizationB_)
-               coinFactorizationB_->clearArrays();
-     }
-     /// Returns areaFactor but adjusted for dense
-     inline double adjustedAreaFactor() const {
-          if (coinFactorizationA_) return coinFactorizationA_->adjustedAreaFactor();
-          else return 0.0 ;
-     }
-     inline void setBiasLU(int value) {
-          if (coinFactorizationA_) coinFactorizationA_->setBiasLU(value);
-     }
-     /// true if Forrest Tomlin update, false if PFI
-     inline void setForrestTomlin(bool value) {
-          if (coinFactorizationA_) coinFactorizationA_->setForrestTomlin(value);
-     }
-     /// Sets default values
-     inline void setDefaultValues() {
-          if (coinFactorizationA_) {
-               // row activities have negative sign
-#ifndef COIN_FAST_CODE
-               coinFactorizationA_->slackValue(-1.0);
-#endif
-               coinFactorizationA_->zeroTolerance(1.0e-13);
-          }
-     }
-     /// If nonzero force use of 1,dense 2,small 3,osl
-     void forceOtherFactorization(int which);
-     /// Get switch to osl if number rows <= this
-     inline int goOslThreshold() const {
-          return goOslThreshold_;
-     }
-     /// Set switch to osl if number rows <= this
-     inline void setGoOslThreshold(int value) {
-          goOslThreshold_ = value;
-     }
-     /// Get switch to dense if number rows <= this
-     inline int goDenseThreshold() const {
-          return goDenseThreshold_;
-     }
-     /// Set switch to dense if number rows <= this
-     inline void setGoDenseThreshold(int value) {
-          goDenseThreshold_ = value;
-     }
-     /// Get switch to small if number rows <= this
-     inline int goSmallThreshold() const {
-          return goSmallThreshold_;
-     }
-     /// Set switch to small if number rows <= this
-     inline void setGoSmallThreshold(int value) {
-          goSmallThreshold_ = value;
-     }
-     /// Go over to dense or small code if small enough
-     void goDenseOrSmall(int numberRows) ;
-     /// Sets factorization
-     void setFactorization(ClpFactorization & factorization);
-     /// Return 1 if dense code
-     inline int isDenseOrSmall() const {
-          return coinFactorizationB_ ? 1 : 0;
-     }
-#else
-     inline bool timeToRefactorize() const {
-          return (pivots() * 3 > maximumPivots() * 2 &&
-                  numberElementsR() * 3 > (numberElementsL() + numberElementsU()) * 2 + 1000 &&
-                  !numberDense());
-     }
-     /// Sets default values
-     inline void setDefaultValues() {
-          // row activities have negative sign
-#ifndef COIN_FAST_CODE
-          slackValue(-1.0);
-#endif
-          zeroTolerance(1.0e-13);
-     }
-     /// Go over to dense code
-     inline void goDense() {}
-#endif
-     //@}
-
-     /**@name other stuff */
-     //@{
-     /** makes a row copy of L for speed and to allow very sparse problems */
-     void goSparse();
-     /// Cleans up i.e. gets rid of network basis
-     void cleanUp();
-     /// Says whether to redo pivot order
-     bool needToReorder() const;
-#ifndef SLIM_CLP
-     /// Says if a network basis
-     inline bool networkBasis() const {
-          return (networkBasis_ != NULL);
-     }
-#else
-     /// Says if a network basis
-     inline bool networkBasis() const {
-          return false;
-     }
-#endif
-     /// Fills weighted row list
-     void getWeights(int * weights) const;
-     //@}
-
-////////////////// data //////////////////
-private:
-
-     /**@name data */
-     //@{
-     /// Pointer to network basis
-#ifndef SLIM_CLP
-     ClpNetworkBasis * networkBasis_;
-#endif
-#ifdef CLP_MULTIPLE_FACTORIZATIONS
-     /// Pointer to CoinFactorization
-     CoinFactorization * coinFactorizationA_;
-     /// Pointer to CoinOtherFactorization
-     CoinOtherFactorization * coinFactorizationB_;
-#ifdef CLP_REUSE_ETAS
-     /// Pointer to model
-     ClpSimplex * model_;
-#endif
-     /// If nonzero force use of 1,dense 2,small 3,osl
-     int forceB_;
-     /// Switch to osl if number rows <= this
-     int goOslThreshold_;
-     /// Switch to small if number rows <= this
-     int goSmallThreshold_;
-     /// Switch to dense if number rows <= this
-     int goDenseThreshold_;
-#endif
-#ifdef CLP_FACTORIZATION_NEW_TIMING
-     /// For guessing when to re-factorize
-     mutable double shortestAverage_;
-     mutable double totalInR_;
-     mutable double totalInIncreasingU_;
-     mutable int endLengthU_;
-     mutable int lastNumberPivots_;
-     mutable int effectiveStartNumberU_;
-#endif
-     //@}
-};
- 
-#endif