casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/CoinPresolveMonitor.hpp

@@ -0,0 +1,105 @@
+
+#ifndef CoinPresolveMonitor_H
+#define CoinPresolveMonitor_H
+
+/*!
+  \brief Monitor a row or column for modification
+
+  The purpose of this class is to monitor a row or column for modifications
+  during presolve and postsolve. Each object can monitor one row or
+  column. The initial copy of the row or column is loaded by the constructor.
+  Each subsequent call to checkAndTell() compares the current state of the row
+  or column with the stored state and reports any modifications.
+
+  Internally the row or column is held as a CoinPackedVector so that it's
+  possible to follow a row or column through presolve (CoinPresolveMatrix)
+  and postsolve (CoinPostsolveMatrix).
+
+  Do not underestimate the amount of work required here. Extracting a row from
+  the CoinPostsolve matrix requires a scan of every element in the matrix.
+  That's one scan by the constructor and one scan with every call to modify.
+  But that's precisely why it's virtually impossible to debug presolve without
+  aids.
+
+  Parameter overloads for CoinPresolveMatrix and CoinPostsolveMatrix are a
+  little clumsy, but not a problem in use. The alternative is to add methods
+  to the CoinPresolveMatrix and CoinPostsolveMatrix classes that will only be
+  used for debugging. That's not too attractive either.
+*/
+class CoinPresolveMonitor {
+public:
+  /*! \brief Default constructor
+
+    Creates an empty monitor.
+  */
+  CoinPresolveMonitor();
+
+  /*! \brief Initialise from a CoinPresolveMatrix
+
+    Load the initial row or column from a CoinPresolveMatrix. Set \p isRow
+    true for a row, false for a column.
+  */
+  CoinPresolveMonitor(const CoinPresolveMatrix *mtx, bool isRow, int k);
+
+  /*! \brief Initialise from a CoinPostsolveMatrix
+
+    Load the initial row or column from a CoinPostsolveMatrix. Set \p isRow
+    true for a row, false for a column.
+  */
+  CoinPresolveMonitor(const CoinPostsolveMatrix *mtx, bool isRow, int k);
+
+  /*! \brief Compare the present row or column against the stored copy and
+  	     report differences.
+
+    Load the current row or column from a CoinPresolveMatrix and compare.
+    Differences are printed to std::cout.
+  */
+  void checkAndTell(const CoinPresolveMatrix *mtx);
+
+  /*! \brief Compare the present row or column against the stored copy and
+  	     report differences.
+
+    Load the current row or column from a CoinPostsolveMatrix and compare.
+    Differences are printed to std::cout.
+  */
+  void checkAndTell(const CoinPostsolveMatrix *mtx);
+
+private:
+  /// Extract a row from a CoinPresolveMatrix
+  CoinPackedVector *extractRow(int i, const CoinPresolveMatrix *mtx) const;
+
+  /// Extract a column from a CoinPresolveMatrix
+  CoinPackedVector *extractCol(int j, const CoinPresolveMatrix *mtx) const;
+
+  /// Extract a row from a CoinPostsolveMatrix
+  CoinPackedVector *extractRow(int i, const CoinPostsolveMatrix *mtx) const;
+
+  /// Extract a column from a CoinPostsolveMatrix
+  CoinPackedVector *extractCol(int j, const CoinPostsolveMatrix *mtx) const;
+
+  /// Worker method underlying the public checkAndTell methods.
+  void checkAndTell(CoinPackedVector *curVec, double lb, double ub);
+
+  /// True to monitor a row, false to monitor a column
+  bool isRow_;
+
+  /// Row or column index
+  int ndx_;
+
+  /*! The original row or column
+
+    Sorted in increasing order of indices.
+  */
+  CoinPackedVector *origVec_;
+
+  /// Original row or column lower bound
+  double lb_;
+
+  /// Original row or column upper bound
+  double ub_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinPresolvePsdebug.hpp

@@ -0,0 +1,169 @@
+/* $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).
+
+#ifndef CoinPresolvePsdebug_H
+#define CoinPresolvePsdebug_H
+
+/*
+  The current idea of the relation between PRESOLVE_DEBUG and
+  PRESOLVE_CONSISTENCY is that PRESOLVE_CONSISTENCY triggers the consistency
+  checks and PRESOLVE_DEBUG triggers consistency checks and output.
+  This isn't always true in the code, but that's the goal.  Really,
+  the whole compile-time scheme should be replaced with something more
+  user-friendly (control variables that can be changed during the run).
+
+  Also floating about are PRESOLVE_SUMMARY and COIN_PRESOLVE_TUNING.
+  -- lh, 111208 --
+*/
+/*! \defgroup PresolveDebugFunctions Presolve Debug Functions
+
+  These functions implement consistency checks on data structures involved
+  in presolve and postsolve and on the components of the lp solution.
+
+  To use these functions, include CoinPresolvePsdebug.hpp in your file and
+  define the compile-time constants PRESOLVE_SUMMARY, PRESOLVE_DEBUG, and
+  PRESOLVE_CONSISTENCY. A value is needed (<i>i.e.</i>, PRESOLVE_DEBUG=1).
+  In a few places, higher values will get you a bit more output.
+
+                        ********
+
+  Define the symbols PRESOLVE_DEBUG and PRESOLVE_CONSISTENCY on the configure
+  command line (use ADD_CXXFLAGS), in a Makefile, or similar and do a full
+  rebuild (including any presolve driver code). If the symbols are not
+  consistently nonzero across *all* presolve code, you'll get something
+  between garbage and a core dump! Debugging adds messages to CoinMessage
+  and allocates and maintains arrays that hold debug information.
+
+  That said, given that you've configured and built with PRESOLVE_DEBUG and
+  PRESOLVE_CONSISTENCY nonzero everywhere, it's safe to adjust PRESOLVE_DEBUG
+  to values in the range 1..n in individual files to increase or decrease the
+  amount of output.
+
+  The suggested approach for PRESOLVE_DEBUG is to define it to 1 in the build
+  and then increase it in individual presolve code files to get more detail.
+
+                        ********
+*/
+//@{
+
+/*! \relates CoinPresolveMatrix
+    \brief Check column-major and/or row-major matrices for duplicate
+	   entries in the major vectors.
+
+  By default, scans both the column- and row-major matrices. Set doCol (doRow)
+  to false to suppress the column (row) scan.
+*/
+void presolve_no_dups(const CoinPresolveMatrix *preObj,
+  bool doCol = true, bool doRow = true);
+
+/*! \relates CoinPresolveMatrix
+    \brief Check the links which track storage order for major vectors in
+    the bulk storage area.
+
+  By default, scans both the column- and row-major matrix. Set doCol = false to
+  suppress the column-major scan. Set doRow = false to suppres the row-major
+  scan. 
+*/
+void presolve_links_ok(const CoinPresolveMatrix *preObj,
+  bool doCol = true, bool doRow = true);
+
+/*! \relates CoinPresolveMatrix
+    \brief Check for explicit zeros in the column- and/or row-major matrices.
+
+  By default, scans both the column- and row-major matrices. Set doCol (doRow)
+  to false to suppress the column (row) scan.
+*/
+void presolve_no_zeros(const CoinPresolveMatrix *preObj,
+  bool doCol = true, bool doRow = true);
+
+/*! \relates CoinPresolveMatrix
+    \brief Checks for equivalence of the column- and row-major matrices.
+
+  Normally the routine will test for coefficient presence and value. Set
+  \p chkvals to false to suppress the check for equal value.
+*/
+void presolve_consistent(const CoinPresolveMatrix *preObj,
+  bool chkvals = true);
+
+/*! \relates CoinPostsolveMatrix
+    \brief Checks that column threads agree with column lengths
+*/
+void presolve_check_threads(const CoinPostsolveMatrix *obj);
+
+/*! \relates CoinPostsolveMatrix
+    \brief Checks the free list
+
+    Scans the thread of free locations in the bulk store and checks that all
+    entries are reasonable (0 <= index < bulk0_). If chkElemCnt is true, it
+    also checks that the total number of entries in the matrix plus the
+    locations on the free list total to the size of the bulk store. Postsolve
+    routines do not maintain an accurate element count, but this is useful
+    for checking a newly constructed postsolve matrix.
+*/
+void presolve_check_free_list(const CoinPostsolveMatrix *obj,
+  bool chkElemCnt = false);
+
+/*! \relates CoinPostsolveMatrix
+    \brief Check stored reduced costs for accuracy and consistency with
+	   variable status.
+
+  The routine will check the value of the reduced costs for architectural
+  variables (CoinPrePostsolveMatrix::rcosts_). It performs an accuracy check
+  by recalculating the reduced cost from scratch. It will also check the
+  value for consistency with the status information in
+  CoinPrePostsolveMatrix::colstat_.
+*/
+void presolve_check_reduced_costs(const CoinPostsolveMatrix *obj);
+
+/*! \relates CoinPostsolveMatrix
+    \brief Check the dual variables for consistency with row activity.
+
+  The routine checks that the value of the dual variable is consistent
+  with the state of the constraint (loose, tight at lower bound, or tight at
+  upper bound).
+*/
+void presolve_check_duals(const CoinPostsolveMatrix *postObj);
+
+/*! \relates CoinPresolveMatrix
+    \brief Check primal solution and architectural variable status.
+
+    The architectural variables can be checked for bogus values, feasibility,
+    and valid status. The row activity is checked for bogus values, accuracy,
+    and feasibility.  By default, row activity is not checked (presolve is
+    sloppy about maintaining it). See the definitions in
+    CoinPresolvePsdebug.cpp for more information.
+*/
+void presolve_check_sol(const CoinPresolveMatrix *preObj,
+  int chkColSol = 2, int chkRowAct = 1,
+  int chkStatus = 1);
+
+/*! \relates CoinPostsolveMatrix
+    \brief Check primal solution and architectural variable status.
+
+    The architectural variables can be checked for bogus values, feasibility,
+    and valid status. The row activity is checked for bogus values, accuracy,
+    and feasibility. See the definitions in CoinPresolvePsdebug.cpp for more
+    information.
+*/
+void presolve_check_sol(const CoinPostsolveMatrix *postObj,
+  int chkColSol = 2, int chkRowAct = 2,
+  int chkStatus = 1);
+
+/*! \relates CoinPresolveMatrix
+    \brief Check for the proper number of basic variables.
+*/
+void presolve_check_nbasic(const CoinPresolveMatrix *preObj);
+
+/*! \relates CoinPostsolveMatrix
+    \brief Check for the proper number of basic variables.
+*/
+void presolve_check_nbasic(const CoinPostsolveMatrix *postObj);
+
+//@}
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinPresolveSingleton.hpp

@@ -0,0 +1,115 @@
+/* $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).
+
+#ifndef CoinPresolveSingleton_H
+#define CoinPresolveSingleton_H
+#define SLACK_DOUBLETON 2
+#define SLACK_SINGLETON 8
+
+/*!
+  \file
+*/
+
+//const int MAX_SLACK_DOUBLETONS	= 1000;
+
+/*! \class slack_doubleton_action
+    \brief Convert an explicit bound constraint to a column bound
+
+  This transform looks for explicit bound constraints for a variable and
+  transfers the bound to the appropriate column bound array.
+  The constraint is removed from the constraint system.
+*/
+class slack_doubleton_action : public CoinPresolveAction {
+  struct action {
+    double clo;
+    double cup;
+
+    double rlo;
+    double rup;
+
+    double coeff;
+
+    int col;
+    int row;
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+  slack_doubleton_action(int nactions,
+    const action *actions,
+    const CoinPresolveAction *next)
+    : CoinPresolveAction(next)
+    , nactions_(nactions)
+    , actions_(actions)
+  {
+  }
+
+public:
+  const char *name() const { return ("slack_doubleton_action"); }
+
+  /*! \brief Convert explicit bound constraints to column bounds.
+  
+    Not now There is a hard limit (#MAX_SLACK_DOUBLETONS) on the number of
+    constraints processed in a given call. \p notFinished is set to true
+    if candidates remain.
+  */
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
+    const CoinPresolveAction *next,
+    bool &notFinished);
+
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  virtual ~slack_doubleton_action() { deleteAction(actions_, action *); }
+};
+/*! \class slack_singleton_action
+    \brief For variables with one entry
+
+    If we have a variable with one entry and no cost then we can
+    transform the row from E to G etc.
+    If there is a row objective region then we may be able to do
+    this even with a cost.
+*/
+class slack_singleton_action : public CoinPresolveAction {
+  struct action {
+    double clo;
+    double cup;
+
+    double rlo;
+    double rup;
+
+    double coeff;
+
+    int col;
+    int row;
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+  slack_singleton_action(int nactions,
+    const action *actions,
+    const CoinPresolveAction *next)
+    : CoinPresolveAction(next)
+    , nactions_(nactions)
+    , actions_(actions)
+  {
+  }
+
+public:
+  const char *name() const { return ("slack_singleton_action"); }
+
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
+    const CoinPresolveAction *next,
+    double *rowObjective);
+
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  virtual ~slack_singleton_action() { deleteAction(actions_, action *); }
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinPresolveSubst.hpp

@@ -0,0 +1,103 @@
+/* $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).
+
+#ifndef CoinPresolveSubst_H
+#define CoinPresolveSubst_H
+
+/*!
+  \file
+*/
+
+#define SUBST_ROW 21
+
+#include "CoinPresolveMatrix.hpp"
+
+/*! \class subst_constraint_action
+    \brief Detect and process implied free variables
+
+  Consider a variable x. Suppose that we can find an equality such that the
+  bound on the equality, combined with
+  the bounds on the other variables involved in the equality, are such that
+  even the worst case values of the other variables still imply bounds for x
+  which are tighter than the variable's original bounds. Since x can never
+  reach its upper or lower bounds, it is an implied free variable. By solving
+  the equality for x and substituting for x in every other constraint
+  entangled with x, we can make x into a column singleton. Now x is an implied
+  free column singleton and both x and the equality can be removed.
+
+  A similar transform for the case where the variable is a natural column
+  singleton is handled by #implied_free_action. In the current presolve
+  architecture, #implied_free_action is responsible for detecting implied free
+  variables that are natural column singletons or can be reduced to column
+  singletons. #implied_free_action calls subst_constraint_action to process
+  variables that must be reduced to column singletons.
+*/
+class subst_constraint_action : public CoinPresolveAction {
+private:
+  subst_constraint_action();
+  subst_constraint_action(const subst_constraint_action &rhs);
+  subst_constraint_action &operator=(const subst_constraint_action &rhs);
+
+  struct action {
+    double *rlos;
+    double *rups;
+
+    double *coeffxs;
+    int *rows;
+
+    int *ninrowxs;
+    int *rowcolsxs;
+    double *rowelsxs;
+
+    const double *costsx;
+    int col;
+    int rowy;
+
+    int nincol;
+  };
+
+  const int nactions_;
+  // actions_ is owned by the class and must be deleted at destruction
+  const action *const actions_;
+
+  subst_constraint_action(int nactions,
+    action *actions,
+    const CoinPresolveAction *next)
+    : CoinPresolveAction(next)
+    , nactions_(nactions)
+    , actions_(actions)
+  {
+  }
+
+public:
+  const char *name() const;
+
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
+    const int *implied_free,
+    const int *which,
+    int numberFree,
+    const CoinPresolveAction *next,
+    int fill_level);
+  static const CoinPresolveAction *presolveX(CoinPresolveMatrix *prob,
+    const CoinPresolveAction *next,
+    int fillLevel);
+
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  virtual ~subst_constraint_action();
+};
+
+/*static*/ void implied_bounds(const double *els,
+  const double *clo, const double *cup,
+  const int *hcol,
+  CoinBigIndex krs, CoinBigIndex kre,
+  double *maxupp, double *maxdownp,
+  int jcol,
+  double rlo, double rup,
+  double *iclb, double *icub);
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinPresolveTighten.hpp

@@ -0,0 +1,58 @@
+/* $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).
+
+#ifndef CoinPresolveTighten_H
+#define CoinPresolveTighten_H
+
+#include "CoinPresolveMatrix.hpp"
+
+// This action has no separate class;
+// instead, it decides which columns can be made fixed
+// and calls make_fixed_action::presolve.
+const CoinPresolveAction *tighten_zero_cost(CoinPresolveMatrix *prob,
+  const CoinPresolveAction *next);
+
+#define DO_TIGHTEN 30
+
+class do_tighten_action : public CoinPresolveAction {
+  do_tighten_action();
+  do_tighten_action(const do_tighten_action &rhs);
+  do_tighten_action &operator=(const do_tighten_action &rhs);
+
+  struct action {
+    int *rows;
+    double *lbound;
+    double *ubound;
+    int col;
+    int nrows;
+    int direction; // just for assertions
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+  do_tighten_action(int nactions,
+    const action *actions,
+    const CoinPresolveAction *next)
+    : CoinPresolveAction(next)
+    , nactions_(nactions)
+    , actions_(actions)
+  {
+  }
+
+public:
+  const char *name() const;
+
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
+    const CoinPresolveAction *next);
+
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  virtual ~do_tighten_action();
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinPresolveTripleton.hpp

@@ -0,0 +1,69 @@
+/* $Id$ */
+// 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).
+
+#ifndef CoinPresolveTripleton_H
+#define CoinPresolveTripleton_H
+#define TRIPLETON 11
+/** We are only going to do this if it does not increase number of elements?.
+    It could be generalized to more than three but it seems unlikely it would
+    help.
+
+    As it is adapted from doubleton icoly is one dropped.
+ */
+class tripleton_action : public CoinPresolveAction {
+public:
+  struct action {
+    int icolx;
+    int icolz;
+    int row;
+
+    int icoly;
+    double cloy;
+    double cupy;
+    double costy;
+    double clox;
+    double cupx;
+    double costx;
+
+    double rlo;
+    double rup;
+
+    double coeffx;
+    double coeffy;
+    double coeffz;
+
+    double *colel;
+
+    int ncolx;
+    int ncoly;
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+private:
+  tripleton_action(int nactions,
+    const action *actions,
+    const CoinPresolveAction *next)
+    : CoinPresolveAction(next)
+    , nactions_(nactions)
+    , actions_(actions)
+  {
+  }
+
+public:
+  const char *name() const { return ("tripleton_action"); }
+
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *,
+    const CoinPresolveAction *next);
+
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  virtual ~tripleton_action();
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/CoinPresolveUseless.hpp

@@ -0,0 +1,63 @@
+/* $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).
+
+#ifndef CoinPresolveUseless_H
+#define CoinPresolveUseless_H
+#define USELESS 20
+
+class useless_constraint_action : public CoinPresolveAction {
+  struct action {
+    double rlo;
+    double rup;
+    const int *rowcols;
+    const double *rowels;
+    int row;
+    int ninrow;
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+  useless_constraint_action(int nactions,
+    const action *actions,
+    const CoinPresolveAction *next);
+
+public:
+  const char *name() const;
+
+  // These rows are asserted to be useless,
+  // that is, given a solution the row activity
+  // must be in range.
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
+    const int *useless_rows,
+    int nuseless_rows,
+    const CoinPresolveAction *next);
+
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  virtual ~useless_constraint_action();
+};
+
+/*! \relates useless_constraint_action
+    \brief Scan constraints looking for useless constraints
+
+  A front end to identify useless constraints and hand them to
+  useless_constraint_action::presolve() for processing.
+
+  In a bit more detail, the routine implements a greedy algorithm that
+  identifies a set of necessary constraints. A constraint is necessary if it
+  implies a tighter bound on a variable than the original column bound. These
+  tighter column bounds are then used to calculate row activity and identify
+  constraints that are useless given the presence of the necessary
+  constraints. 
+*/
+
+const CoinPresolveAction *testRedundant(CoinPresolveMatrix *prob,
+  const CoinPresolveAction *next);
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/