ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,26 +0,0 @@
-/* $Id: CoinPragma.hpp 1372 2011-01-03 23:31:00Z lou $ */
-// 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 CoinPragma_H
-#define CoinPragma_H
-
-//-------------------------------------------------------------------
-//
-// This is a file which can contain Pragma's that are
-// generally applicable to any source file.
-//
-//-------------------------------------------------------------------
-
-#if defined(_MSC_VER)
-// Turn off compiler warning about long names
-#  pragma warning(disable:4786)
-// Turn off compiler warning: 
-// "empty controlled statement found; is this the intent?"
-#  pragma warning(disable:4390)
-// Turn off compiler warning about deprecated functions
-#  pragma warning(disable:4996)
-#endif
-
-#endif

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

@@ -1,73 +0,0 @@
-/* $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

@@ -1,85 +0,0 @@
-/* $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

@@ -1,226 +0,0 @@
-/* $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

@@ -1,116 +0,0 @@
-/* $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
-