/home/coin/SVN-release/CoinAll-1.1.0/Bcps/examples/Blis/BlisNodeDesc.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Bcps Linear Solver (BLIS).                       *
 *                                                                           *
 * BLIS 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-2005, International Business Machines                  *
 * Corporation, Lehigh University, Yan Xu, Ted Ralphs, Matthew Salzman and   *
 * others. All Rights Reserved.                                              *
 *===========================================================================*/

#ifndef BlisNodeDesc_h_
#define BlisNodeDesc_h_

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

#include "CoinWarmStartBasis.hpp"

#include "AlpsNodeDesc.h"
#include "BcpsNodeDesc.h"

#include "BlisHelp.h"
#include "BlisModel.h"

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


class BlisNodeDesc : public BcpsNodeDesc {

 private:
    
    int branchedDir_;

    int branchedInd_;

    double branchedVal_;

    CoinWarmStartBasis *basis_;
    
 public:

    BlisNodeDesc() :
        BcpsNodeDesc(),
        branchedDir_(0),
        branchedInd_(-1),
        branchedVal_(0.0),
        basis_(NULL)
        {}

    BlisNodeDesc(BlisModel* m) 
        :
        BcpsNodeDesc(m),
        branchedDir_(0),
        branchedInd_(-1),
        branchedVal_(0.0),
        basis_(NULL)
        {}

    virtual ~BlisNodeDesc() { delete basis_; }

    void setBasis(CoinWarmStartBasis *&ws) { 
        if (basis_) { delete basis_; }
        basis_= ws;
        ws = NULL; 
    }

    CoinWarmStartBasis * getBasis() const { return basis_; }

    void setBranchedDir(int d) { branchedDir_ = d; }

    int getBranchedDir() const { return branchedDir_; }

    void setBranchedInd(int d) { branchedInd_ = d; }

    int getBranchedInd() const { return branchedInd_; }

    void setBranchedVal(double d) { branchedVal_ = d; }

    double getBranchedVal() const { return branchedVal_; }

 protected:

    AlpsReturnStatus encodeBlis(AlpsEncoded *encoded) const {
        AlpsReturnStatus status = AlpsReturnStatusOk;

        encoded->writeRep(branchedDir_);
        encoded->writeRep(branchedInd_);
        encoded->writeRep(branchedVal_);

        // Basis
        int ava = 0;
        if (basis_) {
            ava = 1;
            encoded->writeRep(ava);
            BlisEncodeWarmStart(encoded, basis_);
        }
        else {
            encoded->writeRep(ava);
        }
        
        return status;
    }

    AlpsReturnStatus decodeBlis(AlpsEncoded &encoded) {
        AlpsReturnStatus status = AlpsReturnStatusOk;
        
        encoded.readRep(branchedDir_);
        encoded.readRep(branchedInd_);
        encoded.readRep(branchedVal_);
        
        // Basis
        int ava;
        encoded.readRep(ava);
        if (ava == 1) {
            basis_ = BlisDecodeWarmStart(encoded, &status);
        }
        else {
            basis_ = NULL;
        }
        
        return status;
    }

 public:

    virtual AlpsReturnStatus encode(AlpsEncoded *encoded) const {
        AlpsReturnStatus status = AlpsReturnStatusOk;
        
        status = encodeBcps(encoded);
        status = encodeBlis(encoded);
        
        return status;
    }

    virtual AlpsReturnStatus decode(AlpsEncoded &encoded) {
        
        AlpsReturnStatus status = AlpsReturnStatusOk;
        
        status = decodeBcps(encoded);
        status = decodeBlis(encoded);

        return status;
    }
    
};
#endif

---