/home/coin/SVN-release/CoinAll-1.1.0/Bcp/src/include/BCP_matrix.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef _BCP_MATRIX_H
#define _BCP_MATRIX_H

// This file is fully docified.

// #include <cmath>
// #include <cfloat>

#include "CoinPackedVector.hpp"
#include "CoinPackedMatrix.hpp"

#include "BCP_math.hpp"
#include "BCP_vector.hpp"

//#############################################################################

class BCP_buffer;

//#############################################################################

class BCP_col : public CoinPackedVector {
   
protected:
   double _Objective;
   double _LowerBound;
   double _UpperBound;
   //--------------------------------------------------------------------------

public:
   inline double Objective()  const { return _Objective; }
   inline double LowerBound() const { return _LowerBound; }
   inline double UpperBound() const { return _UpperBound; }
   //--------------------------------------------------------------------------

   inline void Objective(const double obj) { _Objective = obj; }
   inline void LowerBound(const double lb) { _LowerBound = lb; }
   inline void UpperBound(const double ub) { _UpperBound = ub; }

   BCP_col& operator=(const BCP_col& x) {
      CoinPackedVector::operator=(x);
      _Objective = x.Objective();
      _LowerBound = x.LowerBound();
      _UpperBound = x.UpperBound();
      return *this;
   }
   inline void
   assign(const int size, int*& ElementIndices, double*& ElementValues,
          const double Obj, const double LB, const double UB) {
      CoinPackedVector::assignVector(size, ElementIndices, ElementValues,
                                    false /* no test for duplicate index */);
      _Objective = Obj;
      _LowerBound = LB;
      _UpperBound = UB;
   }
   inline void
   copy(const int size, const int* ElementIndices, const double* ElementValues,
        const double Obj, const double LB, const double UB) {
      CoinPackedVector::setVector(size, ElementIndices, ElementValues,
                                 false /* no test for duplicate index */);
      _Objective = Obj;
      _LowerBound = LB;
      _UpperBound = UB;
   }
   inline void
   copy(BCP_vec<int>::const_iterator firstind,
        BCP_vec<int>::const_iterator lastind,
        BCP_vec<double>::const_iterator firstval,
        BCP_vec<double>::const_iterator lastval,
        const double Obj, const double LB, const double UB) {
      CoinPackedVector::setVector(lastind - firstind, firstind, firstval,
                                 false /* no test for duplicate index */);
      _Objective = Obj;
      _LowerBound = LB;
      _UpperBound = UB;
   }
   //--------------------------------------------------------------------------

   BCP_col() : CoinPackedVector(false /* no test for duplicate index */),
               _Objective(0), _LowerBound(0.0), _UpperBound(BCP_DBL_MAX) {}
   BCP_col(const BCP_col& x) :
      CoinPackedVector(x), _Objective(x.Objective()),
      _LowerBound(x.LowerBound()), _UpperBound(x.UpperBound()) {}
   BCP_col(BCP_vec<int>::const_iterator firstind,
           BCP_vec<int>::const_iterator lastind,
           BCP_vec<double>::const_iterator firstval,
           BCP_vec<double>::const_iterator lastval,
           const double Obj, const double LB, const double UB) :
      CoinPackedVector(lastind - firstind, firstind, firstval,
                      false /* no test for duplicate index */),
      _Objective(Obj), _LowerBound(LB), _UpperBound(UB) {}
   BCP_col(const int size, int*& ElementIndices, double*& ElementValues,
           const double Obj, const double LB, const double UB) :
      CoinPackedVector(), _Objective(Obj), _LowerBound(LB), _UpperBound(UB) {
      CoinPackedVector::assignVector(size, ElementIndices, ElementValues,
                                    false /* no test for duplicate index */);
   }
   BCP_col(const CoinPackedVectorBase& vec,
           const double Obj, const double LB, const double UB) :
      CoinPackedVector(vec.getNumElements(),
                      vec.getIndices(), vec.getElements()),
      _Objective(Obj), _LowerBound(LB), _UpperBound(UB) {}
   ~BCP_col() {}
};

//#############################################################################

class BCP_row : public CoinPackedVector {
protected:
   double _LowerBound;
   double _UpperBound;
   //--------------------------------------------------------------------------

public:
   inline double LowerBound() const { return _LowerBound; }
   inline double UpperBound() const { return _UpperBound; }
   //--------------------------------------------------------------------------

   inline void LowerBound(double lb) { _LowerBound = lb; }
   inline void UpperBound(double ub) { _UpperBound = ub; }

   BCP_row& operator=(const BCP_row& x) {
      CoinPackedVector::operator=(x);
      _LowerBound = x.LowerBound();
      _UpperBound = x.UpperBound();
      return *this;
   }

   void
   assign(const int size, int*& ElementIndices, double*& ElementValues,
          const double LB, const double UB) {
      CoinPackedVector::assignVector(size, ElementIndices, ElementValues,
                                    false /* no test for duplicate index */);
      _LowerBound = LB;
      _UpperBound = UB;
   }
   void
   copy(const int size, const int* ElementIndices, const double* ElementValues,
        const double LB, const double UB) {
      CoinPackedVector::setVector(size, ElementIndices, ElementValues,
                                 false /* no test for duplicate index */);
      _LowerBound = LB;
      _UpperBound = UB;
   }
   void
   copy(BCP_vec<int>::const_iterator firstind,
        BCP_vec<int>::const_iterator lastind,
        BCP_vec<double>::const_iterator firstval,
        BCP_vec<double>::const_iterator lastval,
        const double LB, const double UB) {
      CoinPackedVector::setVector(lastind - firstind, firstind, firstval,
                                 false /* no test for duplicate index */);
      _LowerBound = LB;
      _UpperBound = UB;
   }
   //--------------------------------------------------------------------------

   BCP_row() : CoinPackedVector(false /* no test for duplicate index */),
               _LowerBound(-BCP_DBL_MAX), _UpperBound(BCP_DBL_MAX) {}
   BCP_row(const BCP_row& x) :
      CoinPackedVector(x),
      _LowerBound(x.LowerBound()), _UpperBound(x.UpperBound()) {}
   BCP_row(BCP_vec<int>::const_iterator firstind,
           BCP_vec<int>::const_iterator lastind,
           BCP_vec<double>::const_iterator firstval,
           BCP_vec<double>::const_iterator lastval,
           const double LB, const double UB) :
      CoinPackedVector(lastind - firstind, firstind, firstval,
                      false /* no test for duplicate index */),
      _LowerBound(LB), _UpperBound(UB) {}
   BCP_row(const int size, int*& ElementIndices, double*& ElementValues,
           const double LB, const double UB) :
      CoinPackedVector(), _LowerBound(LB), _UpperBound(UB) {
      CoinPackedVector::assignVector(size, ElementIndices, ElementValues,
                                    false /* no test for duplicate index */);
   }
   BCP_row(const CoinPackedVectorBase& vec, const double LB, const double UB) :
      CoinPackedVector(vec.getNumElements(),
                      vec.getIndices(), vec.getElements()),
      _LowerBound(LB), _UpperBound(UB) {}
   ~BCP_row() {}
};

//#############################################################################
//#############################################################################

class BCP_lp_relax : public CoinPackedMatrix {
private:
   BCP_vec<double> _Objective;
   BCP_vec<double> _ColLowerBound;
   BCP_vec<double> _ColUpperBound;
   BCP_vec<double> _RowLowerBound;
   BCP_vec<double> _RowUpperBound;
   //--------------------------------------------------------------------------

public:
   inline size_t colnum() const       { return _ColLowerBound.size(); }
   inline size_t rownum() const       { return _RowLowerBound.size(); }
   inline const BCP_vec<double>& Objective()     const {return _Objective;}
   inline const BCP_vec<double>& ColLowerBound() const {return _ColLowerBound;}
   inline const BCP_vec<double>& ColUpperBound() const {return _ColUpperBound;}
   inline const BCP_vec<double>& RowLowerBound() const {return _RowLowerBound;}
   inline const BCP_vec<double>& RowUpperBound() const {return _RowUpperBound;}
   //--------------------------------------------------------------------------

   BCP_lp_relax& operator=(const BCP_lp_relax& mat);
   void reserve(const int MaxColNum, const int MaxRowNum,
                const int MaxNonzeros);
   void clear();
   void copyOf(const CoinPackedMatrix& m,
               const double* OBJ, const double* CLB, const double* CUB,
               const double* RLB, const double* RUB);
   void assign(CoinPackedMatrix& m,
               double*& OBJ, double*& CLB, double*& CUB,
               double*& RLB, double*& RUB);
   //--------------------------------------------------------------------------

#if 0

   void add_col_set(const BCP_col_set& Cols);
   void add_row_set(const BCP_row_set& Rows);
#endif

   void erase_col_set(const BCP_vec<int>& pos);
   void erase_row_set(const BCP_vec<int>& pos);
   //--------------------------------------------------------------------------
#if 0

   double dot_product_col(const int index, const BCP_vec<double>& col) const;
   double dot_product_row(const int index, const BCP_vec<double>& row) const;
   double dot_product_col(const int index, const double* col) const;
   double dot_product_row(const int index, const double* row) const;
#endif
   //--------------------------------------------------------------------------

   void pack(BCP_buffer& buf) const;
   void unpack(BCP_buffer& buf);
   //--------------------------------------------------------------------------

   BCP_lp_relax(const bool colordered = true) :
      CoinPackedMatrix(colordered, 0, 0, 0, NULL, NULL, NULL, NULL),
      _Objective(), _ColLowerBound(), _ColUpperBound(),
      _RowLowerBound(), _RowUpperBound() {}

   BCP_lp_relax(const BCP_lp_relax& mat);

   BCP_lp_relax(BCP_vec<BCP_row*>& rows,
                BCP_vec<double>& CLB, BCP_vec<double>& CUB,
                BCP_vec<double>& OBJ);

   BCP_lp_relax(BCP_vec<BCP_row*>& rows,
                BCP_vec<double>& CLB, BCP_vec<double>& CUB,
                BCP_vec<double>& OBJ,
                double extra_gap, double extra_major);

   BCP_lp_relax(BCP_vec<BCP_col*>& cols,
                BCP_vec<double>& RLB, BCP_vec<double>& RUB);

   BCP_lp_relax(BCP_vec<BCP_col*>& cols,
                BCP_vec<double>& RLB, BCP_vec<double>& RUB,
                double extra_gap, double extra_major);

   BCP_lp_relax(const bool colordered,
                const BCP_vec<int>& VB, const BCP_vec<int>& EI,
                const BCP_vec<double>& EV, const BCP_vec<double>& OBJ,
                const BCP_vec<double>& CLB, const BCP_vec<double>& CUB,
                const BCP_vec<double>& RLB, const BCP_vec<double>& RUB);
   BCP_lp_relax(const bool colordered,
                const int rownum, const int colnum, const int nznum,
                int*& VB, int*& EI, double*& EV,
                double*& OBJ, double*& CLB, double*& CUB,
                double*& RLB, double*& RUB);

   ~BCP_lp_relax() {}
private:

  void BCP_createColumnOrderedMatrix(BCP_vec<BCP_row*>& rows,
                                     BCP_vec<double>& CLB,
                                     BCP_vec<double>& CUB,
                                     BCP_vec<double>& OBJ);
  void BCP_createRowOrderedMatrix(BCP_vec<BCP_col*>& cols,
                                  BCP_vec<double>& RLB,
                                  BCP_vec<double>& RUB);
};

#endif

---