ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,119 +0,0 @@
-/* $Id: ClpConstraintQuadratic.hpp 1665 2011-01-04 17:55:54Z lou $ */
-// 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 ClpConstraintQuadratic_H
-#define ClpConstraintQuadratic_H
-
-#include "ClpConstraint.hpp"
-
-//#############################################################################
-
-/** Quadratic Constraint Class
-
-*/
-
-class ClpConstraintQuadratic : public ClpConstraint {
-
-public:
-
-     ///@name Stuff
-     //@{
-
-
-     /** Fills gradient.  If Quadratic then solution may be NULL,
-         also returns true value of function and offset so we can use x not deltaX in constraint
-         If refresh is false then uses last solution
-         Uses model for scaling
-         Returns non-zero if gradient udefined at current solution
-     */
-     virtual int gradient(const ClpSimplex * model,
-                          const double * solution,
-                          double * gradient,
-                          double & functionValue ,
-                          double & offset,
-                          bool useScaling = false,
-                          bool refresh = true) const ;
-     /// Resize constraint
-     virtual void resize(int newNumberColumns) ;
-     /// Delete columns in  constraint
-     virtual void deleteSome(int numberToDelete, const int * which) ;
-     /// Scale constraint
-     virtual void reallyScale(const double * columnScale) ;
-     /** Given a zeroed array sets nonquadratic columns to 1.
-         Returns number of nonquadratic columns
-      */
-     virtual int markNonlinear(char * which) const ;
-     /** Given a zeroed array sets possible nonzero coefficients to 1.
-         Returns number of nonzeros
-      */
-     virtual int markNonzero(char * which) const;
-     //@}
-
-
-     ///@name Constructors and destructors
-     //@{
-     /// Default Constructor
-     ClpConstraintQuadratic();
-
-     /// Constructor from quadratic
-     ClpConstraintQuadratic(int row, int numberQuadraticColumns, int numberColumns,
-                            const CoinBigIndex * start,
-                            const int * column, const double * element);
-
-     /** Copy constructor .
-     */
-     ClpConstraintQuadratic(const ClpConstraintQuadratic & rhs);
-
-     /// Assignment operator
-     ClpConstraintQuadratic & operator=(const ClpConstraintQuadratic& rhs);
-
-     /// Destructor
-     virtual ~ClpConstraintQuadratic ();
-
-     /// Clone
-     virtual ClpConstraint * clone() const;
-     //@}
-     ///@name Gets and sets
-     //@{
-     /// Number of coefficients
-     virtual int numberCoefficients() const;
-     /// Number of columns in constraint
-     inline int numberColumns() const {
-          return numberColumns_;
-     }
-     /// Column starts
-     inline CoinBigIndex * start() const {
-          return start_;
-     }
-     /// Columns
-     inline const int * column() const {
-          return column_;
-     }
-     /// Coefficients
-     inline const double * coefficient() const {
-          return coefficient_;
-     }
-     //@}
-
-     //---------------------------------------------------------------------------
-
-private:
-     ///@name Private member data
-     /// Column starts
-     CoinBigIndex * start_;
-     /// Column (if -1 then linear coefficient)
-     int * column_;
-     /// Coefficients
-     double * coefficient_;
-     /// Useful to have number of columns about
-     int numberColumns_;
-     /// Number of coefficients in gradient
-     int numberCoefficients_;
-     /// Number of quadratic columns
-     int numberQuadraticColumns_;
-     //@}
-};
-
-#endif

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

@@ -1,71 +0,0 @@
-/* $Id: ClpDualRowDantzig.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 ClpDualRowDantzig_H
-#define ClpDualRowDantzig_H
-
-#include "ClpDualRowPivot.hpp"
-
-//#############################################################################
-
-/** Dual Row Pivot Dantzig Algorithm Class
-
-This is simplest choice - choose largest infeasibility
-
-*/
-
-class ClpDualRowDantzig : public ClpDualRowPivot {
-
-public:
-
-     ///@name Algorithmic methods
-     //@{
-
-     /// Returns pivot row, -1 if none
-     virtual int pivotRow();
-
-     /** Updates weights and returns pivot alpha.
-         Also does FT update */
-     virtual double updateWeights(CoinIndexedVector * input,
-                                  CoinIndexedVector * spare,
-                                  CoinIndexedVector * spare2,
-                                  CoinIndexedVector * updatedColumn);
-     /** Updates primal solution (and maybe list of candidates)
-         Uses input vector which it deletes
-         Computes change in objective function
-     */
-     virtual void updatePrimalSolution(CoinIndexedVector * input,
-                                       double theta,
-                                       double & changeInObjective);
-     //@}
-
-
-     ///@name Constructors and destructors
-     //@{
-     /// Default Constructor
-     ClpDualRowDantzig();
-
-     /// Copy constructor
-     ClpDualRowDantzig(const ClpDualRowDantzig &);
-
-     /// Assignment operator
-     ClpDualRowDantzig & operator=(const ClpDualRowDantzig& rhs);
-
-     /// Destructor
-     virtual ~ClpDualRowDantzig ();
-
-     /// Clone
-     virtual ClpDualRowPivot * clone(bool copyData = true) const;
-
-     //@}
-
-     //---------------------------------------------------------------------------
-
-private:
-     ///@name Private member data
-     //@}
-};
-
-#endif

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

@@ -1,129 +0,0 @@
-/* $Id: ClpDualRowPivot.hpp 2070 2014-11-18 11:12:54Z 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 ClpDualRowPivot_H
-#define ClpDualRowPivot_H
-
-class ClpSimplex;
-class CoinIndexedVector;
-
-//#############################################################################
-
-/** Dual Row Pivot Abstract Base Class
-
-Abstract Base Class for describing an interface to an algorithm
-to choose row pivot in dual simplex algorithm.  For some algorithms
-e.g. Dantzig choice then some functions may be null.
-
-*/
-
-class ClpDualRowPivot  {
-
-public:
-
-     ///@name Algorithmic methods
-     //@{
-
-     /// Returns pivot row, -1 if none
-     virtual int pivotRow() = 0;
-
-     /** Updates weights and returns pivot alpha.
-         Also does FT update */
-     virtual double updateWeights(CoinIndexedVector * input,
-                                  CoinIndexedVector * spare,
-                                  CoinIndexedVector * spare2,
-                                  CoinIndexedVector * updatedColumn) = 0;
-
-     /** Updates primal solution (and maybe list of candidates)
-         Uses input vector which it deletes
-         Computes change in objective function
-         Would be faster if we kept basic regions, but on other hand it
-         means everything is always in sync
-     */
-     /* FIXME: this was pure virtul (=0). Why? */
-     virtual void updatePrimalSolution(CoinIndexedVector * input,
-                                       double theta,
-                                       double & changeInObjective) = 0;
-     /** 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) for strong branching - initialize to 1 , infeasibilities
-	 6) scale back
-         7) for strong branching - initialize full weights , infeasibilities
-     */
-     virtual void saveWeights(ClpSimplex * model, int mode);
-     /// checks accuracy and may re-initialize (may be empty)
-     virtual void checkAccuracy();
-     /// Gets rid of last update (may be empty)
-     virtual void unrollWeights();
-     /// Gets rid of all arrays (may be empty)
-     virtual void clearArrays();
-     /// Returns true if would not find any row
-     virtual bool looksOptimal() const {
-          return false;
-     }
-     /// Called when maximum pivots changes
-     virtual void maximumPivotsChanged() {}
-     //@}
-
-
-     ///@name Constructors and destructors
-     //@{
-     /// Default Constructor
-     ClpDualRowPivot();
-
-     /// Copy constructor
-     ClpDualRowPivot(const ClpDualRowPivot &);
-
-     /// Assignment operator
-     ClpDualRowPivot & operator=(const ClpDualRowPivot& rhs);
-
-     /// Destructor
-     virtual ~ClpDualRowPivot ();
-
-     /// Clone
-     virtual ClpDualRowPivot * clone(bool copyData = true) const = 0;
-
-     //@}
-
-     ///@name Other
-     //@{
-     /// Returns model
-     inline ClpSimplex * model() {
-          return model_;
-     }
-
-     /// Sets model (normally to NULL)
-     inline void setModel(ClpSimplex * newmodel) {
-          model_ = newmodel;
-     }
-
-     /// Returns type (above 63 is extra information)
-     inline int type() {
-          return type_;
-     }
-
-     //@}
-
-     //---------------------------------------------------------------------------
-
-protected:
-     ///@name Protected member data
-     //@{
-     /// Pointer to model
-     ClpSimplex * model_;
-     /// Type of row pivot algorithm
-     int type_;
-     //@}
-};
-#ifndef CLP_DUAL_COLUMN_MULTIPLIER
-//#define CLP_DUAL_COLUMN_MULTIPLIER 0.99999
-#endif
-#endif

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

@@ -1,153 +0,0 @@
-/* $Id: ClpDualRowSteepest.hpp 2070 2014-11-18 11:12:54Z 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 ClpDualRowSteepest_H
-#define ClpDualRowSteepest_H
-
-#include "ClpDualRowPivot.hpp"
-class CoinIndexedVector;
-
-
-//#############################################################################
-
-/** Dual Row Pivot Steepest Edge Algorithm Class
-
-See Forrest-Goldfarb paper for algorithm
-
-*/
-
-class ClpDualRowSteepest : public ClpDualRowPivot {
-
-public:
-
-     ///@name Algorithmic methods
-     //@{
-
-     /// Returns pivot row, -1 if none
-     virtual int pivotRow();
-
-     /** Updates weights and returns pivot alpha.
-         Also does FT update */
-     virtual double updateWeights(CoinIndexedVector * input,
-                                  CoinIndexedVector * spare,
-                                  CoinIndexedVector * spare2,
-                                  CoinIndexedVector * updatedColumn);
-
-     /** Updates primal solution (and maybe list of candidates)
-         Uses input vector which it deletes
-         Computes change in objective function
-     */
-     virtual void updatePrimalSolution(CoinIndexedVector * input,
-                                       double theta,
-                                       double & changeInObjective);
-
-     /** Saves any weights round factorization as pivot rows may change
-         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) for strong branching - initialize (uninitialized) , infeasibilities
-     */
-     virtual void saveWeights(ClpSimplex * model, int mode);
-     /// Pass in saved weights
-     void passInSavedWeights(const CoinIndexedVector * saved);
-     /// Get saved weights
-     inline CoinIndexedVector * savedWeights()
-     { return savedWeights_;} 
-     /// Gets rid of last update
-     virtual void unrollWeights();
-     /// Gets rid of all arrays
-     virtual void clearArrays();
-     /// Returns true if would not find any row
-     virtual bool looksOptimal() const;
-     /// Called when maximum pivots changes
-     virtual void maximumPivotsChanged();
-     //@}
-
-     /** enums for persistence
-     */
-     enum Persistence {
-          normal = 0x00, // create (if necessary) and destroy
-          keep = 0x01 // create (if necessary) and leave
-     };
-
-     ///@name Constructors and destructors
-     //@{
-     /** Default Constructor
-         0 is uninitialized, 1 full, 2 is partial uninitialized,
-         3 starts as 2 but may switch to 1.
-         By partial is meant that the weights are updated as normal
-         but only part of the infeasible basic variables are scanned.
-         This can be faster on very easy problems.
-     */
-     ClpDualRowSteepest(int mode = 3);
-
-     /// Copy constructor
-     ClpDualRowSteepest(const ClpDualRowSteepest &);
-
-     /// Assignment operator
-     ClpDualRowSteepest & operator=(const ClpDualRowSteepest& rhs);
-
-     /// Fill most values
-     void fill(const ClpDualRowSteepest& rhs);
-
-     /// Destructor
-     virtual ~ClpDualRowSteepest ();
-
-     /// Clone
-     virtual ClpDualRowPivot * clone(bool copyData = true) const;
-
-     //@}
-     /**@name gets and sets */
-     //@{
-     /// Mode
-     inline int mode() const {
-          return mode_;
-     }
-     /// Set mode
-     inline void setMode(int mode) {
-          mode_ = mode;
-     }
-     /// Set/ get persistence
-     inline void setPersistence(Persistence life) {
-          persistence_ = life;
-     }
-     inline Persistence persistence() const {
-          return persistence_ ;
-     }
-//@}
-
-     //---------------------------------------------------------------------------
-
-private:
-     ///@name Private member data
-     /** Status
-         0) Normal
-         -1) Needs initialization
-         1) Weights are stored by sequence number
-     */
-     int state_;
-     /** If 0 then we are using uninitialized weights, 1 then full,
-         if 2 then uninitialized partial, 3 switchable */
-     int mode_;
-     /// Life of weights
-     Persistence persistence_;
-     /// weight array
-     double * weights_;
-     /// square of infeasibility array (just for infeasible rows)
-     CoinIndexedVector * infeasible_;
-     /// alternate weight array (so we can unroll)
-     CoinIndexedVector * alternateWeights_;
-     /// save weight array (so we can use checkpoint)
-     CoinIndexedVector * savedWeights_;
-     /// Dubious weights
-     int * dubiousWeights_;
-     //@}
-};
-
-#endif