ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,244 +0,0 @@
-/* $Id: ClpSimplexPrimal.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).
-/*
-   Authors
-
-   John Forrest
-
- */
-#ifndef ClpSimplexPrimal_H
-#define ClpSimplexPrimal_H
-
-#include "ClpSimplex.hpp"
-
-/** This solves LPs using the primal simplex method
-
-    It inherits from ClpSimplex.  It has no data of its own and
-    is never created - only cast from a ClpSimplex object at algorithm time.
-
-*/
-
-class ClpSimplexPrimal : public ClpSimplex {
-
-public:
-
-     /**@name Description of algorithm */
-     //@{
-     /** Primal algorithm
-
-         Method
-
-        It tries to be a single phase approach with a weight of 1.0 being
-        given to getting optimal and a weight of infeasibilityCost_ being
-        given to getting primal feasible.  In this version I have tried to
-        be clever in a stupid way.  The idea of fake bounds in dual
-        seems to work so the primal analogue would be that of getting
-        bounds on reduced costs (by a presolve approach) and using
-        these for being above or below feasible region.  I decided to waste
-        memory and keep these explicitly.  This allows for non-linear
-        costs!  I have not tested non-linear costs but will be glad
-        to do something if a reasonable example is provided.
-
-        The code is designed to take advantage of sparsity so arrays are
-        seldom zeroed out from scratch or gone over in their entirety.
-        The only exception is a full scan to find incoming variable for
-        Dantzig row choice.  For steepest edge we keep an updated list
-        of dual infeasibilities (actually squares).
-        On easy problems we don't need full scan - just
-        pick first reasonable.  This method has not been coded.
-
-        One problem is how to tackle degeneracy and accuracy.  At present
-        I am using the modification of costs which I put in OSL and which was
-        extended by Gill et al.  I am still not sure whether we will also
-        need explicit perturbation.
-
-        The flow of primal is three while loops as follows:
-
-        while (not finished) {
-
-          while (not clean solution) {
-
-             Factorize and/or clean up solution by changing bounds so
-         primal feasible.  If looks finished check fake primal bounds.
-         Repeat until status is iterating (-1) or finished (0,1,2)
-
-          }
-
-          while (status==-1) {
-
-            Iterate until no pivot in or out or time to re-factorize.
-
-            Flow is:
-
-            choose pivot column (incoming variable).  if none then
-        we are primal feasible so looks as if done but we need to
-        break and check bounds etc.
-
-        Get pivot column in tableau
-
-            Choose outgoing row.  If we don't find one then we look
-        primal unbounded so break and check bounds etc.  (Also the
-        pivot tolerance is larger after any iterations so that may be
-        reason)
-
-            If we do find outgoing row, we may have to adjust costs to
-        keep going forwards (anti-degeneracy).  Check pivot will be stable
-        and if unstable throw away iteration and break to re-factorize.
-        If minor error re-factorize after iteration.
-
-        Update everything (this may involve changing bounds on
-        variables to stay primal feasible.
-
-          }
-
-        }
-
-        TODO's (or maybe not)
-
-        At present we never check we are going forwards.  I overdid that in
-        OSL so will try and make a last resort.
-
-        Needs partial scan pivot in option.
-
-        May need other anti-degeneracy measures, especially if we try and use
-        loose tolerances as a way to solve in fewer iterations.
-
-        I like idea of dynamic scaling.  This gives opportunity to decouple
-        different implications of scaling for accuracy, iteration count and
-        feasibility tolerance.
-
-        for use of exotic parameter startFinishoptions see Clpsimplex.hpp
-     */
-
-     int primal(int ifValuesPass = 0, int startFinishOptions = 0);
-     //@}
-
-     /**@name For advanced users */
-     //@{
-     /// Do not change infeasibility cost and always say optimal
-     void alwaysOptimal(bool onOff);
-     bool alwaysOptimal() const;
-     /** Normally outgoing variables can go out to slightly negative
-         values (but within tolerance) - this is to help stability and
-         and degeneracy.  This can be switched off
-     */
-     void exactOutgoing(bool onOff);
-     bool exactOutgoing() const;
-     //@}
-
-     /**@name Functions used in primal */
-     //@{
-     /** This has the flow between re-factorizations
-
-         Returns a code to say where decision to exit was made
-         Problem status set to:
-
-         -2 re-factorize
-         -4 Looks optimal/infeasible
-         -5 Looks unbounded
-         +3 max iterations
-
-         valuesOption has original value of valuesPass
-      */
-     int whileIterating(int valuesOption);
-
-     /** Do last half of an iteration.  This is split out so people can
-         force incoming variable.  If solveType_ is 2 then this may
-         re-factorize while normally it would exit to re-factorize.
-         Return codes
-         Reasons to come out (normal mode/user mode):
-         -1 normal
-         -2 factorize now - good iteration/ NA
-         -3 slight inaccuracy - refactorize - iteration done/ same but factor done
-         -4 inaccuracy - refactorize - no iteration/ NA
-         -5 something flagged - go round again/ pivot not possible
-         +2 looks unbounded
-         +3 max iterations (iteration done)
-
-         With solveType_ ==2 this should
-         Pivot in a variable and choose an outgoing one.  Assumes primal
-         feasible - will not go through a bound.  Returns step length in theta
-         Returns ray in ray_
-     */
-     int pivotResult(int ifValuesPass = 0);
-
-
-     /** The primals are updated by the given array.
-         Returns number of infeasibilities.
-         After rowArray will have cost changes for use next iteration
-     */
-     int updatePrimalsInPrimal(CoinIndexedVector * rowArray,
-                               double theta,
-                               double & objectiveChange,
-                               int valuesPass);
-     /**
-         Row array has pivot column
-         This chooses pivot row.
-         Rhs array is used for distance to next bound (for speed)
-         For speed, we may need to go to a bucket approach when many
-         variables go through bounds
-         If valuesPass non-zero then compute dj for direction
-     */
-     void primalRow(CoinIndexedVector * rowArray,
-                    CoinIndexedVector * rhsArray,
-                    CoinIndexedVector * spareArray,
-                    int valuesPass);
-     /**
-         Chooses primal pivot column
-         updateArray has cost updates (also use pivotRow_ from last iteration)
-         Would be faster with separate region to scan
-         and will have this (with square of infeasibility) when steepest
-         For easy problems we can just choose one of the first columns we look at
-     */
-     void primalColumn(CoinIndexedVector * updateArray,
-                       CoinIndexedVector * spareRow1,
-                       CoinIndexedVector * spareRow2,
-                       CoinIndexedVector * spareColumn1,
-                       CoinIndexedVector * spareColumn2);
-
-     /** Checks if tentative optimal actually means unbounded in primal
-         Returns -3 if not, 2 if is unbounded */
-     int checkUnbounded(CoinIndexedVector * ray, CoinIndexedVector * spare,
-                        double changeCost);
-     /**  Refactorizes if necessary
-          Checks if finished.  Updates status.
-          lastCleaned refers to iteration at which some objective/feasibility
-          cleaning too place.
-
-          type - 0 initial so set up save arrays etc
-               - 1 normal -if good update save
-           - 2 restoring from saved
-          saveModel is normally NULL but may not be if doing Sprint
-     */
-     void statusOfProblemInPrimal(int & lastCleaned, int type,
-                                  ClpSimplexProgress * progress,
-                                  bool doFactorization,
-                                  int ifValuesPass,
-                                  ClpSimplex * saveModel = NULL);
-     /// Perturbs problem (method depends on perturbation())
-     void perturb(int type);
-     /// Take off effect of perturbation and say whether to try dual
-     bool unPerturb();
-     /// Unflag all variables and return number unflagged
-     int unflag();
-     /** Get next superbasic -1 if none,
-         Normal type is 1
-         If type is 3 then initializes sorted list
-         if 2 uses list.
-     */
-     int nextSuperBasic(int superBasicType, CoinIndexedVector * columnArray);
-
-     /// Create primal ray
-     void primalRay(CoinIndexedVector * rowArray);
-     /// Clears all bits and clears rowArray[1] etc
-     void clearAll();
-
-     /// Sort of lexicographic resolve
-     int lexSolve();
-
-     //@}
-};
-#endif
-

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

@@ -1,446 +0,0 @@
-/* $Id: ClpSolve.hpp 2078 2015-01-05 12:39:49Z forrest $ */
-// 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).
-/*
-   Authors
-
-   John Forrest
-
- */
-#ifndef ClpSolve_H
-#define ClpSolve_H
-
-/**
-    This is a very simple class to guide algorithms.  It is used to tidy up
-    passing parameters to initialSolve and maybe for output from that
-
-*/
-
-class ClpSolve  {
-
-public:
-
-     /** enums for solve function */
-     enum SolveType {
-          useDual = 0,
-          usePrimal,
-          usePrimalorSprint,
-          useBarrier,
-          useBarrierNoCross,
-          automatic,
-	  tryDantzigWolfe,
-	  tryBenders,
-          notImplemented
-     };
-     enum PresolveType {
-          presolveOn = 0,
-          presolveOff,
-          presolveNumber,
-          presolveNumberCost
-     };
-
-     /**@name Constructors and destructor and copy */
-     //@{
-     /// Default constructor
-     ClpSolve (  );
-     /// Constructor when you really know what you are doing
-     ClpSolve ( SolveType method, PresolveType presolveType,
-                int numberPasses, int options[6],
-                int extraInfo[6], int independentOptions[3]);
-     /// Generates code for above constructor
-     void generateCpp(FILE * fp);
-     /// Copy constructor.
-     ClpSolve(const ClpSolve &);
-     /// Assignment operator. This copies the data
-     ClpSolve & operator=(const ClpSolve & rhs);
-     /// Destructor
-     ~ClpSolve (  );
-     //@}
-
-     /**@name Functions most useful to user */
-     //@{
-     /** Special options - bits
-     0      4 - use crash (default allslack in dual, idiot in primal)
-         8 - all slack basis in primal
-     2      16 - switch off interrupt handling
-     3      32 - do not try and make plus minus one matrix
-         64 - do not use sprint even if problem looks good
-      */
-     /** which translation is:
-         which:
-         0 - startup in Dual  (nothing if basis exists).:
-                      0 - no basis
-       	   1 - crash
-       	   2 - use initiative about idiot! but no crash
-         1 - startup in Primal (nothing if basis exists):
-                      0 - use initiative
-       	   1 - use crash
-       	   2 - use idiot and look at further info
-       	   3 - use sprint and look at further info
-       	   4 - use all slack
-       	   5 - use initiative but no idiot
-       	   6 - use initiative but no sprint
-       	   7 - use initiative but no crash
-                      8 - do allslack or idiot
-                      9 - do allslack or sprint
-       	   10 - slp before
-       	   11 - no nothing and primal(0)
-         2 - interrupt handling - 0 yes, 1 no (for threadsafe)
-         3 - whether to make +- 1matrix - 0 yes, 1 no
-         4 - for barrier
-                      0 - dense cholesky
-       	   1 - Wssmp allowing some long columns
-       	   2 - Wssmp not allowing long columns
-       	   3 - Wssmp using KKT
-                      4 - Using Florida ordering
-       	   8 - bit set to do scaling
-       	   16 - set to be aggressive with gamma/delta?
-                      32 - Use KKT
-         5 - for presolve
-                      1 - switch off dual stuff
-         6 - extra switches
-                      
-     */
-     void setSpecialOption(int which, int value, int extraInfo = -1);
-     int getSpecialOption(int which) const;
-
-     /// Solve types
-     void setSolveType(SolveType method, int extraInfo = -1);
-     SolveType getSolveType();
-
-     // Presolve types
-     void setPresolveType(PresolveType amount, int extraInfo = -1);
-     PresolveType getPresolveType();
-     int getPresolvePasses() const;
-     /// Extra info for idiot (or sprint)
-     int getExtraInfo(int which) const;
-     /** Say to return at once if infeasible,
-         default is to solve */
-     void setInfeasibleReturn(bool trueFalse);
-     inline bool infeasibleReturn() const {
-          return independentOptions_[0] != 0;
-     }
-     /// Whether we want to do dual part of presolve
-     inline bool doDual() const {
-          return (independentOptions_[1] & 1) == 0;
-     }
-     inline void setDoDual(bool doDual_) {
-          if (doDual_) independentOptions_[1]  &= ~1;
-          else independentOptions_[1] |= 1;
-     }
-     /// Whether we want to do singleton part of presolve
-     inline bool doSingleton() const {
-          return (independentOptions_[1] & 2) == 0;
-     }
-     inline void setDoSingleton(bool doSingleton_) {
-          if (doSingleton_) independentOptions_[1]  &= ~2;
-          else independentOptions_[1] |= 2;
-     }
-     /// Whether we want to do doubleton part of presolve
-     inline bool doDoubleton() const {
-          return (independentOptions_[1] & 4) == 0;
-     }
-     inline void setDoDoubleton(bool doDoubleton_) {
-          if (doDoubleton_) independentOptions_[1]  &= ~4;
-          else independentOptions_[1] |= 4;
-     }
-     /// Whether we want to do tripleton part of presolve
-     inline bool doTripleton() const {
-          return (independentOptions_[1] & 8) == 0;
-     }
-     inline void setDoTripleton(bool doTripleton_) {
-          if (doTripleton_) independentOptions_[1]  &= ~8;
-          else independentOptions_[1] |= 8;
-     }
-     /// Whether we want to do tighten part of presolve
-     inline bool doTighten() const {
-          return (independentOptions_[1] & 16) == 0;
-     }
-     inline void setDoTighten(bool doTighten_) {
-          if (doTighten_) independentOptions_[1]  &= ~16;
-          else independentOptions_[1] |= 16;
-     }
-     /// Whether we want to do forcing part of presolve
-     inline bool doForcing() const {
-          return (independentOptions_[1] & 32) == 0;
-     }
-     inline void setDoForcing(bool doForcing_) {
-          if (doForcing_) independentOptions_[1]  &= ~32;
-          else independentOptions_[1] |= 32;
-     }
-     /// Whether we want to do impliedfree part of presolve
-     inline bool doImpliedFree() const {
-          return (independentOptions_[1] & 64) == 0;
-     }
-     inline void setDoImpliedFree(bool doImpliedfree) {
-          if (doImpliedfree) independentOptions_[1]  &= ~64;
-          else independentOptions_[1] |= 64;
-     }
-     /// Whether we want to do dupcol part of presolve
-     inline bool doDupcol() const {
-          return (independentOptions_[1] & 128) == 0;
-     }
-     inline void setDoDupcol(bool doDupcol_) {
-          if (doDupcol_) independentOptions_[1]  &= ~128;
-          else independentOptions_[1] |= 128;
-     }
-     /// Whether we want to do duprow part of presolve
-     inline bool doDuprow() const {
-          return (independentOptions_[1] & 256) == 0;
-     }
-     inline void setDoDuprow(bool doDuprow_) {
-          if (doDuprow_) independentOptions_[1]  &= ~256;
-          else independentOptions_[1] |= 256;
-     }
-     /// Whether we want to do singleton column part of presolve
-     inline bool doSingletonColumn() const {
-          return (independentOptions_[1] & 512) == 0;
-     }
-     inline void setDoSingletonColumn(bool doSingleton_) {
-          if (doSingleton_) independentOptions_[1]  &= ~512;
-          else independentOptions_[1] |= 512;
-     }
-     /// Whether we want to kill small substitutions
-     inline bool doKillSmall() const {
-          return (independentOptions_[1] & 8192) == 0;
-     }
-     inline void setDoKillSmall(bool doKill) {
-          if (doKill) independentOptions_[1]  &= ~8192;
-          else independentOptions_[1] |= 8192;
-     }
-     /// Set whole group
-     inline int presolveActions() const {
-          return independentOptions_[1] & 0xffff;
-     }
-     inline void setPresolveActions(int action) {
-          independentOptions_[1]  = (independentOptions_[1] & 0xffff0000) | (action & 0xffff);
-     }
-     /// Largest column for substitution (normally 3)
-     inline int substitution() const {
-          return independentOptions_[2];
-     }
-     inline void setSubstitution(int value) {
-          independentOptions_[2] = value;
-     }
-     inline void setIndependentOption(int type,int value) {
-          independentOptions_[type]  = value;
-     }
-     inline int independentOption(int type) const {
-          return independentOptions_[type];
-     }
-     //@}
-
-////////////////// data //////////////////
-private:
-
-     /**@name data.
-     */
-     //@{
-     /// Solve type
-     SolveType method_;
-     /// Presolve type
-     PresolveType presolveType_;
-     /// Amount of presolve
-     int numberPasses_;
-     /// Options - last is switch for OsiClp
-     int options_[7];
-     /// Extra information
-     int extraInfo_[7];
-     /** Extra algorithm dependent options
-         0 - if set return from clpsolve if infeasible
-         1 - To be copied over to presolve options
-         2 - max substitution level
-	 If Dantzig Wolfe/benders 0 is number blocks, 2 is #passes (notional)
-     */
-     int independentOptions_[3];
-     //@}
-};
-
-/// For saving extra information to see if looping.
-class ClpSimplexProgress {
-
-public:
-
-
-     /**@name Constructors and destructor and copy */
-     //@{
-     /// Default constructor
-     ClpSimplexProgress (  );
-
-     /// Constructor from model
-     ClpSimplexProgress ( ClpSimplex * model );
-
-     /// Copy constructor.
-     ClpSimplexProgress(const ClpSimplexProgress &);
-
-     /// Assignment operator. This copies the data
-     ClpSimplexProgress & operator=(const ClpSimplexProgress & rhs);
-     /// Destructor
-     ~ClpSimplexProgress (  );
-     /// Resets as much as possible
-     void reset();
-     /// Fill from model
-     void fillFromModel ( ClpSimplex * model );
-
-     //@}
-
-     /**@name Check progress */
-     //@{
-     /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
-         >=0 if give up and use as problem status
-     */
-     int looping (  );
-     /// Start check at beginning of whileIterating
-     void startCheck();
-     /// Returns cycle length in whileIterating
-     int cycle(int in, int out, int wayIn, int wayOut);
-
-     /// Returns previous objective (if -1) - current if (0)
-     double lastObjective(int back = 1) const;
-     /// Set real primal infeasibility and move back
-     void setInfeasibility(double value);
-     /// Returns real primal infeasibility (if -1) - current if (0)
-     double lastInfeasibility(int back = 1) const;
-     /// Returns number of primal infeasibilities (if -1) - current if (0)
-     int numberInfeasibilities(int back = 1) const;
-     /// Modify objective e.g. if dual infeasible in dual
-     void modifyObjective(double value);
-     /// Returns previous iteration number (if -1) - current if (0)
-     int lastIterationNumber(int back = 1) const;
-     /// clears all iteration numbers (to switch off panic)
-     void clearIterationNumbers();
-     /// Odd state
-     inline void newOddState() {
-          oddState_ = - oddState_ - 1;
-     }
-     inline void endOddState() {
-          oddState_ = abs(oddState_);
-     }
-     inline void clearOddState() {
-          oddState_ = 0;
-     }
-     inline int oddState() const {
-          return oddState_;
-     }
-     /// number of bad times
-     inline int badTimes() const {
-          return numberBadTimes_;
-     }
-     inline void clearBadTimes() {
-          numberBadTimes_ = 0;
-     }
-     /// number of really bad times
-     inline int reallyBadTimes() const {
-          return numberReallyBadTimes_;
-     }
-     inline void incrementReallyBadTimes() {
-          numberReallyBadTimes_++;
-     }
-     /// number of times flagged
-     inline int timesFlagged() const {
-          return numberTimesFlagged_;
-     }
-     inline void clearTimesFlagged() {
-          numberTimesFlagged_ = 0;
-     }
-     inline void incrementTimesFlagged() {
-          numberTimesFlagged_++;
-     }
-
-     //@}
-     /**@name Data  */
-#define CLP_PROGRESS 5
-     //#define CLP_PROGRESS_WEIGHT 10
-     //@{
-     /// Objective values
-     double objective_[CLP_PROGRESS];
-     /// Sum of infeasibilities for algorithm
-     double infeasibility_[CLP_PROGRESS];
-     /// Sum of real primal infeasibilities for primal
-     double realInfeasibility_[CLP_PROGRESS];
-#ifdef CLP_PROGRESS_WEIGHT
-     /// Objective values for weights
-     double objectiveWeight_[CLP_PROGRESS_WEIGHT];
-     /// Sum of infeasibilities for algorithm for weights
-     double infeasibilityWeight_[CLP_PROGRESS_WEIGHT];
-     /// Sum of real primal infeasibilities for primal for weights
-     double realInfeasibilityWeight_[CLP_PROGRESS_WEIGHT];
-     /// Drop  for weights
-     double drop_;
-     /// Best? for weights
-     double best_;
-#endif
-     /// Initial weight for weights
-     double initialWeight_;
-#define CLP_CYCLE 12
-     /// For cycle checking
-     //double obj_[CLP_CYCLE];
-     int in_[CLP_CYCLE];
-     int out_[CLP_CYCLE];
-     char way_[CLP_CYCLE];
-     /// Pointer back to model so we can get information
-     ClpSimplex * model_;
-     /// Number of infeasibilities
-     int numberInfeasibilities_[CLP_PROGRESS];
-     /// Iteration number at which occurred
-     int iterationNumber_[CLP_PROGRESS];
-#ifdef CLP_PROGRESS_WEIGHT
-     /// Number of infeasibilities for weights
-     int numberInfeasibilitiesWeight_[CLP_PROGRESS_WEIGHT];
-     /// Iteration number at which occurred for weights
-     int iterationNumberWeight_[CLP_PROGRESS_WEIGHT];
-#endif
-     /// Number of times checked (so won't stop too early)
-     int numberTimes_;
-     /// Number of times it looked like loop
-     int numberBadTimes_;
-     /// Number really bad times
-     int numberReallyBadTimes_;
-     /// Number of times no iterations as flagged
-     int numberTimesFlagged_;
-     /// If things are in an odd state
-     int oddState_;
-     //@}
-};
-
-#include "ClpConfig.h"
-#if CLP_HAS_ABC
-#include "AbcCommon.hpp"
-/// For saving extra information to see if looping.
-class AbcSimplexProgress : public ClpSimplexProgress {
-
-public:
-
-
-     /**@name Constructors and destructor and copy */
-     //@{
-     /// Default constructor
-     AbcSimplexProgress (  );
-
-     /// Constructor from model
-     AbcSimplexProgress ( ClpSimplex * model );
-
-     /// Copy constructor.
-     AbcSimplexProgress(const AbcSimplexProgress &);
-
-     /// Assignment operator. This copies the data
-     AbcSimplexProgress & operator=(const AbcSimplexProgress & rhs);
-     /// Destructor
-     ~AbcSimplexProgress (  );
-
-     //@}
-
-     /**@name Check progress */
-     //@{
-     /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
-         >=0 if give up and use as problem status
-     */
-     int looping (  );
-
-     //@}
-     /**@name Data  */
-     //@}
-};
-#endif
-#endif