cbcintlinprog added

1 files changed, 0 insertions, 381 deletions

diff --git a/newstructure/thirdparty/linux/include/coin/ClpDynamicMatrix.hpp b/newstructure/thirdparty/linux/include/coin/ClpDynamicMatrix.hpp
deleted file mode 100644
index da4e144..0000000
--- a/newstructure/thirdparty/linux/include/coin/ClpDynamicMatrix.hpp
+++ /dev/null
@@ -1,381 +0,0 @@
-/* $Id: ClpDynamicMatrix.hpp 1755 2011-06-28 18:24:31Z lou $ */
-// 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 ClpDynamicMatrix_H
-#define ClpDynamicMatrix_H
-
-
-#include "CoinPragma.hpp"
-
-#include "ClpPackedMatrix.hpp"
-class ClpSimplex;
-/** This implements  a dynamic matrix when we have a limit on the number of
-    "interesting rows". This version inherits from ClpPackedMatrix and knows that
-    the real matrix is gub.  A later version could use shortest path to generate columns.
-
-*/
-
-class ClpDynamicMatrix : public ClpPackedMatrix {
-
-public:
-     /// enums for status of various sorts
-     enum DynamicStatus {
-          soloKey = 0x00,
-          inSmall = 0x01,
-          atUpperBound = 0x02,
-          atLowerBound = 0x03
-     };
-     /**@name Main functions provided */
-     //@{
-     /// Partial pricing
-     virtual void partialPricing(ClpSimplex * model, double start, double end,
-                                 int & bestSequence, int & numberWanted);
-
-     /**
-        update information for a pivot (and effective rhs)
-     */
-     virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
-     /** Returns effective RHS offset if it is being used.  This is used for long problems
-         or big dynamic or anywhere where going through full columns is
-         expensive.  This may re-compute */
-     virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
-                                bool check = false);
-
-     using ClpPackedMatrix::times ;
-     /** Return <code>y + A * scalar *x</code> in <code>y</code>.
-         @pre <code>x</code> must be of size <code>numColumns()</code>
-         @pre <code>y</code> must be of size <code>numRows()</code> */
-     virtual void times(double scalar,
-                        const double * x, double * y) const;
-     /// Modifies rhs offset
-     void modifyOffset(int sequence, double amount);
-     /// Gets key value when none in small
-     double keyValue(int iSet) const;
-     /**
-         mode=0  - Set up before "updateTranspose" and "transposeTimes" for duals using extended
-                   updates array (and may use other if dual values pass)
-         mode=1  - Update dual solution after "transposeTimes" using extended rows.
-         mode=2  - Compute all djs and compute key dual infeasibilities
-         mode=3  - Report on key dual infeasibilities
-         mode=4  - Modify before updateTranspose in partial pricing
-     */
-     virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
-                               double * other, int mode);
-     /**
-         mode=0  - Create list of non-key basics in pivotVariable_ using
-                   number as numberBasic in and out
-         mode=1  - Set all key variables as basic
-         mode=2  - return number extra rows needed, number gives maximum number basic
-         mode=3  - before replaceColumn
-         mode=4  - return 1 if can do primal, 2 if dual, 3 if both
-         mode=5  - save any status stuff (when in good state)
-         mode=6  - restore status stuff
-         mode=7  - flag given variable (normally sequenceIn)
-         mode=8  - unflag all variables
-         mode=9  - synchronize costs
-         mode=10  - return 1 if there may be changing bounds on variable (column generation)
-         mode=11  - make sure set is clean (used when a variable rejected - but not flagged)
-         mode=12  - after factorize but before permute stuff
-         mode=13  - at end of simplex to delete stuff
-     */
-     virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
-     /** Purely for column generation and similar ideas.  Allows
-         matrix and any bounds or costs to be updated (sensibly).
-         Returns non-zero if any changes.
-     */
-     virtual int refresh(ClpSimplex * model);
-     /** Creates a variable.  This is called after partial pricing and will modify matrix.
-         Will update bestSequence.
-     */
-     virtual void createVariable(ClpSimplex * model, int & bestSequence);
-     /// Returns reduced cost of a variable
-     virtual double reducedCost( ClpSimplex * model, int sequence) const;
-     /// Does gub crash
-     void gubCrash();
-     /// Writes out model (without names)
-     void writeMps(const char * name);
-     /// Populates initial matrix from dynamic status
-     void initialProblem();
-     /** Adds in a column to gub structure (called from descendant) and returns sequence */
-     int addColumn(int numberEntries, const int * row, const double * element,
-                   double cost, double lower, double upper, int iSet,
-                   DynamicStatus status);
-     /** If addColumn forces compression then this allows descendant to know what to do.
-         If >=0 then entry stayed in, if -1 then entry went out to lower bound.of zero.
-         Entries at upper bound (really nonzero) never go out (at present).
-     */
-     virtual void packDown(const int * , int ) {}
-     /// Gets lower bound (to simplify coding)
-     inline double columnLower(int sequence) const {
-          if (columnLower_) return columnLower_[sequence];
-          else return 0.0;
-     }
-     /// Gets upper bound (to simplify coding)
-     inline double columnUpper(int sequence) const {
-          if (columnUpper_) return columnUpper_[sequence];
-          else return COIN_DBL_MAX;
-     }
-
-     //@}
-
-
-
-     /**@name Constructors, destructor */
-     //@{
-     /** Default constructor. */
-     ClpDynamicMatrix();
-     /** This is the real constructor.
-         It assumes factorization frequency will not be changed.
-         This resizes model !!!!
-         The contents of original matrix in model will be taken over and original matrix
-         will be sanitized so can be deleted (to avoid a very small memory leak)
-      */
-     ClpDynamicMatrix(ClpSimplex * model, int numberSets,
-                      int numberColumns, const int * starts,
-                      const double * lower, const double * upper,
-                      const CoinBigIndex * startColumn, const int * row,
-                      const double * element, const double * cost,
-                      const double * columnLower = NULL, const double * columnUpper = NULL,
-                      const unsigned char * status = NULL,
-                      const unsigned char * dynamicStatus = NULL);
-
-     /** Destructor */
-     virtual ~ClpDynamicMatrix();
-     //@}
-
-     /**@name Copy method */
-     //@{
-     /** The copy constructor. */
-     ClpDynamicMatrix(const ClpDynamicMatrix&);
-     /** The copy constructor from an CoinPackedMatrix. */
-     ClpDynamicMatrix(const CoinPackedMatrix&);
-
-     ClpDynamicMatrix& operator=(const ClpDynamicMatrix&);
-     /// Clone
-     virtual ClpMatrixBase * clone() const ;
-     //@}
-     /**@name gets and sets */
-     //@{
-     /// Status of row slacks
-     inline ClpSimplex::Status getStatus(int sequence) const {
-          return static_cast<ClpSimplex::Status> (status_[sequence] & 7);
-     }
-     inline void setStatus(int sequence, ClpSimplex::Status status) {
-          unsigned char & st_byte = status_[sequence];
-          st_byte = static_cast<unsigned char>(st_byte & ~7);
-          st_byte = static_cast<unsigned char>(st_byte | status);
-     }
-     /// Whether flagged slack
-     inline bool flaggedSlack(int i) const {
-          return (status_[i] & 8) != 0;
-     }
-     inline void setFlaggedSlack(int i) {
-          status_[i] = static_cast<unsigned char>(status_[i] | 8);
-     }
-     inline void unsetFlaggedSlack(int i) {
-          status_[i] = static_cast<unsigned char>(status_[i] & ~8);
-     }
-     /// Number of sets (dynamic rows)
-     inline int numberSets() const {
-          return numberSets_;
-     }
-     /// Number of possible gub variables
-     inline int numberGubEntries() const
-     { return startSet_[numberSets_];}
-     /// Sets
-     inline int * startSets() const
-     { return startSet_;}
-     /// Whether flagged
-     inline bool flagged(int i) const {
-          return (dynamicStatus_[i] & 8) != 0;
-     }
-     inline void setFlagged(int i) {
-          dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] | 8);
-     }
-     inline void unsetFlagged(int i) {
-          dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] & ~8);
-     }
-     inline void setDynamicStatus(int sequence, DynamicStatus status) {
-          unsigned char & st_byte = dynamicStatus_[sequence];
-          st_byte = static_cast<unsigned char>(st_byte & ~7);
-          st_byte = static_cast<unsigned char>(st_byte | status);
-     }
-     inline DynamicStatus getDynamicStatus(int sequence) const {
-          return static_cast<DynamicStatus> (dynamicStatus_[sequence] & 7);
-     }
-     /// Saved value of objective offset
-     inline double objectiveOffset() const {
-          return objectiveOffset_;
-     }
-     /// Starts of each column
-     inline CoinBigIndex * startColumn() const {
-          return startColumn_;
-     }
-     /// rows
-     inline int * row() const {
-          return row_;
-     }
-     /// elements
-     inline double * element() const {
-          return element_;
-     }
-     /// costs
-     inline double * cost() const {
-          return cost_;
-     }
-     /// ids of active columns (just index here)
-     inline int * id() const {
-          return id_;
-     }
-     /// Optional lower bounds on columns
-     inline double * columnLower() const {
-          return columnLower_;
-     }
-     /// Optional upper bounds on columns
-     inline double * columnUpper() const {
-          return columnUpper_;
-     }
-     /// Lower bounds on sets
-     inline double * lowerSet() const {
-          return lowerSet_;
-     }
-     /// Upper bounds on sets
-     inline double * upperSet() const {
-          return upperSet_;
-     }
-     /// size
-     inline int numberGubColumns() const {
-          return numberGubColumns_;
-     }
-     /// first free
-     inline int firstAvailable() const {
-          return firstAvailable_;
-     }
-     /// first dynamic
-     inline int firstDynamic() const {
-          return firstDynamic_;
-     }
-     /// number of columns in dynamic model
-     inline int lastDynamic() const {
-          return lastDynamic_;
-     }
-     /// number of rows in original model
-     inline int numberStaticRows() const {
-          return numberStaticRows_;
-     }
-     /// size of working matrix (max)
-     inline int numberElements() const {
-          return numberElements_;
-     }
-     inline int * keyVariable() const {
-          return keyVariable_;
-     }
-     /// Switches off dj checking each factorization (for BIG models)
-     void switchOffCheck();
-     /// Status region for gub slacks
-     inline unsigned char * gubRowStatus() const {
-          return status_;
-     }
-     /// Status region for gub variables
-     inline unsigned char * dynamicStatus() const {
-          return dynamicStatus_;
-     }
-     /// Returns which set a variable is in
-     int whichSet (int sequence) const;
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /// Sum of dual infeasibilities
-     double sumDualInfeasibilities_;
-     /// Sum of primal infeasibilities
-     double sumPrimalInfeasibilities_;
-     /// Sum of Dual infeasibilities using tolerance based on error in duals
-     double sumOfRelaxedDualInfeasibilities_;
-     /// Sum of Primal infeasibilities using tolerance based on error in primals
-     double sumOfRelaxedPrimalInfeasibilities_;
-     /// Saved best dual on gub row in pricing
-     double savedBestGubDual_;
-     /// Saved best set in pricing
-     int savedBestSet_;
-     /// Backward pointer to pivot row !!!
-     int * backToPivotRow_;
-     /// Key variable of set (only accurate if none in small problem)
-     mutable int * keyVariable_;
-     /// Backward pointer to extra row
-     int * toIndex_;
-     // Reverse pointer from index to set
-     int * fromIndex_;
-     /// Number of sets (dynamic rows)
-     int numberSets_;
-     /// Number of active sets
-     int numberActiveSets_;
-     /// Saved value of objective offset
-     double objectiveOffset_;
-     /// Lower bounds on sets
-     double * lowerSet_;
-     /// Upper bounds on sets
-     double * upperSet_;
-     /// Status of slack on set
-     unsigned char * status_;
-     /// Pointer back to model
-     ClpSimplex * model_;
-     /// first free
-     int firstAvailable_;
-     /// first free when iteration started
-     int firstAvailableBefore_;
-     /// first dynamic
-     int firstDynamic_;
-     /// number of columns in dynamic model
-     int lastDynamic_;
-     /// number of rows in original model
-     int numberStaticRows_;
-     /// size of working matrix (max)
-     int numberElements_;
-     /// Number of dual infeasibilities
-     int numberDualInfeasibilities_;
-     /// Number of primal infeasibilities
-     int numberPrimalInfeasibilities_;
-     /** If pricing will declare victory (i.e. no check every factorization).
-         -1 - always check
-         0  - don't check
-         1  - in don't check mode but looks optimal
-     */
-     int noCheck_;
-     /// Infeasibility weight when last full pass done
-     double infeasibilityWeight_;
-     /// size
-     int numberGubColumns_;
-     /// current maximum number of columns (then compress)
-     int maximumGubColumns_;
-     /// current maximum number of elemnts (then compress)
-     int maximumElements_;
-     /// Start of each set
-     int * startSet_;
-     /// next in chain
-     int * next_;
-     /// Starts of each column
-     CoinBigIndex * startColumn_;
-     /// rows
-     int * row_;
-     /// elements
-     double * element_;
-     /// costs
-     double * cost_;
-     /// ids of active columns (just index here)
-     int * id_;
-     /// for status and which bound
-     unsigned char * dynamicStatus_;
-     /// Optional lower bounds on columns
-     double * columnLower_;
-     /// Optional upper bounds on columns
-     double * columnUpper_;
-     //@}
-};
-
-#endif