ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,133 +0,0 @@
-// $Id: CglZeroHalf.hpp 1122 2013-04-06 20:39:53Z stefan $
-// Copyright (C) 2010, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-#ifndef CglZeroHalf_H
-#define CglZeroHalf_H
-
-#include <string>
-
-#include "CglCutGenerator.hpp"
-#include "CoinPackedMatrix.hpp"
-#include "Cgl012cut.hpp" 
-
-/** Zero Half Cut Generator Class
-
- This class generates zero half cuts via the following method:
-
- See - 
-
-G. Andreello, A. Caprara, M. Fischetti,
- “Embedding Cuts in a Branch and Cut Framework: a Computational Study 
-  with {0,1/2}-Cuts”, INFORMS Journal on Computing 19(2), 229-238, 2007.
- 
-*/
-
-class CglZeroHalf : public CglCutGenerator {
-   friend void CglZeroHalfUnitTest(const OsiSolverInterface * siP,
-					 const std::string mpdDir );
- 
-public:
-
-  /**@name Generate Cuts */
-  //@{
-  /** Generate zero half cuts for the model accessed through the solver interface. 
-  Insert generated cuts into the cut set cs.
-  */
-  virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
-			     const CglTreeInfo info = CglTreeInfo());
-  //@}
-
-  /**@name Sets and Gets */
-  //@{
-  /// Get flags
-  inline int getFlags() const
-  { return flags_;}
-  /// Set flags
-  inline void setFlags(int value)
-  { flags_ = value;}
-  //@}
-
-  /**@name Constructors and destructors */
-  //@{
-  /// Default constructor 
-  CglZeroHalf ();
- 
-  /// Copy constructor 
-  CglZeroHalf (
-    const CglZeroHalf &);
-
-  /// Clone
-  virtual CglCutGenerator * clone() const;
-
-  /// Assignment operator 
-  CglZeroHalf &
-    operator=(
-    const CglZeroHalf& rhs);
-  
-  /// Destructor 
-  virtual
-    ~CglZeroHalf ();
-  /// Create C++ lines to get to current state
-  virtual std::string generateCpp( FILE * fp);
-  /// This can be used to refresh any information
-  virtual void refreshSolver(OsiSolverInterface * solver);
-  //@}
-
-private:
-  
-  // Private member methods
-   
-  /**@name Private methods */
-  //@{
-  //@}
-  
-  
-  /**@name Private member data */
-  //@{
-  /// number of rows in the ILP matrix 
-  int mr_;
-  /// number of columns in the ILP matrix 
-  int mc_;
-  /// number of nonzero's in the ILP matrix 
-  int mnz_;
-  /// starting position of each row in arrays mtind and mtval 
-  int *mtbeg_;
-  /// number of entries of each row in arrays mtind and mtval 
-  int *mtcnt_;
-  /// column indices of the nonzero entries of the ILP matrix 
-  int *mtind_;
-  /// values of the nonzero entries of the ILP matrix 
-  int *mtval_;
-  /// lower bounds on the variables 
-  int *vlb_;
-  /// upper bounds on the variables 
-  int *vub_;
-  /// right hand sides of the constraints 
-  int *mrhs_;
-  /// senses of the constraints: 'L', 'G' or 'E' 
-  char *msense_;
-  /// Cgl012Cut object to make thread safe
-  Cgl012Cut cutInfo_;
-  /** Flags
-      1 bit - global cuts 
-  */
-  int flags_;
-  //@}
-};
-/// A simple Dijkstra shortest path - make better later
-#ifndef CGL_NEW_SHORT
-void cglShortestPath(cgl_graph * graph, int source, int maximumLength);
-#else
-void cglShortestPath(auxiliary_graph * graph, int source, int maximumLength);
-#endif
-//#############################################################################
-/** A function that tests the methods in the CglZeroHalf class. The
-    only reason for it not to be a member method is that this way it doesn't
-    have to be compiled into the library. And that's a gain, because the
-    library should be compiled with optimization on, but this method should be
-    compiled with debugging. */
-void CglZeroHalfUnitTest(const OsiSolverInterface * siP,
-			       const std::string mpdDir );
-  
-#endif

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

@@ -1,113 +0,0 @@
-/* $Id: ClpAmplObjective.hpp 1899 2013-04-09 18:12:08Z stefan $ */
-// Copyright (C) 2007, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef ClpAmplObjective_H
-#define ClpAmplObjective_H
-
-#include "ClpObjective.hpp"
-#include "CoinPackedMatrix.hpp"
-
-//#############################################################################
-
-/** Ampl Objective Class
-
-*/
-
-class ClpAmplObjective : public ClpObjective {
-
-public:
-
-    ///@name Stuff
-    //@{
-
-    /** Returns gradient.  If Ampl then solution may be NULL,
-        also returns an offset (to be added to current one)
-        If refresh is false then uses last solution
-        Uses model for scaling
-        includeLinear 0 - no, 1 as is, 2 as feasible
-    */
-    virtual double * gradient(const ClpSimplex * model,
-                              const double * solution, double & offset, bool refresh,
-                              int includeLinear = 2);
-    /// Resize objective
-    /** Returns reduced gradient.Returns an offset (to be added to current one).
-    */
-    virtual double reducedGradient(ClpSimplex * model, double * region,
-                                   bool useFeasibleCosts);
-    /** Returns step length which gives minimum of objective for
-        solution + theta * change vector up to maximum theta.
-
-        arrays are numberColumns+numberRows
-        Also sets current objective, predicted and at maximumTheta
-    */
-    virtual double stepLength(ClpSimplex * model,
-                              const double * solution,
-                              const double * change,
-                              double maximumTheta,
-                              double & currentObj,
-                              double & predictedObj,
-                              double & thetaObj);
-    /// Return objective value (without any ClpModel offset) (model may be NULL)
-    virtual double objectiveValue(const ClpSimplex * model, const double * solution) const ;
-    virtual void resize(int newNumberColumns) ;
-    /// Delete columns in  objective
-    virtual void deleteSome(int numberToDelete, const int * which) ;
-    /// Scale objective
-    virtual void reallyScale(const double * columnScale) ;
-    /** Given a zeroed array sets nonlinear columns to 1.
-        Returns number of nonlinear columns
-     */
-    virtual int markNonlinear(char * which);
-
-    /// Say we have new primal solution - so may need to recompute
-    virtual void newXValues() ;
-    //@}
-
-
-    ///@name Constructors and destructors
-    //@{
-    /// Default Constructor
-    ClpAmplObjective();
-
-    /// Constructor from ampl info
-    ClpAmplObjective(void * amplInfo);
-
-    /** Copy constructor .
-    */
-    ClpAmplObjective(const ClpAmplObjective & rhs);
-
-    /// Assignment operator
-    ClpAmplObjective & operator=(const ClpAmplObjective& rhs);
-
-    /// Destructor
-    virtual ~ClpAmplObjective ();
-
-    /// Clone
-    virtual ClpObjective * clone() const;
-
-    //@}
-    ///@name Gets and sets
-    //@{
-    /// Linear objective
-    double * linearObjective() const;
-    //@}
-
-    //---------------------------------------------------------------------------
-
-private:
-    ///@name Private member data
-    /// Saved offset
-    double offset_;
-    /// Ampl info
-    void * amplObjective_;
-    /// Objective
-    double * objective_;
-    /// Gradient
-    double * gradient_;
-    //@}
-};
-
-#endif
-

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

@@ -1,294 +0,0 @@
-/* $Id: ClpCholeskyBase.hpp 1722 2011-04-17 09:58:37Z stefan $ */
-// Copyright (C) 2003, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef ClpCholeskyBase_H
-#define ClpCholeskyBase_H
-
-#include "CoinPragma.hpp"
-#include "CoinTypes.hpp"
-//#define CLP_LONG_CHOLESKY 0
-#ifndef CLP_LONG_CHOLESKY
-#define CLP_LONG_CHOLESKY 0
-#endif
-/* valid combinations are
-   CLP_LONG_CHOLESKY 0 and COIN_LONG_WORK 0
-   CLP_LONG_CHOLESKY 1 and COIN_LONG_WORK 1
-   CLP_LONG_CHOLESKY 2 and COIN_LONG_WORK 1
-*/
-#if COIN_LONG_WORK==0
-#if CLP_LONG_CHOLESKY>0
-#define CHOLESKY_BAD_COMBINATION
-#endif
-#else
-#if CLP_LONG_CHOLESKY==0
-#define CHOLESKY_BAD_COMBINATION
-#endif
-#endif
-#ifdef CHOLESKY_BAD_COMBINATION
-#  warning("Bad combination of CLP_LONG_CHOLESKY and COIN_BIG_DOUBLE/COIN_LONG_WORK");
-"Bad combination of CLP_LONG_CHOLESKY and COIN_LONG_WORK"
-#endif
-#if CLP_LONG_CHOLESKY>1
-typedef long double longDouble;
-#define CHOL_SMALL_VALUE 1.0e-15
-#elif CLP_LONG_CHOLESKY==1
-typedef double longDouble;
-#define CHOL_SMALL_VALUE 1.0e-11
-#else
-typedef double longDouble;
-#define CHOL_SMALL_VALUE 1.0e-11
-#endif
-class ClpInterior;
-class ClpCholeskyDense;
-class ClpMatrixBase;
-
-/** Base class for Clp Cholesky factorization
-    Will do better factorization.  very crude ordering
-
-    Derived classes may be using more sophisticated methods
-*/
-
-class ClpCholeskyBase  {
-
-public:
-     /**@name Virtual methods that the derived classes may provide  */
-     //@{
-     /** Orders rows and saves pointer to matrix.and model.
-      returns non-zero if not enough memory.
-      You can use preOrder to set up ADAT
-      If using default symbolic etc then must set sizeFactor_ to
-      size of input matrix to order (and to symbolic).
-      Also just permute_ and permuteInverse_ should be created */
-     virtual int order(ClpInterior * model);
-     /** Does Symbolic factorization given permutation.
-         This is called immediately after order.  If user provides this then
-         user must provide factorize and solve.  Otherwise the default factorization is used
-         returns non-zero if not enough memory */
-     virtual int symbolic();
-     /** Factorize - filling in rowsDropped and returning number dropped.
-         If return code negative then out of memory */
-     virtual int factorize(const CoinWorkDouble * diagonal, int * rowsDropped) ;
-     /** Uses factorization to solve. */
-     virtual void solve (CoinWorkDouble * region) ;
-     /** Uses factorization to solve. - given as if KKT.
-      region1 is rows+columns, region2 is rows */
-     virtual void solveKKT (CoinWorkDouble * region1, CoinWorkDouble * region2, const CoinWorkDouble * diagonal,
-                            CoinWorkDouble diagonalScaleFactor);
-private:
-     /// AMD ordering
-     int orderAMD();
-public:
-     //@}
-
-     /**@name Gets */
-     //@{
-     /// status.  Returns status
-     inline int status() const {
-          return status_;
-     }
-     /// numberRowsDropped.  Number of rows gone
-     inline int numberRowsDropped() const {
-          return numberRowsDropped_;
-     }
-     /// reset numberRowsDropped and rowsDropped.
-     void resetRowsDropped();
-     /// rowsDropped - which rows are gone
-     inline char * rowsDropped() const {
-          return rowsDropped_;
-     }
-     /// choleskyCondition.
-     inline double choleskyCondition() const {
-          return choleskyCondition_;
-     }
-     /// goDense i.e. use dense factoriaztion if > this (default 0.7).
-     inline double goDense() const {
-          return goDense_;
-     }
-     /// goDense i.e. use dense factoriaztion if > this (default 0.7).
-     inline void setGoDense(double value) {
-          goDense_ = value;
-     }
-     /// rank.  Returns rank
-     inline int rank() const {
-          return numberRows_ - numberRowsDropped_;
-     }
-     /// Return number of rows
-     inline int numberRows() const {
-          return numberRows_;
-     }
-     /// Return size
-     inline CoinBigIndex size() const {
-          return sizeFactor_;
-     }
-     /// Return sparseFactor
-     inline longDouble * sparseFactor() const {
-          return sparseFactor_;
-     }
-     /// Return diagonal
-     inline longDouble * diagonal() const {
-          return diagonal_;
-     }
-     /// Return workDouble
-     inline longDouble * workDouble() const {
-          return workDouble_;
-     }
-     /// If KKT on
-     inline bool kkt() const {
-          return doKKT_;
-     }
-     /// Set KKT
-     inline void setKKT(bool yesNo) {
-          doKKT_ = yesNo;
-     }
-     /// Set integer parameter
-     inline void setIntegerParameter(int i, int value) {
-          integerParameters_[i] = value;
-     }
-     /// get integer parameter
-     inline int getIntegerParameter(int i) {
-          return integerParameters_[i];
-     }
-     /// Set double parameter
-     inline void setDoubleParameter(int i, double value) {
-          doubleParameters_[i] = value;
-     }
-     /// get double parameter
-     inline double getDoubleParameter(int i) {
-          return doubleParameters_[i];
-     }
-     //@}
-
-
-public:
-
-     /**@name Constructors, destructor
-      */
-     //@{
-     /** Constructor which has dense columns activated.
-         Default is off. */
-     ClpCholeskyBase(int denseThreshold = -1);
-     /** Destructor (has to be public) */
-     virtual ~ClpCholeskyBase();
-     /// Copy
-     ClpCholeskyBase(const ClpCholeskyBase&);
-     /// Assignment
-     ClpCholeskyBase& operator=(const ClpCholeskyBase&);
-     //@}
-     //@{
-     ///@name Other
-     /// Clone
-     virtual ClpCholeskyBase * clone() const;
-
-     /// Returns type
-     inline int type() const {
-          if (doKKT_) return 100;
-          else return type_;
-     }
-protected:
-     /// Sets type
-     inline void setType(int type) {
-          type_ = type;
-     }
-     /// model.
-     inline void setModel(ClpInterior * model) {
-          model_ = model;
-     }
-     //@}
-
-     /**@name Symbolic, factor and solve */
-     //@{
-     /** Symbolic1  - works out size without clever stuff.
-         Uses upper triangular as much easier.
-         Returns size
-      */
-     int symbolic1(const CoinBigIndex * Astart, const int * Arow);
-     /** Symbolic2  - Fills in indices
-         Uses lower triangular so can do cliques etc
-      */
-     void symbolic2(const CoinBigIndex * Astart, const int * Arow);
-     /** Factorize - filling in rowsDropped and returning number dropped
-         in integerParam.
-      */
-     void factorizePart2(int * rowsDropped) ;
-     /** solve - 1 just first half, 2 just second half - 3 both.
-     If 1 and 2 then diagonal has sqrt of inverse otherwise inverse
-     */
-     void solve(CoinWorkDouble * region, int type);
-     /// Forms ADAT - returns nonzero if not enough memory
-     int preOrder(bool lowerTriangular, bool includeDiagonal, bool doKKT);
-     /// Updates dense part (broken out for profiling)
-     void updateDense(longDouble * d, /*longDouble * work,*/ int * first);
-     //@}
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// type (may be useful) if > 20 do KKT
-     int type_;
-     /// Doing full KKT (only used if default symbolic and factorization)
-     bool doKKT_;
-     /// Go dense at this fraction
-     double goDense_;
-     /// choleskyCondition.
-     double choleskyCondition_;
-     /// model.
-     ClpInterior * model_;
-     /// numberTrials.  Number of trials before rejection
-     int numberTrials_;
-     /// numberRows.  Number of Rows in factorization
-     int numberRows_;
-     /// status.  Status of factorization
-     int status_;
-     /// rowsDropped
-     char * rowsDropped_;
-     /// permute inverse.
-     int * permuteInverse_;
-     /// main permute.
-     int * permute_;
-     /// numberRowsDropped.  Number of rows gone
-     int numberRowsDropped_;
-     /// sparseFactor.
-     longDouble * sparseFactor_;
-     /// choleskyStart - element starts
-     CoinBigIndex * choleskyStart_;
-     /// choleskyRow (can be shorter than sparsefactor)
-     int * choleskyRow_;
-     /// Index starts
-     CoinBigIndex * indexStart_;
-     /// Diagonal
-     longDouble * diagonal_;
-     /// double work array
-     longDouble * workDouble_;
-     /// link array
-     int * link_;
-     // Integer work array
-     CoinBigIndex * workInteger_;
-     // Clique information
-     int * clique_;
-     /// sizeFactor.
-     CoinBigIndex sizeFactor_;
-     /// Size of index array
-     CoinBigIndex sizeIndex_;
-     /// First dense row
-     int firstDense_;
-     /// integerParameters
-     int integerParameters_[64];
-     /// doubleParameters;
-     double doubleParameters_[64];
-     /// Row copy of matrix
-     ClpMatrixBase * rowCopy_;
-     /// Dense indicators
-     char * whichDense_;
-     /// Dense columns (updated)
-     longDouble * denseColumn_;
-     /// Dense cholesky
-     ClpCholeskyDense * dense_;
-     /// Dense threshold (for taking out of Cholesky)
-     int denseThreshold_;
-     //@}
-};
-
-#endif