casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/ClpSimplexOther.hpp

@@ -0,0 +1,282 @@
+/* $Id$ */
+// 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).
+/*
+   Authors
+
+   John Forrest
+
+ */
+#ifndef ClpSimplexOther_H
+#define ClpSimplexOther_H
+
+#include "ClpSimplex.hpp"
+
+/** This is for Simplex stuff which is neither dual nor primal
+
+    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 ClpSimplexOther : public ClpSimplex {
+
+public:
+  /**@name Methods */
+  //@{
+  /** Dual ranging.
+         This computes increase/decrease in cost for each given variable and corresponding
+         sequence numbers which would change basis.  Sequence numbers are 0..numberColumns
+         and numberColumns.. for artificials/slacks.
+         For non-basic variables the information is trivial to compute and the change in cost is just minus the
+         reduced cost and the sequence number will be that of the non-basic variables.
+         For basic variables a ratio test is between the reduced costs for non-basic variables
+         and the row of the tableau corresponding to the basic variable.
+         The increase/decrease value is always >= 0.0
+
+         Up to user to provide correct length arrays where each array is of length numberCheck.
+         which contains list of variables for which information is desired.  All other
+         arrays will be filled in by function.  If fifth entry in which is variable 7 then fifth entry in output arrays
+         will be information for variable 7.
+
+         If valueIncrease/Decrease not NULL (both must be NULL or both non NULL) then these are filled with
+         the value of variable if such a change in cost were made (the existing bounds are ignored)
+
+         When here - guaranteed optimal
+     */
+  void dualRanging(int numberCheck, const int *which,
+    double *costIncrease, int *sequenceIncrease,
+    double *costDecrease, int *sequenceDecrease,
+    double *valueIncrease = NULL, double *valueDecrease = NULL);
+  /** Primal ranging.
+         This computes increase/decrease in value for each given variable and corresponding
+         sequence numbers which would change basis.  Sequence numbers are 0..numberColumns
+         and numberColumns.. for artificials/slacks.
+         This should only be used for non-basic variabls as otherwise information is pretty useless
+         For basic variables the sequence number will be that of the basic variables.
+
+         Up to user to provide correct length arrays where each array is of length numberCheck.
+         which contains list of variables for which information is desired.  All other
+         arrays will be filled in by function.  If fifth entry in which is variable 7 then fifth entry in output arrays
+         will be information for variable 7.
+
+         When here - guaranteed optimal
+     */
+  void primalRanging(int numberCheck, const int *which,
+    double *valueIncrease, int *sequenceIncrease,
+    double *valueDecrease, int *sequenceDecrease);
+  /** Parametrics
+         This is an initial slow version.
+         The code uses current bounds + theta * change (if change array not NULL)
+         and similarly for objective.
+         It starts at startingTheta and returns ending theta in endingTheta.
+         If reportIncrement 0.0 it will report on any movement
+         If reportIncrement >0.0 it will report at startingTheta+k*reportIncrement.
+         If it can not reach input endingTheta return code will be 1 for infeasible,
+         2 for unbounded, if error on ranges -1,  otherwise 0.
+         Normal report is just theta and objective but
+         if event handler exists it may do more
+         On exit endingTheta is maximum reached (can be used for next startingTheta)
+     */
+  int parametrics(double startingTheta, double &endingTheta, double reportIncrement,
+    const double *changeLowerBound, const double *changeUpperBound,
+    const double *changeLowerRhs, const double *changeUpperRhs,
+    const double *changeObjective);
+  /** Version of parametrics which reads from file
+	 See CbcClpParam.cpp for details of format
+	 Returns -2 if unable to open file */
+  int parametrics(const char *dataFile);
+  /** Parametrics
+         This is an initial slow version.
+         The code uses current bounds + theta * change (if change array not NULL)
+         It starts at startingTheta and returns ending theta in endingTheta.
+         If it can not reach input endingTheta return code will be 1 for infeasible,
+         2 for unbounded, if error on ranges -1,  otherwise 0.
+         Event handler may do more
+         On exit endingTheta is maximum reached (can be used for next startingTheta)
+     */
+  int parametrics(double startingTheta, double &endingTheta,
+    const double *changeLowerBound, const double *changeUpperBound,
+    const double *changeLowerRhs, const double *changeUpperRhs);
+  int parametricsObj(double startingTheta, double &endingTheta,
+    const double *changeObjective);
+  /// Finds best possible pivot
+  double bestPivot(bool justColumns = false);
+  typedef struct {
+    double startingTheta;
+    double endingTheta;
+    double maxTheta;
+    double acceptableMaxTheta; // if this far then within tolerances
+    double *lowerChange; // full array of lower bound changes
+    int *lowerList; // list of lower bound changes
+    double *upperChange; // full array of upper bound changes
+    int *upperList; // list of upper bound changes
+    char *markDone; // mark which ones looked at
+    int *backwardBasic; // from sequence to pivot row
+    int *lowerActive;
+    double *lowerGap;
+    double *lowerCoefficient;
+    int *upperActive;
+    double *upperGap;
+    double *upperCoefficient;
+    int unscaledChangesOffset;
+    bool firstIteration; // so can update rhs for accuracy
+  } parametricsData;
+
+private:
+  /** Parametrics - inner loop
+         This first attempt is when reportIncrement non zero and may
+         not report endingTheta correctly
+         If it can not reach input endingTheta return code will be 1 for infeasible,
+         2 for unbounded,  otherwise 0.
+         Normal report is just theta and objective but
+         if event handler exists it may do more
+     */
+  int parametricsLoop(parametricsData &paramData, double reportIncrement,
+    const double *changeLower, const double *changeUpper,
+    const double *changeObjective, ClpDataSave &data,
+    bool canTryQuick);
+  int parametricsLoop(parametricsData &paramData,
+    ClpDataSave &data, bool canSkipFactorization = false);
+  int parametricsObjLoop(parametricsData &paramData,
+    ClpDataSave &data, bool canSkipFactorization = false);
+  /**  Refactorizes if necessary
+          Checks if finished.  Updates status.
+
+          type - 0 initial so set up save arrays etc
+               - 1 normal -if good update save
+           - 2 restoring from saved
+     */
+  void statusOfProblemInParametrics(int type, ClpDataSave &saveData);
+  void statusOfProblemInParametricsObj(int type, ClpDataSave &saveData);
+  /** This has the flow between re-factorizations
+
+         Reasons to come out:
+         -1 iterations etc
+         -2 inaccuracy
+         -3 slight inaccuracy (and done iterations)
+         +0 looks optimal (might be unbounded - but we will investigate)
+         +1 looks infeasible
+         +3 max iterations
+      */
+  int whileIterating(parametricsData &paramData, double reportIncrement,
+    const double *changeObjective);
+  /** Computes next theta and says if objective or bounds (0= bounds, 1 objective, -1 none).
+         theta is in theta_.
+         type 1 bounds, 2 objective, 3 both.
+     */
+  int nextTheta(int type, double maxTheta, parametricsData &paramData,
+    const double *changeObjective);
+  int whileIteratingObj(parametricsData &paramData);
+  int nextThetaObj(double maxTheta, parametricsData &paramData);
+  /// Restores bound to original bound
+  void originalBound(int iSequence, double theta, const double *changeLower,
+    const double *changeUpper);
+  /// Compute new rowLower_ etc (return negative if infeasible - otherwise largest change)
+  double computeRhsEtc(parametricsData &paramData);
+  /// Redo lower_ from rowLower_ etc
+  void redoInternalArrays();
+  /**
+         Row array has row part of pivot row
+         Column array has column part.
+         This is used in dual ranging
+     */
+  void checkDualRatios(CoinIndexedVector *rowArray,
+    CoinIndexedVector *columnArray,
+    double &costIncrease, int &sequenceIncrease, double &alphaIncrease,
+    double &costDecrease, int &sequenceDecrease, double &alphaDecrease);
+  /**
+         Row array has pivot column
+         This is used in primal ranging
+     */
+  void checkPrimalRatios(CoinIndexedVector *rowArray,
+    int direction);
+  /// Returns new value of whichOther when whichIn enters basis
+  double primalRanging1(int whichIn, int whichOther);
+
+public:
+  /** Write the basis in MPS format to the specified file.
+     If writeValues true writes values of structurals
+     (and adds VALUES to end of NAME card)
+
+     Row and column names may be null.
+     formatType is
+     <ul>
+       <li> 0 - normal
+       <li> 1 - extra accuracy
+       <li> 2 - IEEE hex (later)
+     </ul>
+
+     Returns non-zero on I/O error
+     */
+  int writeBasis(const char *filename,
+    bool writeValues = false,
+    int formatType = 0) const;
+  /// Read a basis from the given filename
+  int readBasis(const char *filename);
+  /** Creates dual of a problem if looks plausible
+         (defaults will always create model)
+         fractionRowRanges is fraction of rows allowed to have ranges
+         fractionColumnRanges is fraction of columns allowed to have ranges
+     */
+  ClpSimplex *dualOfModel(double fractionRowRanges = 1.0, double fractionColumnRanges = 1.0) const;
+  /** Restores solution from dualized problem
+         non-zero return code indicates minor problems
+     */
+  int restoreFromDual(const ClpSimplex *dualProblem,
+    bool checkAccuracy = false);
+  /** Sets solution in dualized problem
+         non-zero return code indicates minor problems
+     */
+  int setInDual(ClpSimplex *dualProblem);
+  /** Does very cursory presolve.
+         rhs is numberRows, whichRows is 3*numberRows and whichColumns is 2*numberColumns.
+     */
+  ClpSimplex *crunch(double *rhs, int *whichRows, int *whichColumns,
+    int &nBound, bool moreBounds = false, bool tightenBounds = false);
+  /** After very cursory presolve.
+         rhs is numberRows, whichRows is 3*numberRows and whichColumns is 2*numberColumns.
+     */
+  void afterCrunch(const ClpSimplex &small,
+    const int *whichRows, const int *whichColumns,
+    int nBound);
+  /** Returns gub version of model or NULL
+	 whichRows has to be numberRows
+	 whichColumns has to be numberRows+numberColumns */
+  ClpSimplex *gubVersion(int *whichRows, int *whichColumns,
+    int neededGub,
+    int factorizationFrequency = 50);
+  /// Sets basis from original
+  void setGubBasis(ClpSimplex &original, const int *whichRows,
+    const int *whichColumns);
+  /// Restores basis to original
+  void getGubBasis(ClpSimplex &original, const int *whichRows,
+    const int *whichColumns) const;
+  /// Quick try at cleaning up duals if postsolve gets wrong
+  void cleanupAfterPostsolve();
+  /** Tightens integer bounds - returns number tightened or -1 if infeasible
+     */
+  int tightenIntegerBounds(double *rhsSpace);
+  /** Expands out all possible combinations for a knapsack
+         If buildObj NULL then just computes space needed - returns number elements
+         On entry numberOutput is maximum allowed, on exit it is number needed or
+         -1 (as will be number elements) if maximum exceeded.  numberOutput will have at
+         least space to return values which reconstruct input.
+         Rows returned will be original rows but no entries will be returned for
+         any rows all of whose entries are in knapsack.  So up to user to allow for this.
+         If reConstruct >=0 then returns number of entrie which make up item "reConstruct"
+         in expanded knapsack.  Values in buildRow and buildElement;
+     */
+  int expandKnapsack(int knapsackRow, int &numberOutput,
+    double *buildObj, CoinBigIndex *buildStart,
+    int *buildRow, double *buildElement, int reConstruct = -1) const;
+  /// Create a string of commands to guess at best strategy for model
+  /// At present mode is ignored
+  char *guess(int mode) const;
+  //@}
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpSimplexPrimal.hpp

@@ -0,0 +1,244 @@
+/* $Id$ */
+// 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
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/