Structure updated and intqpipopt files added

1 files changed, 0 insertions, 524 deletions

diff --git a/build/Bonmin/include/coin/ClpMatrixBase.hpp b/build/Bonmin/include/coin/ClpMatrixBase.hpp
deleted file mode 100644
index 06dc523..0000000
--- a/build/Bonmin/include/coin/ClpMatrixBase.hpp
+++ /dev/null
@@ -1,524 +0,0 @@
-/* $Id: ClpMatrixBase.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 ClpMatrixBase_H
-#define ClpMatrixBase_H
-
-#include "CoinPragma.hpp"
-#include "CoinTypes.hpp"
-
-#include "CoinPackedMatrix.hpp"
-class CoinIndexedVector;
-class ClpSimplex;
-class ClpModel;
-// Compilers can produce better code if they know about __restrict
-#ifndef COIN_RESTRICT
-#ifdef COIN_USE_RESTRICT
-#define COIN_RESTRICT __restrict
-#else
-#define COIN_RESTRICT
-#endif
-#endif
-
-/** Abstract base class for Clp Matrices
-
-Since this class is abstract, no object of this type can be created.
-
-If a derived class provides all methods then all Clp algorithms
-should work.  Some can be very inefficient e.g. getElements etc is
-only used for tightening bounds for dual and the copies are
-deleted.  Many methods can just be dummy i.e. abort(); if not
-all features are being used.  So if column generation was being done
-then it makes no sense to do steepest edge so there would be
-no point providing subsetTransposeTimes.
-*/
-
-class ClpMatrixBase  {
-
-public:
-     /**@name Virtual methods that the derived classes must provide */
-     //@{
-     /// Return a complete CoinPackedMatrix
-     virtual CoinPackedMatrix * getPackedMatrix() const = 0;
-     /** Whether the packed matrix is column major ordered or not. */
-     virtual bool isColOrdered() const = 0;
-     /** Number of entries in the packed matrix. */
-     virtual CoinBigIndex getNumElements() const = 0;
-     /** Number of columns. */
-     virtual int getNumCols() const = 0;
-     /** Number of rows. */
-     virtual int getNumRows() const = 0;
-
-     /** A vector containing the elements in the packed matrix. Note that there
-         might be gaps in this list, entries that do not belong to any
-         major-dimension vector. To get the actual elements one should look at
-         this vector together with vectorStarts and vectorLengths. */
-     virtual const double * getElements() const = 0;
-     /** A vector containing the minor indices of the elements in the packed
-         matrix. Note that there might be gaps in this list, entries that do not
-         belong to any major-dimension vector. To get the actual elements one
-         should look at this vector together with vectorStarts and
-         vectorLengths. */
-     virtual const int * getIndices() const = 0;
-
-     virtual const CoinBigIndex * getVectorStarts() const = 0;
-     /** The lengths of the major-dimension vectors. */
-     virtual const int * getVectorLengths() const = 0 ;
-     /** The length of a single major-dimension vector. */
-     virtual int getVectorLength(int index) const ;
-     /** Delete the columns whose indices are listed in <code>indDel</code>. */
-     virtual void deleteCols(const int numDel, const int * indDel) = 0;
-     /** Delete the rows whose indices are listed in <code>indDel</code>. */
-     virtual void deleteRows(const int numDel, const int * indDel) = 0;
-#ifndef CLP_NO_VECTOR
-     /// Append Columns
-     virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
-     /// Append Rows
-     virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
-#endif
-     /** Modify one element of packed matrix.  An element may be added.
-         This works for either ordering If the new element is zero it will be
-         deleted unless keepZero true */
-     virtual void modifyCoefficient(int row, int column, double newElement,
-                                    bool keepZero = false);
-     /** Append a set of rows/columns to the end of the matrix. Returns number of errors
-         i.e. if any of the new rows/columns contain an index that's larger than the
-         number of columns-1/rows-1 (if numberOther>0) or duplicates
-         If 0 then rows, 1 if columns */
-     virtual int appendMatrix(int number, int type,
-                              const CoinBigIndex * starts, const int * index,
-                              const double * element, int numberOther = -1);
-
-     /** Returns a new matrix in reverse order without gaps
-         Is allowed to return NULL if doesn't want to have row copy */
-     virtual ClpMatrixBase * reverseOrderedCopy() const {
-          return NULL;
-     }
-
-     /// Returns number of elements in column part of basis
-     virtual CoinBigIndex countBasis(const int * whichColumn,
-                                     int & numberColumnBasic) = 0;
-     /// Fills in column part of basis
-     virtual void fillBasis(ClpSimplex * model,
-                            const int * whichColumn,
-                            int & numberColumnBasic,
-                            int * row, int * start,
-                            int * rowCount, int * columnCount,
-                            CoinFactorizationDouble * element) = 0;
-     /** Creates scales for column copy (rowCopy in model may be modified)
-         default does not allow scaling
-         returns non-zero if no scaling done */
-     virtual int scale(ClpModel * , const ClpSimplex * = NULL) const {
-          return 1;
-     }
-     /** Scales rowCopy if column copy scaled
-         Only called if scales already exist */
-     virtual void scaleRowCopy(ClpModel * ) const { }
-     /// Returns true if can create row copy
-     virtual bool canGetRowCopy() const {
-          return true;
-     }
-     /** Realy really scales column copy
-         Only called if scales already exist.
-         Up to user to delete */
-     inline virtual ClpMatrixBase * scaledColumnCopy(ClpModel * ) const {
-          return this->clone();
-     }
-
-     /** Checks if all elements are in valid range.  Can just
-         return true if you are not paranoid.  For Clp I will
-         probably expect no zeros.  Code can modify matrix to get rid of
-         small elements.
-         check bits (can be turned off to save time) :
-         1 - check if matrix has gaps
-         2 - check if zero elements
-         4 - check and compress duplicates
-         8 - report on large and small
-     */
-     virtual bool allElementsInRange(ClpModel * ,
-                                     double , double ,
-                                     int = 15) {
-          return true;
-     }
-     /** Set the dimensions of the matrix. In effect, append new empty
-         columns/rows to the matrix. A negative number for either dimension
-         means that that dimension doesn't change. Otherwise the new dimensions
-         MUST be at least as large as the current ones otherwise an exception
-         is thrown. */
-     virtual void setDimensions(int numrows, int numcols);
-     /** Returns largest and smallest elements of both signs.
-         Largest refers to largest absolute value.
-         If returns zeros then can't tell anything */
-     virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
-                                  double & smallestPositive, double & largestPositive);
-
-     /** Unpacks a column into an CoinIndexedvector
-      */
-     virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
-                         int column) const = 0;
-     /** Unpacks a column into an CoinIndexedvector
-      ** in packed format
-      Note that model is NOT const.  Bounds and objective could
-      be modified if doing column generation (just for this variable) */
-     virtual void unpackPacked(ClpSimplex * model,
-                               CoinIndexedVector * rowArray,
-                               int column) const = 0;
-     /** 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 * ) {
-          return 0;
-     }
-
-     // Really scale matrix
-     virtual void reallyScale(const double * rowScale, const double * columnScale);
-     /** Given positive integer weights for each row fills in sum of weights
-         for each column (and slack).
-         Returns weights vector
-         Default returns vector of ones
-     */
-     virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model, int * inputWeights) const;
-     /** Adds multiple of a column into an CoinIndexedvector
-         You can use quickAdd to add to vector */
-     virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
-                      int column, double multiplier) const = 0;
-     /** Adds multiple of a column into an array */
-     virtual void add(const ClpSimplex * model, double * array,
-                      int column, double multiplier) const = 0;
-     /// Allow any parts of a created CoinPackedMatrix to be deleted
-     virtual void releasePackedMatrix() const = 0;
-     /// Says whether it can do partial pricing
-     virtual bool canDoPartialPricing() const;
-     /// Returns number of hidden rows e.g. gub
-     virtual int hiddenRows() const;
-     /// Partial pricing
-     virtual void partialPricing(ClpSimplex * model, double start, double end,
-                                 int & bestSequence, int & numberWanted);
-     /** expands an updated column to allow for extra rows which the main
-         solver does not know about and returns number added.
-
-         This will normally be a no-op - it is in for GUB but may get extended to
-         general non-overlapping and embedded networks.
-
-         mode 0 - extend
-         mode 1 - delete etc
-     */
-     virtual int extendUpdated(ClpSimplex * model, CoinIndexedVector * update, int mode);
-     /**
-        utility primal function for dealing with dynamic constraints
-        mode=0  - Set up before "update" and "times" for primal solution using extended rows
-        mode=1  - Cleanup primal solution after "times" using extended rows.
-        mode=2  - Check (or report on) primal infeasibilities
-     */
-     virtual void primalExpanded(ClpSimplex * model, int mode);
-     /**
-         utility dual function for dealing with dynamic constraints
-         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);
-     /**
-         general utility function for dealing with dynamic constraints
-         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 and bounds
-         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);
-     /**
-        update information for a pivot (and effective rhs)
-     */
-     virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
-     /** Creates a variable.  This is called after partial pricing and may modify matrix.
-         May update bestSequence.
-     */
-     virtual void createVariable(ClpSimplex * model, int & bestSequence);
-     /** Just for debug if odd type matrix.
-         Returns number of primal infeasibilities. */
-     virtual int checkFeasible(ClpSimplex * model, double & sum) const ;
-     /// Returns reduced cost of a variable
-     double reducedCost(ClpSimplex * model, int sequence) const;
-     /// Correct sequence in and out to give true value (if both -1 maybe do whole matrix)
-     virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ;
-     //@}
-
-     //---------------------------------------------------------------------------
-     /**@name Matrix times vector methods
-        They can be faster if scalar is +- 1
-        Also for simplex I am not using basic/non-basic split */
-     //@{
-     /** Return <code>y + A * x * scalar</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 * COIN_RESTRICT x, double * COIN_RESTRICT y) const = 0;
-     /** And for scaling - default aborts for when scaling not supported
-         (unless pointers NULL when as normal)
-     */
-     virtual void times(double scalar,
-                        const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
-                        const double * COIN_RESTRICT rowScale,
-                        const double * COIN_RESTRICT columnScale) const;
-     /** Return <code>y + x * scalar * A</code> in <code>y</code>.
-         @pre <code>x</code> must be of size <code>numRows()</code>
-         @pre <code>y</code> must be of size <code>numColumns()</code> */
-     virtual void transposeTimes(double scalar,
-                                 const double * COIN_RESTRICT x, double * COIN_RESTRICT y) const = 0;
-     /** And for scaling - default aborts for when scaling not supported
-         (unless pointers NULL when as normal)
-     */
-     virtual void transposeTimes(double scalar,
-                                 const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
-                                 const double * COIN_RESTRICT rowScale,
-                                 const double * COIN_RESTRICT columnScale,
-                                 double * COIN_RESTRICT spare = NULL) const;
-#if COIN_LONG_WORK
-     // For long double versions (aborts if not supported)
-     virtual void times(CoinWorkDouble scalar,
-                        const CoinWorkDouble * COIN_RESTRICT x, CoinWorkDouble * COIN_RESTRICT y) const ;
-     virtual void transposeTimes(CoinWorkDouble scalar,
-                                 const CoinWorkDouble * COIN_RESTRICT x, CoinWorkDouble * COIN_RESTRICT y) const ;
-#endif
-     /** Return <code>x * scalar *A + y</code> in <code>z</code>.
-         Can use y as temporary array (will be empty at end)
-         Note - If x packed mode - then z packed mode
-         Squashes small elements and knows about ClpSimplex */
-     virtual void transposeTimes(const ClpSimplex * model, double scalar,
-                                 const CoinIndexedVector * x,
-                                 CoinIndexedVector * y,
-                                 CoinIndexedVector * z) const = 0;
-     /** Return <code>x *A</code> in <code>z</code> but
-         just for indices in y.
-         This is only needed for primal steepest edge.
-         Note - z always packed mode */
-     virtual void subsetTransposeTimes(const ClpSimplex * model,
-                                       const CoinIndexedVector * x,
-                                       const CoinIndexedVector * y,
-                                       CoinIndexedVector * z) const = 0;
-     /** Returns true if can combine transposeTimes and subsetTransposeTimes
-         and if it would be faster */
-     virtual bool canCombine(const ClpSimplex * ,
-                             const CoinIndexedVector * ) const {
-          return false;
-     }
-     /// Updates two arrays for steepest and does devex weights (need not be coded)
-     virtual void transposeTimes2(const ClpSimplex * model,
-                                  const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
-                                  const CoinIndexedVector * pi2,
-                                  CoinIndexedVector * spare,
-                                  double referenceIn, double devex,
-                                  // Array for exact devex to say what is in reference framework
-                                  unsigned int * reference,
-                                  double * weights, double scaleFactor);
-     /// Updates second array for steepest and does devex weights (need not be coded)
-     virtual void subsetTimes2(const ClpSimplex * model,
-                               CoinIndexedVector * dj1,
-                               const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
-                               double referenceIn, double devex,
-                               // Array for exact devex to say what is in reference framework
-                               unsigned int * reference,
-                               double * weights, double scaleFactor);
-     /** Return <code>x *A</code> in <code>z</code> but
-         just for number indices in y.
-         Default cheats with fake CoinIndexedVector and
-         then calls subsetTransposeTimes */
-     virtual void listTransposeTimes(const ClpSimplex * model,
-                                     double * x,
-                                     int * y,
-                                     int number,
-                                     double * z) const;
-     //@}
-     //@{
-     ///@name Other
-     /// Clone
-     virtual ClpMatrixBase * clone() const = 0;
-     /** Subset clone (without gaps).  Duplicates are allowed
-         and order is as given.
-         Derived classes need not provide this as it may not always make
-         sense */
-     virtual ClpMatrixBase * subsetClone (
-          int numberRows, const int * whichRows,
-          int numberColumns, const int * whichColumns) const;
-     /// Gets rid of any mutable by products
-     virtual void backToBasics() {}
-     /** Returns type.
-         The types which code may need to know about are:
-         1  - ClpPackedMatrix
-         11 - ClpNetworkMatrix
-         12 - ClpPlusMinusOneMatrix
-     */
-     inline int type() const {
-          return type_;
-     }
-     /// Sets type
-     void setType(int newtype) {
-          type_ = newtype;
-     }
-     /// Sets up an effective RHS
-     void useEffectiveRhs(ClpSimplex * model);
-     /** Returns effective RHS offset if it is being used.  This is used for long problems
-         or big gub or anywhere where going through full columns is
-         expensive.  This may re-compute */
-     virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
-                                bool check = false);
-     /// If rhsOffset used this is iteration last refreshed
-     inline int lastRefresh() const {
-          return lastRefresh_;
-     }
-     /// If rhsOffset used this is refresh frequency (0==off)
-     inline int refreshFrequency() const {
-          return refreshFrequency_;
-     }
-     inline void setRefreshFrequency(int value) {
-          refreshFrequency_ = value;
-     }
-     /// whether to skip dual checks most of time
-     inline bool skipDualCheck() const {
-          return skipDualCheck_;
-     }
-     inline void setSkipDualCheck(bool yes) {
-          skipDualCheck_ = yes;
-     }
-     /** Partial pricing tuning parameter - minimum number of "objects" to scan.
-         e.g. number of Gub sets but could be number of variables */
-     inline int minimumObjectsScan() const {
-          return minimumObjectsScan_;
-     }
-     inline void setMinimumObjectsScan(int value) {
-          minimumObjectsScan_ = value;
-     }
-     /// Partial pricing tuning parameter - minimum number of negative reduced costs to get
-     inline int minimumGoodReducedCosts() const {
-          return minimumGoodReducedCosts_;
-     }
-     inline void setMinimumGoodReducedCosts(int value) {
-          minimumGoodReducedCosts_ = value;
-     }
-     /// Current start of search space in matrix (as fraction)
-     inline double startFraction() const {
-          return startFraction_;
-     }
-     inline void setStartFraction(double value) {
-          startFraction_ = value;
-     }
-     /// Current end of search space in matrix (as fraction)
-     inline double endFraction() const {
-          return endFraction_;
-     }
-     inline void setEndFraction(double value) {
-          endFraction_ = value;
-     }
-     /// Current best reduced cost
-     inline double savedBestDj() const {
-          return savedBestDj_;
-     }
-     inline void setSavedBestDj(double value) {
-          savedBestDj_ = value;
-     }
-     /// Initial number of negative reduced costs wanted
-     inline int originalWanted() const {
-          return originalWanted_;
-     }
-     inline void setOriginalWanted(int value) {
-          originalWanted_ = value;
-     }
-     /// Current number of negative reduced costs which we still need
-     inline int currentWanted() const {
-          return currentWanted_;
-     }
-     inline void setCurrentWanted(int value) {
-          currentWanted_ = value;
-     }
-     /// Current best sequence
-     inline int savedBestSequence() const {
-          return savedBestSequence_;
-     }
-     inline void setSavedBestSequence(int value) {
-          savedBestSequence_ = value;
-     }
-     //@}
-
-
-protected:
-
-     /**@name Constructors, destructor<br>
-        <strong>NOTE</strong>: All constructors are protected. There's no need
-        to expose them, after all, this is an abstract class. */
-     //@{
-     /** Default constructor. */
-     ClpMatrixBase();
-     /** Destructor (has to be public) */
-public:
-     virtual ~ClpMatrixBase();
-protected:
-     // Copy
-     ClpMatrixBase(const ClpMatrixBase&);
-     // Assignment
-     ClpMatrixBase& operator=(const ClpMatrixBase&);
-     //@}
-
-
-protected:
-     /**@name Data members
-        The data members are protected to allow access for derived classes. */
-     //@{
-     /** Effective RHS offset if it is being used.  This is used for long problems
-         or big gub or anywhere where going through full columns is
-         expensive */
-     double * rhsOffset_;
-     /// Current start of search space in matrix (as fraction)
-     double startFraction_;
-     /// Current end of search space in matrix (as fraction)
-     double endFraction_;
-     /// Best reduced cost so far
-     double savedBestDj_;
-     /// Initial number of negative reduced costs wanted
-     int originalWanted_;
-     /// Current number of negative reduced costs which we still need
-     int currentWanted_;
-     /// Saved best sequence in pricing
-     int savedBestSequence_;
-     /// type (may be useful)
-     int type_;
-     /// If rhsOffset used this is iteration last refreshed
-     int lastRefresh_;
-     /// If rhsOffset used this is refresh frequency (0==off)
-     int refreshFrequency_;
-     /// Partial pricing tuning parameter - minimum number of "objects" to scan
-     int minimumObjectsScan_;
-     /// Partial pricing tuning parameter - minimum number of negative reduced costs to get
-     int minimumGoodReducedCosts_;
-     /// True sequence in (i.e. from larger problem)
-     int trueSequenceIn_;
-     /// True sequence out (i.e. from larger problem)
-     int trueSequenceOut_;
-     /// whether to skip dual checks most of time
-     bool skipDualCheck_;
-     //@}
-};
-// bias for free variables
-#define FREE_BIAS 1.0e1
-// Acceptance criteria for free variables
-#define FREE_ACCEPT 1.0e2
-
-#endif