ruby-cbc 0.1.9

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

@@ -0,0 +1,73 @@
+/* $Id: CoinPresolveDoubleton.hpp 1498 2011-11-02 15:25:35Z mjs $ */
+// 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 CoinPresolveDoubleton_H
+#define CoinPresolveDoubleton_H
+
+#define	DOUBLETON	5
+
+/*! \class doubleton_action
+    \brief Solve ax+by=c for y and substitute y out of the problem.
+
+  This moves the bounds information for y onto x, making y free and allowing
+  us to substitute it away.
+  \verbatim
+	   a x + b y = c
+	   l1 <= x <= u1
+	   l2 <= y <= u2	==>
+	  
+	   l2 <= (c - a x) / b <= u2
+	   b/-a > 0 ==> (b l2 - c) / -a <= x <= (b u2 - c) / -a
+	   b/-a < 0 ==> (b u2 - c) / -a <= x <= (b l2 - c) / -a
+  \endverbatim
+*/
+class doubleton_action : public CoinPresolveAction {
+ public:
+  struct action {
+
+    double clox;
+    double cupx;
+    double costx;
+    
+    double costy;
+
+    double rlo;
+
+    double coeffx;
+    double coeffy;
+
+    double *colel;
+
+    int icolx;
+    int icoly;
+    int row;
+    int ncolx;
+    int ncoly;
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+ private:
+  doubleton_action(int nactions,
+		      const action *actions,
+		      const CoinPresolveAction *next) :
+    CoinPresolveAction(next),
+    nactions_(nactions), actions_(actions)
+{}
+
+ public:
+  const char *name() const { return ("doubleton_action"); }
+
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *,
+					 const CoinPresolveAction *next);
+  
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  virtual ~doubleton_action();
+};
+#endif
+
+

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

@@ -0,0 +1,85 @@
+/* $Id: CoinPresolveDual.hpp 1510 2011-12-08 23:56:01Z 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).
+
+#ifndef CoinPresolveDual_H
+#define CoinPresolveDual_H
+
+/*! \class remove_dual_action
+    \brief Attempt to fix variables by bounding reduced costs
+
+  The reduced cost of x_j is d_j = c_j - y*a_j (1). Assume minimization,
+  so that at optimality d_j >= 0 for x_j nonbasic at lower bound, and
+  d_j <= 0 for x_j nonbasic at upper bound.
+ 
+  For a slack variable s_i, c_(n+i) = 0 and a_(n+i) is a unit vector, hence
+  d_(n+i) = -y_i. If s_i has a finite lower bound and no upper bound, we
+  must have y_i <= 0 at optimality. Similarly, if s_i has no lower bound and a
+  finite upper bound, we must have y_i >= 0.
+
+  For a singleton variable x_j, d_j = c_j - y_i*a_ij. Given x_j with a
+  single finite bound, we can bound d_j greater or less than 0 at
+  optimality, and that allows us to calculate an upper or lower bound on y_i
+  (depending on the bound on d_j and the sign of a_ij).
+
+  Now we have bounds on some subset of the y_i, and we can use these to
+  calculate upper and lower bounds on the d_j, using bound propagation on
+  (1). If we can manage to bound some d_j as strictly positive or strictly
+  negative, then at optimality the corresponding variable must be nonbasic
+  at its lower or upper bound, respectively. If the required bound is lacking,
+  the problem is unbounded.
+*/
+
+class remove_dual_action : public CoinPresolveAction {
+
+  public:
+
+  /// Destructor
+  ~remove_dual_action () ;
+
+  /// Name
+  inline const char *name () const { return ("remove_dual_action") ; }
+
+  /*! \brief Attempt to fix variables by bounding reduced costs
+
+    Always scans all variables. Propagates bounds on reduced costs until there's
+    no change or until some set of variables can be fixed.
+  */
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
+					    const CoinPresolveAction *next) ;
+
+  /*! \brief Postsolve
+
+    In addition to fixing variables (handled by make_fixed_action), we may
+    need use our own postsolve to restore constraint bounds.
+  */
+  void postsolve (CoinPostsolveMatrix *prob) const ;
+
+  private:
+
+  /// Postsolve (bound restore) instruction
+  struct action {
+    double rlo_ ;  ///< restored row lower bound
+    double rup_ ;  ///< restored row upper bound
+    int ndx_ ;     ///< row index
+  } ;
+
+  /// Constructor with postsolve actions.
+  remove_dual_action(int nactions, const action *actions,
+		     const CoinPresolveAction *next)
+    : CoinPresolveAction(next),
+      nactions_(nactions),
+      actions_(actions)
+  {}
+
+  /// Count of bound restore entries
+  const int nactions_ ;
+  /// Bound restore entries
+  const action *actions_ ;
+
+} ;
+#endif
+
+

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

@@ -0,0 +1,226 @@
+/* $Id: CoinPresolveDupcol.hpp 1817 2015-03-22 16:43:28Z 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 CoinPresolveDupcol_H
+#define CoinPresolveDupcol_H
+
+#include "CoinPresolveMatrix.hpp"
+
+/*!
+  \file
+*/
+
+#define	DUPCOL	10
+
+/*! \class dupcol_action
+    \brief Detect and remove duplicate columns
+
+    The general technique is to sum the coefficients a_(*,j) of each column.
+    Columns with identical sums are duplicates. The obvious problem is that,
+    <i>e.g.</i>, [1 0 1 0] and [0 1 0 1] both add to 2. To minimize the
+    chances of false positives, the coefficients of each row are multipled by
+    a random number r_i, so that we sum r_i*a_ij.
+
+   Candidate columns are checked to confirm they are identical. Where the
+   columns have the same objective coefficient, the two are combined. If the
+   columns have different objective coefficients, complications ensue. In order
+   to remove the duplicate, it must be possible to fix the variable at a bound.
+*/
+
+class dupcol_action : public CoinPresolveAction {
+  dupcol_action();
+  dupcol_action(const dupcol_action& rhs);
+  dupcol_action& operator=(const dupcol_action& rhs);
+
+  struct action {
+    double thislo;
+    double thisup;
+    double lastlo;
+    double lastup;
+    int ithis;
+    int ilast;
+
+    double *colels;
+    int nincol;
+  };
+
+  const int nactions_;
+  // actions_ is owned by the class and must be deleted at destruction
+  const action *const actions_;
+
+  dupcol_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 ~dupcol_action();
+
+};
+
+
+/*! \class duprow_action
+    \brief Detect and remove duplicate rows
+
+    The algorithm to detect duplicate rows is as outlined for dupcol_action.
+
+    If the feasible interval for one constraint is strictly contained in the
+    other, the tighter (contained) constraint is kept. If the feasible
+    intervals are disjoint, the problem is infeasible. If the feasible
+    intervals overlap, both constraints are kept.
+
+    duprow_action is definitely a work in progress; #postsolve is
+    unimplemented.
+    This doesn't matter as it uses useless_constraint.
+*/
+
+class duprow_action : public CoinPresolveAction {
+  struct action {
+    int row;
+    double lbound;
+    double ubound;
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+  duprow_action():CoinPresolveAction(NULL),nactions_(0),actions_(NULL) {}
+  duprow_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;
+
+  //~duprow_action() { delete[]actions_; }
+};
+
+class duprow3_action : public CoinPresolveAction {
+  struct action {
+    int row;
+    double lbound;
+    double ubound;
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+  duprow3_action():CoinPresolveAction(NULL),nactions_(0),actions_(NULL) {}
+  duprow3_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;
+
+  //~duprow_action() { delete[]actions_; }
+};
+
+/*! \class gubrow_action
+    \brief Detect and remove entries whose sum is known
+
+    If we have an equality row where all entries same then
+    For other rows where all entries for that equality row are same
+    then we can delete entries and modify rhs
+    gubrow_action is definitely a work in progress; #postsolve is
+    unimplemented.
+*/
+
+class gubrow_action : public CoinPresolveAction {
+  struct action {
+    int row;
+    double lbound;
+    double ubound;
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+  gubrow_action():CoinPresolveAction(NULL),nactions_(0),actions_(NULL) {}
+  gubrow_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;
+
+  //~gubrow_action() { delete[]actions_; }
+};
+
+/*! \class twoxtwo_action
+    \brief Detect interesting 2 by 2 blocks
+
+    If a variable has two entries and for each row there are only
+    two entries with same other variable then we can get rid of 
+    one constraint and modify costs.
+
+    This is a work in progress - I need more examples
+*/
+
+class twoxtwo_action : public CoinPresolveAction {
+  struct action {
+    double lbound_row;
+    double ubound_row;
+    double lbound_col;
+    double ubound_col;
+    double cost_col;
+    double cost_othercol;
+    int row;
+    int col;
+    int othercol;
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+  twoxtwo_action():CoinPresolveAction(NULL),nactions_(0),actions_(NULL) {}
+  twoxtwo_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;
+
+  ~twoxtwo_action() { delete [] actions_; }
+};
+
+#endif
+

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

@@ -0,0 +1,116 @@
+/* $Id: CoinPresolveEmpty.hpp 1561 2012-11-24 00:32:16Z 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).
+
+#ifndef CoinPresolveEmpty_H
+#define CoinPresolveEmpty_H
+
+/*! \file
+
+  Drop/reinsert empty rows/columns.
+*/
+
+const int DROP_ROW = 3;
+const int DROP_COL = 4;
+
+/*! \class drop_empty_cols_action
+    \brief Physically removes empty columns in presolve, and reinserts
+	   empty columns in postsolve.
+
+  Physical removal of rows and columns should be the last activities
+  performed during presolve. Do them exactly once. The row-major matrix
+  is <b>not</b> maintained by this transform.
+
+  To physically drop the columns, CoinPrePostsolveMatrix::mcstrt_ and
+  CoinPrePostsolveMatrix::hincol_ are compressed, along with column bounds,
+  objective, and (if present) the column portions of the solution. This
+  renumbers the columns. drop_empty_cols_action::presolve will reconstruct
+  CoinPresolveMatrix::clink_.
+
+  \todo Confirm correct behaviour with solution in presolve.
+*/
+
+class drop_empty_cols_action : public CoinPresolveAction {
+private:
+  const int nactions_;
+
+  struct action {
+    double clo;
+    double cup;
+    double cost;
+    double sol;
+    int jcol;
+  };
+  const action *const actions_;
+
+  drop_empty_cols_action(int nactions,
+			 const action *const actions,
+			 const CoinPresolveAction *next) :
+    CoinPresolveAction(next),
+    nactions_(nactions), 
+    actions_(actions)
+  {}
+
+ public:
+  const char *name() const { return ("drop_empty_cols_action"); }
+
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *,
+					 const int *ecols,
+					 int necols,
+					 const CoinPresolveAction*);
+
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
+					 const CoinPresolveAction *next);
+
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  virtual ~drop_empty_cols_action() { deleteAction(actions_,action*); }
+};
+
+
+/*! \class drop_empty_rows_action
+    \brief Physically removes empty rows in presolve, and reinserts
+	   empty rows in postsolve.
+
+  Physical removal of rows and columns should be the last activities
+  performed during presolve. Do them exactly once. The row-major matrix
+  is <b>not</b> maintained by this transform.
+
+  To physically drop the rows, the rows are renumbered, excluding empty
+  rows. This involves rewriting CoinPrePostsolveMatrix::hrow_ and compressing
+  the row bounds and (if present) the row portions of the solution.
+
+  \todo Confirm behaviour when a solution is present in presolve.
+*/
+class drop_empty_rows_action : public CoinPresolveAction {
+private:
+  struct action {
+    double rlo;
+    double rup;
+    int row;
+    int fill_row;	// which row was moved into position row to fill it
+  };
+
+  const int nactions_;
+  const action *const actions_;
+
+  drop_empty_rows_action(int nactions,
+			 const action *actions,
+			 const CoinPresolveAction *next) :
+    CoinPresolveAction(next),
+    nactions_(nactions), actions_(actions)
+{}
+
+ public:
+  const char *name() const { return ("drop_empty_rows_action"); }
+
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
+					    const CoinPresolveAction *next);
+
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  virtual ~drop_empty_rows_action() { deleteAction(actions_,action*); }
+};
+#endif
+

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

@@ -0,0 +1,181 @@
+/* $Id: CoinPresolveFixed.hpp 1510 2011-12-08 23:56:01Z 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).
+
+#ifndef CoinPresolveFixed_H
+#define CoinPresolveFixed_H
+#define	FIXED_VARIABLE	1
+
+/*! \class remove_fixed_action
+    \brief Excise fixed variables from the model.
+
+  Implements the action of virtually removing one or more fixed variables
+  x_j from the model by substituting the value sol_j in each constraint.
+  Specifically, for each constraint i where a_ij != 0, rlo_i and rup_i
+  are adjusted by -a_ij*sol_j and a_ij is set to 0.
+
+  There is an implicit assumption that the variable already has the correct
+  value. If this isn't true, corrections to row activity may be incorrect.
+  If you want to guard against this possibility, consider make_fixed_action.
+
+  Actual removal of the empty column from the matrix is handled by
+  drop_empty_cols_action. Correction of the objective function is done there.
+*/
+class remove_fixed_action : public CoinPresolveAction {
+ public:
+  /*! \brief Structure to hold information necessary to reintroduce a
+	     column into the problem representation.
+  */
+  struct action {
+    int col;		///< column index of variable
+    int start;		///< start of coefficients in #colels_ and #colrows_
+    double sol;		///< value of variable
+  };
+  /// Array of row indices for coefficients of excised columns
+  int *colrows_;
+  /// Array of coefficients of excised columns
+  double *colels_;
+  /// Number of entries in #actions_
+  int nactions_;
+  /// Vector specifying variable(s) affected by this object
+  action *actions_;
+
+ private:
+  /*! \brief Constructor */
+  remove_fixed_action(int nactions,
+		      action *actions,
+		      double * colels,
+		      int * colrows,
+		      const CoinPresolveAction *next);
+
+ public:
+  /// Returns string "remove_fixed_action".
+  const char *name() const;
+
+  /*! \brief Excise the specified columns.
+
+    Remove the specified columns (\p nfcols, \p fcols) from the problem
+    representation (\p prob), leaving the appropriate postsolve object
+    linked as the head of the list of postsolve objects (currently headed
+    by \p next).
+  */
+  static const remove_fixed_action *presolve(CoinPresolveMatrix *prob,
+					 int *fcols,
+					 int nfcols,
+					 const CoinPresolveAction *next);
+
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  /// Destructor
+  virtual ~remove_fixed_action();
+};
+
+
+/*! \relates remove_fixed_action
+    \brief Scan the problem for fixed columns and remove them.
+
+  A front end to collect a list of columns with equal bounds and hand them to
+  remove_fixed_action::presolve() for processing.
+*/
+
+const CoinPresolveAction *remove_fixed(CoinPresolveMatrix *prob,
+				    const CoinPresolveAction *next);
+
+
+/*! \class make_fixed_action
+    \brief Fix a variable at a specified bound.
+
+  Implements the action of fixing a variable by forcing both bounds to the same
+  value and forcing the value of the variable to match.
+
+  If the bounds are already equal, and the value of the variable is already
+  correct, consider remove_fixed_action.
+*/
+class make_fixed_action : public CoinPresolveAction {
+
+  /// Structure to preserve the bound overwritten when fixing a variable
+  struct action {
+    double bound;	///< Value of bound overwritten to fix variable.
+    int col ;		///< column index of variable
+  };
+
+  /// Number of preserved bounds
+  int nactions_;
+  /// Vector of preserved bounds, one for each variable fixed in this object
+  const action *actions_;
+
+  /*! \brief True to fix at lower bound, false to fix at upper bound.
+
+    Note that this applies to all variables fixed in this object.
+  */
+  const bool fix_to_lower_;
+
+  /*! \brief The postsolve object with the information required to repopulate
+  	     the fixed columns.
+  */
+  const remove_fixed_action *faction_;
+
+  /*! \brief Constructor */
+  make_fixed_action(int nactions, const action *actions, bool fix_to_lower,
+		    const remove_fixed_action *faction,
+		    const CoinPresolveAction *next)
+    : CoinPresolveAction(next),
+      nactions_(nactions), actions_(actions),
+      fix_to_lower_(fix_to_lower),
+      faction_(faction)
+  {}
+
+ public:
+  /// Returns string "make_fixed_action".
+  const char *name() const;
+
+  /*! \brief Perform actions to fix variables and return postsolve object
+
+    For each specified variable (\p nfcols, \p fcols), fix the variable to
+    the specified bound (\p fix_to_lower) by setting the variable's bounds
+    to be equal in \p prob. Create a postsolve object, link it at the head of
+    the list of postsolve objects (\p next), and return the object.
+  */
+  static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob,
+					 int *fcols,
+					 int nfcols,
+					 bool fix_to_lower,
+					 const CoinPresolveAction *next);
+
+  /*! \brief Postsolve (unfix variables)
+
+    Back out the variables fixed by the presolve side of this object.
+  */
+  void postsolve(CoinPostsolveMatrix *prob) const;
+
+  /// Destructor
+  virtual ~make_fixed_action() {
+    deleteAction(actions_,action*); 
+    delete faction_;
+  }
+};
+
+/*! \relates make_fixed_action
+    \brief Scan variables and fix any with equal bounds
+
+  A front end to collect a list of columns with equal bounds and hand them to
+  make_fixed_action::presolve() for processing.
+*/
+
+const CoinPresolveAction *make_fixed(CoinPresolveMatrix *prob,
+				    const CoinPresolveAction *next) ;
+
+/*! \brief Transfer costs from singleton variables
+    \relates make_fixed_action
+
+  Transfers costs from singleton variables in equalities onto the other
+  variables. Will also transfer costs from one integer variable to other
+  integer variables with zero cost if there's a net gain in integer variables
+  with non-zero cost.
+
+  The relation to make_fixed_action is tenuous, but this transform should be
+  attempted before the initial round of variable fixing.
+*/
+void transferCosts(CoinPresolveMatrix * prob);
+#endif