/home/coin/SVN-release/CoinAll-1.1.0/Bcps/src/BcpsSolution.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Branch, Constrain and Price Software (BiCePS)    *
 *                                                                           *
 * BiCePS is distributed under the Common Public License as part of the      *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           *
 * Copyright (C) 2001-2007, Lehigh University, Yan Xu, and Ted Ralphs.       *
 * All Rights Reserved.                                                      *
 *===========================================================================*/

#ifndef BcpsSolution_h_
#define BcpsSolution_h_

#include "AlpsSolution.h"
#include "BcpsObject.h"

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

class BcpsSolution : public AlpsSolution {

 private:

    BcpsSolution(const BcpsSolution&);
    BcpsSolution& operator=(const BcpsSolution&);
   
 protected:

    int size_;
    
    BcpsObject_p *objects_;

    double* values_;

    double quality_;
    
 public:
    
    BcpsSolution() 
        : 
        size_(0), objects_(NULL), values_(NULL), quality_(ALPS_OBJ_MAX)
        {}
    
    BcpsSolution(int size, const double *values, double q)
        :
        size_(size), objects_(NULL), values_(NULL), quality_(q) {
        
        if (size > 0) {
            values_ = new double [size];
            memcpy(values_, values, sizeof(double) * size);
        }
        else {
            std::cout << "ERROR: Solution size = " << size << std::endl;
            assert(size > 0);
        }
    }

    BcpsSolution(int size, BcpsObject_p*& objects, double*& values, double q)
        :
        size_(size), objects_(objects), values_(values), quality_(q) {
        objects = NULL;
        values = NULL;
    }
    
    virtual ~BcpsSolution() {
        if (objects_) {
            for (int i = 0; i < size_; ++i) {
                delete objects_[i];
            }
            delete[] objects_;
        }
        delete[] values_;
    }
   
    inline int getSize() const { return size_; }
    inline const BcpsObject_p* getObjects() const { return objects_; }
    inline const double* getValues() const { return values_; }
    inline double getQuality() const { return quality_; }
    inline void setSize(int s) { size_ = s; }
    inline void assignObjects(BcpsObject_p *& obj){
        objects_ = obj;
        obj = NULL;
    }
    inline void setValues(const double *vs, int s) { 
        if (!values_) delete [] values_;
        values_ = new double [s];
        size_ = s;
        memcpy(values_, vs, s * sizeof(double));
    }
    inline void setQuality(double q) { quality_ = q; }
    virtual BcpsSolution* selectNonzeros(const double etol = 1e-5) const;
    virtual BcpsSolution* selectFractional(const double etol = 1e-5) const;
    virtual void print(std::ostream& os) const {
        for (int j = 0; j < size_; ++j) {
            if (values_[j] > 1.0e-15 || values_[j] < -1.0e-15) {
                os << "x[" << j << "] = " << values_[j] << std::endl;
            }
        }
    }
    
    //------------------------------------------------------
    // Parallel.
    //------------------------------------------------------
   
    AlpsReturnStatus encodeBcps(AlpsEncoded *encoded) const;

    AlpsReturnStatus decodeBcps(AlpsEncoded & encoded);
    
};

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

#endif

---