casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CglLandP.hpp

@@ -0,0 +1,306 @@
+// Copyright (C) 2005-2009, Pierre Bonami and others.  All Rights Reserved.
+// Author:   Pierre Bonami
+//           Tepper School of Business
+//           Carnegie Mellon University, Pittsburgh, PA 15213
+// Date:     07/21/05
+//
+// $Id$
+//
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+//---------------------------------------------------------------------------
+#ifndef CglLandP_H
+#define CglLandP_H
+
+#include "CglLandPValidator.hpp"
+#include "CglCutGenerator.hpp"
+#include "CglParam.hpp"
+
+#include <iostream>
+class CoinWarmStartBasis;
+/** Performs one round of Lift & Project using CglLandPSimplex
+    to build cuts
+*/
+
+namespace LAP
+{
+enum LapMessagesTypes
+{
+    BEGIN_ROUND,
+    END_ROUND,
+    DURING_SEP,
+    CUT_REJECTED,
+    CUT_FAILED,
+    CUT_GAP,
+    LAP_CUT_FAILED_DO_MIG,
+    LAP_MESSAGES_DUMMY_END
+};
+/** Output messages for Cgl */
+class LapMessages : public CoinMessages
+{
+public:
+    /** Constructor */
+    LapMessages( );
+    /** destructor.*/
+    virtual ~LapMessages() {}
+};
+class CglLandPSimplex;
+}
+
+class CglLandP : public CglCutGenerator
+{
+    friend void CglLandPUnitTest(OsiSolverInterface *si, const std::string & mpsDir);
+
+    friend class LAP::CglLandPSimplex;
+    friend class CftCglp;
+
+public:
+
+    enum SelectionRules
+    {
+        mostNegativeRc /** select most negative reduced cost */,
+        bestPivot /** select best possible pivot.*/,
+        initialReducedCosts/** Select only those rows which had initialy a 0 reduced cost.*/
+    };
+
+    enum ExtraCutsMode
+    {
+        none/** Generate no extra cuts.*/,
+        AtOptimalBasis /** Generate cuts from the optimal basis.*/,
+        WhenEnteringBasis /** Generate cuts as soon as a structural enters the basis.*/,
+        AllViolatedMigs/** Generate all violated Mixed integer Gomory cuts in the course of the optimization.*/
+    };
+
+    /** Space where cuts are optimized.*/
+    enum SeparationSpaces
+    {
+        Fractional=0 /** True fractional space.*/,
+        Fractional_rc/** Use fractional space only for computing reduced costs.*/,
+        Full /** Work in full space.*/
+    };
+
+    /** Normalization */
+    enum Normalization
+    {
+        Unweighted = 0,
+        WeightRHS,
+        WeightLHS,
+        WeightBoth
+    };
+
+    enum LHSnorm
+    {
+        L1 = 0,
+        L2,
+        SupportSize,
+        Infinity,
+        Average,
+        Uniform
+    };
+    /** RHS weight in normalization.*/
+    enum RhsWeightType
+    {
+        Fixed = 0 /** 2*initial number of constraints. */,
+        Dynamic /** 2 * current number of constraints. */
+    };
+    /** Class storing parameters.
+        \remark I take all parameters from Ionut's code */
+    class Parameters : public CglParam
+    {
+    public:
+        /** Default constructor (with default values)*/
+        Parameters();
+        /** Copy constructor */
+        Parameters(const Parameters &other);
+        /** Assignment opertator */
+        Parameters & operator=(const Parameters &other);
+        /// @name integer parameters
+        ///@{
+
+        /** Max number of pivots before we generate the cut
+          \default 20 */
+        int pivotLimit;
+        /** Max number of pivots at regular nodes. Put a value if you want it lower than the global pivot limit.
+         \default 100.*/
+        int pivotLimitInTree;
+        /** Maximum number of cuts generated at a given round*/
+        int maxCutPerRound;
+        /** Maximum number of failed pivots before aborting */
+        int failedPivotLimit;
+        /** maximum number of consecutive degenerate pivots
+          \default 0 */
+        int degeneratePivotLimit;
+        /** Maximum number of extra rows to generate per round.*/
+        int extraCutsLimit;
+        ///@}
+        /// @name double parameters
+        ///@{
+        /** Tolerance for small pivots values (should be the same as the solver */
+        double pivotTol;
+        /** A variable have to be at least away from integrity to be generated */
+        double away;
+        /** Total time limit for cut generation.*/
+        double timeLimit;
+        /** Time limit for generating a single cut.*/
+        double singleCutTimeLimit;
+        /** Weight to put in RHS of normalization if static.*/
+        double rhsWeight;
+        ///@}
+
+        /// @name Flags
+        ///@{
+        /** Do we use tableau row or the disjunction (I don't really get that there should be a way to always use the tableau)*/
+        bool useTableauRow;
+        /** Do we apply Egon Balas's Heuristic for modularized cuts */
+        bool modularize;
+        /** Do we strengthen the final cut (always do if modularize is 1) */
+        bool strengthen;
+        /** Wether to limit or not the number of mistaken RC (when perturbation is applied).*/
+        bool countMistakenRc;
+        /** Work in the reduced space (only non-structurals enter the basis) */
+        SeparationSpaces sepSpace;
+        /** Apply perturbation procedure. */
+        bool perturb;
+        /** How to weight normalization.*/
+        Normalization normalization;
+        /** How to weight RHS of normalization.*/
+        RhsWeightType rhsWeightType;
+        /** How to weight LHS of normalization.*/
+        LHSnorm lhs_norm;
+        /** Generate extra constraints from optimal lift-and-project basis.*/
+        ExtraCutsMode generateExtraCuts;
+        /** Which rule to apply for choosing entering and leaving variables.*/
+        SelectionRules pivotSelection;
+        ///@}
+    };
+
+
+    /** Constructor for the class*/
+    CglLandP(const CglLandP::Parameters &params = CglLandP::Parameters(),
+             const LAP::Validator &validator = LAP::Validator());
+    /** Destructor */
+    ~CglLandP();
+    /** Copy constructor */
+    CglLandP(const CglLandP &source);
+    /** Assignment operator */
+    CglLandP& operator=(const CglLandP &rhs);
+    /** Clone function */
+    CglCutGenerator * clone() const;
+
+    /**@name Generate Cuts */
+    //@{
+
+    virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+                              const CglTreeInfo info = CglTreeInfo());
+
+    //@}
+
+    virtual bool needsOptimalBasis() const
+    {
+        return true;
+    }
+
+    LAP::Validator & validator()
+    {
+        return validator_;
+    }
+    /** set level of log for cut generation procedure :
+    <ol start=0 >
+    	<li> for none </li>
+    	<li> for log at begin and end of procedure + at some time interval </li>
+    	<li> for log at every cut generated </li>
+    	</ol>
+    	*/
+    void setLogLevel(int level)
+    {
+        handler_->setLogLevel(level);
+    }
+
+    class NoBasisError : public CoinError
+    {
+    public:
+        NoBasisError(): CoinError("No basis available","LandP","") {}
+    };
+
+    class SimplexInterfaceError : public CoinError
+    {
+    public:
+        SimplexInterfaceError(): CoinError("Invalid conversion to simplex interface", "CglLandP","CglLandP") {}
+    };
+    Parameters & parameter()
+    {
+        return params_;
+    }
+private:
+
+
+    void scanExtraCuts(OsiCuts& cs, const double * colsol) const;
+
+    Parameters params_;
+
+    /** Some informations that will be changed by the pivots and that we want to keep*/
+    struct CachedData
+    {
+        CachedData(int nBasics = 0 , int nNonBasics = 0);
+        CachedData(const CachedData & source);
+
+        CachedData& operator=(const CachedData &source);
+        /** Get the data from a problem */
+        void getData(const OsiSolverInterface &si);
+
+        void clean();
+
+        ~CachedData();
+        /** Indices of basic variables in starting basis (ordered if variable basics_[i] s basic in row i)*/
+        int * basics_;
+        /** Indices of non-basic variables */
+        int *nonBasics_;
+        /** number of basics variables */
+        int nBasics_;
+        /** number of non-basics */
+        int nNonBasics_;
+        /** Optimal basis */
+        CoinWarmStartBasis * basis_;
+        /** Stores the value of the solution to cut */
+        double * colsol_;
+        /** Stores the values of the slacks */
+        double * slacks_;
+        /** Stores wheter slacks are integer constrained */
+        bool * integers_;
+        /** Solver before pivots */
+        OsiSolverInterface * solver_;
+    };
+    /** Retrieve sorted integer variables which are fractional in the solution.
+        Return the number of variables.*/
+    int getSortedFractionals(CoinPackedVector &xFrac,
+                             const CachedData & data,
+                             const CglLandP::Parameters& params) const;
+    /** Retrieve sorted integer variables which are fractional in the solution.
+        Return the number of variables.*/
+    void getSortedFractionalIndices(std::vector<int>& indices,
+                                    const CachedData &data,
+                                    const CglLandP::Parameters & params) const;
+    /** Cached informations about problem.*/
+    CachedData cached_;
+    /** message handler */
+    CoinMessageHandler * handler_;
+    /** messages */
+    CoinMessages messages_;
+    /** cut validator */
+    LAP::Validator validator_;
+    /** number of rows in the original problems. */
+    int numrows_;
+    /** number of columns in the original problems. */
+    int numcols_;
+    /** Original lower bounds for the problem (for lifting cuts).*/
+    double * originalColLower_;
+    /** Original upper bounds for the problem (for lifting cuts).*/
+    double * originalColUpper_;
+    /** Flag to say if cuts can be lifted.*/
+    bool canLift_;
+    /** Store some extra cut which could be cheaply generated but do not cut current incumbent.*/
+    OsiCuts extraCuts_;
+};
+void CglLandPUnitTest(OsiSolverInterface *si, const std::string & mpsDir);
+
+#endif
+

casadi/include/coin/CglLandPValidator.hpp

@@ -0,0 +1,130 @@
+// Copyright (C) 2005-2009, Pierre Bonami and others.  All Rights Reserved.
+// Author:   Pierre Bonami
+//           Tepper School of Business
+//           Carnegie Mellon University, Pittsburgh, PA 15213
+// Date:     11/22/05
+//
+// $Id$
+//
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+//---------------------------------------------------------------------------
+
+#ifndef CglLandPValidator_H
+#define CglLandPValidator_H
+#include "OsiSolverInterface.hpp"
+#include "CglParam.hpp"
+#include <vector>
+
+/** constants describing rejection codes*/
+//[5] = {"Accepted", "violation too small", "small coefficient too small", "big dynamic","too dense"}
+
+
+namespace LAP
+{
+
+/** Class to validate or reject a cut */
+class Validator
+{
+public:
+    /** Reasons for rejecting a cut */
+    enum RejectionsReasons
+    {
+        NoneAccepted=0 /**Cut was accepted*/,
+        SmallViolation /** Violation of the cut is too small */,
+        SmallCoefficient /** There is a small coefficient we can not get rid off.*/,
+        BigDynamic /** Dynamic of coefficinet is too important. */,
+        DenseCut/**cut is too dense */,
+        EmptyCut/**After cleaning cut has become empty*/,
+        DummyEnd/** dummy*/
+    };
+
+    /** Constructor with default values */
+    Validator(double maxFillIn = 1.,
+              double maxRatio = 1e8,
+              double minViolation = 0,
+              bool scale = false,
+              double rhsScale = 1);
+
+    /** Clean an OsiCut */
+    int cleanCut(OsiRowCut & aCut, const double * solCut,const OsiSolverInterface &si, const CglParam & par,
+                 const double * colLower, const double * colUpper);
+    /** Clean an OsiCut by another method */
+    int cleanCut2(OsiRowCut & aCut, const double * solCut, const OsiSolverInterface &si, const CglParam & par,
+                  const double * colLower, const double * colUpper);
+    /** Call the cut cleaner */
+    int operator()(OsiRowCut & aCut, const double * solCut,const OsiSolverInterface &si, const CglParam & par,
+                   const double * colLower, const double * colUpper)
+    {
+        return cleanCut(aCut, solCut, si, par, colLower, colUpper);
+    }
+    /** @name set functions */
+    /** @{ */
+    void setMaxFillIn(double value)
+    {
+        maxFillIn_ = value;
+    }
+    void setMaxRatio(double value)
+    {
+        maxRatio_ = value;
+    }
+    void setMinViolation(double value)
+    {
+        minViolation_ = value;
+    }
+
+    void setRhsScale(double v)
+    {
+        rhsScale_ = v;
+    }
+    /** @} */
+    /** @name get functions */
+    /** @{ */
+    double getMaxFillIn()
+    {
+        return maxFillIn_;
+    }
+    double getMaxRatio()
+    {
+        return maxRatio_;
+    }
+    double getMinViolation()
+    {
+        return minViolation_;
+    }
+    /** @} */
+
+    const char* failureString(RejectionsReasons code) const
+    {
+        return rejections_[static_cast<int> (code)];
+    }
+    const char* failureString(int code) const
+    {
+        return rejections_[ code];
+    }
+    int numRejected(RejectionsReasons code)const
+    {
+        return numRejected_[static_cast<int> (code)];
+    }
+    int numRejected(int code)const
+    {
+        return numRejected_[ code];
+    }
+private:
+    /** max percentage of given formulation fillIn should be accepted for cut fillin.*/
+    double maxFillIn_;
+    /** max ratio between smallest and biggest coefficient */
+    double maxRatio_;
+    /** minimum violation for accepting a cut */
+    double minViolation_;
+    /** Do we do scaling? */
+    //bool scale_;
+    /** Scale of right-hand-side.*/
+    double rhsScale_;
+    /** Strings explaining reason for rejections */
+    static const char* rejections_[DummyEnd];
+    /** Number of cut rejected for each of the reasons.*/
+    std::vector<int> numRejected_;
+};
+
+}/* Ends namespace LAP.*/
+#endif

casadi/include/coin/CglLiftAndProject.hpp

@@ -0,0 +1,104 @@
+// Copyright (C) 2000, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglLiftAndProject_H
+#define CglLiftAndProject_H
+
+#include <string>
+
+#include "CglCutGenerator.hpp"
+
+/** Lift And Project Cut Generator Class */
+class CglLiftAndProject : public CglCutGenerator {
+   friend void CglLiftAndProjectUnitTest(const OsiSolverInterface * siP,
+					const std::string mpdDir );
+
+public:
+  /**@name Generate Cuts */
+  //@{
+  /** Generate lift-and-project cuts for the 
+      model of the solver interface, si. 
+      Insert the generated cuts into OsiCut, cs.
+  */
+  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+			    const CglTreeInfo info = CglTreeInfo());
+
+  /** Get the normalization : Either beta=+1 or beta=-1.
+  */
+
+  double getBeta() const {
+    return beta_;
+  }
+
+  /** Set the normalization : Either beta=+1 or beta=-1.
+      Default value is 1.
+  */
+  void setBeta(int oneOrMinusOne){
+    if (oneOrMinusOne==1 || oneOrMinusOne==-1){
+      beta_= static_cast<double>(oneOrMinusOne);
+    }
+    else {
+      throw CoinError("Unallowable value. Beta must be 1 or -1",
+		      "cutGeneration","CglLiftAndProject");
+    }
+  }
+
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor 
+  CglLiftAndProject ();
+ 
+  /// Copy constructor 
+  CglLiftAndProject (
+    const CglLiftAndProject &);
+
+  /// Clone
+  virtual CglCutGenerator * clone() const;
+
+  /// Assignment operator 
+  CglLiftAndProject &
+    operator=(
+    const CglLiftAndProject& rhs);
+  
+  /// Destructor 
+  virtual
+    ~CglLiftAndProject ();
+  /// Create C++ lines to get to current state
+  virtual std::string generateCpp( FILE * fp);
+  //@}
+
+private:
+  
+ // Private member methods
+
+  /**@name Private methods */
+  //@{
+
+  //@}
+
+  // Private member data
+
+  /**@name Private member data */
+  //@{
+  /// The normalization is beta_=1 or beta_=-1
+  double beta_;  
+  /// epsilon
+  double epsilon_;  
+  /// 1-epsilon
+  double onetol_;  
+  //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglLiftAndProject class. The
+    only reason for it not to be a member method is that this way it doesn't
+    have to be compiled into the library. And that's a gain, because the
+    library should be compiled with optimization on, but this method should be
+    compiled with debugging. */
+void CglLiftAndProjectUnitTest(const OsiSolverInterface * siP,
+			      const std::string mpdDir );
+  
+#endif

casadi/include/coin/CglMessage.hpp

@@ -0,0 +1,49 @@
+// $Id$
+// Copyright (C) 2005, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglMessage_H
+#define CglMessage_H
+
+#include "CoinPragma.hpp"
+
+// This deals with Cgl messages (as against Osi messages etc)
+
+#include "CoinMessageHandler.hpp"
+enum CGL_Message {
+  CGL_INFEASIBLE,
+  CGL_CLIQUES,
+  CGL_FIXED,
+  CGL_PROCESS_STATS,
+  CGL_SLACKS,
+  CGL_PROCESS_STATS2,
+  CGL_PROCESS_SOS1,
+  CGL_PROCESS_SOS2,
+  CGL_UNBOUNDED,
+  CGL_ELEMENTS_CHANGED1,
+  CGL_ELEMENTS_CHANGED2,
+  CGL_MADE_INTEGER,
+  CGL_ADDED_INTEGERS,
+  CGL_POST_INFEASIBLE,
+  CGL_POST_CHANGED,
+  CGL_GENERAL,
+  CGL_DUMMY_END
+};
+
+/** This deals with Cgl messages (as against Osi messages etc)
+ */
+class CglMessage : public CoinMessages {
+
+public:
+  /**@name Constructors etc */
+  //@{
+  /** Constructor */
+  CglMessage(Language language = us_en);
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/