DecompSolution.h

Go to the documentation of this file.

//===========================================================================//
// This file is part of the Decomp Solver Framework.                         //
//                                                                           //
// Decomp is distributed under the Common Public License as part of the      //
// COIN-OR repository (http://www.coin-or.org).                              //
//                                                                           //
// Author: Matthew Galati, Lehigh University                                 //
//                                                                           //
// Copyright (C) 2002-2007, Lehigh University, Matthew Galati, and Ted Ralphs//
// All Rights Reserved.                                                      //
//===========================================================================//

#ifndef DECOMP_SOLUTION_INCLUDED
#define DECOMP_SOLUTION_INCLUDED

class DecompSolution {
protected:
   int      m_size;

   double* m_values;

   double   m_quality;

public:
   inline const int getSize() const {
      return m_size;
   }

   inline const double* getValues() const {
      return m_values;
   }

   inline const double getQuality() const {
      return m_quality;
   }

public:
   virtual void print(ostream& os = cout) const {
      int i;
      os << setiosflags(ios::fixed | ios::showpoint)
         << setw(14);
      os << "-------------------------" << endl;

      for (i = 0; i < m_size; i++) {
         if (!UtilIsZero(m_values[i])) {
            os << setw(6) << i << " " << m_values[i] << endl;
         }
      }

      os << "-------------------------" << endl;
      os << resetiosflags(ios::fixed | ios::showpoint | ios::scientific);
   }

public:
   DecompSolution(const DecompSolution& source) :
      m_size(source.m_size),
      m_values(0),
      m_quality(source.m_quality) {
      m_values = new double[m_size];
      CoinAssertHint(m_values, "Error: Out of Memory");
      memcpy(m_values, source.m_values, m_size * sizeof(double));
   }
   DecompSolution& operator=(const DecompSolution& rhs) {
      if (this != &rhs) {
         m_size    = rhs.m_size;
         m_quality = rhs.m_quality;
         m_values = new double[m_size];
         CoinAssertHint(m_values, "Error: Out of Memory");
         memcpy(m_values, rhs.m_values, m_size * sizeof(double));
      }

      return *this;
   }

public:
   DecompSolution() :
      m_size(0),
      m_values(0),
      m_quality(DecompInf) {
   }

   DecompSolution(const int      size,
                  const double* values,
                  const double   quality) :
      m_size(size),
      m_values(0),
      m_quality(quality) {
      CoinAssert(m_size > 0);
      m_values = new double[m_size];
      CoinAssertHint(m_values, "Error: Out of Memory");
      memcpy(m_values, values, m_size * sizeof(double));
   }

   virtual ~DecompSolution() {
      UTIL_DELARR(m_values);
   };
};

#endif