/home/coin/SVN-release/CoinAll-1.1.0/Bcps/src/BcpsNodeDesc.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 BcpsNodeDesc_h_
#define BcpsNodeDesc_h_

#include "BcpsModel.h"

#include "Alps.h"
#include "AlpsNodeDesc.h"

#include "BcpsObject.h"


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

template <class T> struct BcpsFieldListMod {
    bool relative;

    int  numModify;

    int* posModify;
    
    T*   entries;
};


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

    
struct BcpsObjectListMod {

    int  numRemove;

    int* posRemove;
    
    int  numAdd;
    BcpsObject **objects;
  
    BcpsFieldListMod<double> lbHard;
    BcpsFieldListMod<double> ubHard;
    BcpsFieldListMod<double> lbSoft;
    BcpsFieldListMod<double> ubSoft;
    BcpsFieldListMod<int> status;
};


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

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

class BcpsNodeDesc : public AlpsNodeDesc {

 protected: 

    BcpsObjectListMod *vars_;

    BcpsObjectListMod *cons_;
  
 public:

    BcpsNodeDesc() { initToNull(); }
    
    BcpsNodeDesc(BcpsModel* m) 
        :
        AlpsNodeDesc(m) { initToNull(); }
    
    virtual ~BcpsNodeDesc();
    
    void initToNull();
  
    void setVars(int numRem,
                 const int    *posRem,
                 int numAdd,
                 const BcpsObject **objects,
                 bool relvlh,
                 int numvlh, 
                 const int    *vlhp,
                 const double *vlhe,
                 bool relvuh,
                 int numvuh,
                 const int    *vuhp,
                 const double *vuhe,
                 bool relvls,
                 int numvls,
                 const int    *vlsp,
                 const double *vlse,
                 bool relvus,
                 int numvus,
                 const int    *vusp,
                 const double *vuse);
    
    void assignVars(int numRem,
                    int    *&posRem,
                    int numAdd,
                    BcpsObject **&objects,
                    bool relvlh,
                    int numvlh, 
                    int    *&vlhp,
                    double *&vlhe,
                    bool relvuh,
                    int numvuh,
                    int    *&vuhp,
                    double *&vuhe,
                    bool relvls,
                    int numvls,
                    int    *&vlsp,
                    double *&vlse,
                    bool relvus,
                    int numvus,
                    int    *&vusp,
                    double *&vuse);

    void setCons(int numRem,
                 const int    *posRem,
                 int numAdd,
                 const BcpsObject **objects,
                 bool relclh,
                 int numclh,
                 const int    *clhp,
                 const double *clhe,
                 bool relcuh,
                 int numcuh,
                 const int    *cuhp,
                 const double *cuhe,
                 bool relcls,
                 int numcls,
                 const int    *clsp,
                 const double *clse,
                 bool relcus,
                 int numcus,
                 const int    *cusp,
                 const double *cuse);
    
    void assignCons(int numRem,
                    int    *&posRem,
                    int numAdd,
                    BcpsObject **&objects,
                    bool relclh,
                    int numclh,
                    int    *&clhp,
                    double *&clhe,
                    bool relcuh,
                    int numcuh,
                    int    *&cuhp,
                    double *&cuhe,
                    bool relcls,
                    int numcls,
                    int    *&clsp,
                    double *&clse,
                    bool relcus,
                    int numcus,
                    int    *&cusp,
                    double *&cuse);
    
    BcpsObjectListMod *getVars() const { return vars_; }
  
    BcpsObjectListMod *getCons() const { return cons_; }
    
    BcpsObjectListMod *vars() { return vars_; }
    
    BcpsObjectListMod *cons() { return cons_; }

    void assignVarSoftBound(int numModSoftVarLB, 
                            int *&varLBi,
                            double *&varLBv,
                            int numModSoftVarUB,
                            int *&varUBi,
                            double *&varUBv);
 
    void setVarSoftBound(int numModSoftVarLB, 
                         const int *varLBi,
                         const double *varLBv,
                         int numModSoftVarUB,
                         const int *varUBi,
                         const double *varUBv);
  
    void assignVarHardBound(int numModHardVarLB, 
                            int *&varLBi,
                            double *&varLBv,
                            int numModHardVarUB,
                            int *&varUBi,
                            double *&varUBv);
 
    void setConSoftBound(int numModSoftConLB, 
                         const int *conLBi,
                         const double *conLBv,
                         int numModSoftConUB,
                         const int *conUBi,
                         const double *conUBv);
    
    void setVarHardBound(int numModHardVarLB, 
                         const int *varLBi,
                         const double *varLBv,
                         int numModHardVarUB,
                         const int *varUBi,
                         const double *varUBv);
    
    void setConHardBound(int numModHardConLB, 
                         const int *conLBi,
                         const double *conLBv,
                         int numModHardConUB,
                         const int *conUBi,
                         const double *conUBv);

    void appendAddedConstraints(int numAdd, BcpsObject **addCons){
        int numAll = numAdd + cons_->numAdd;
        BcpsObject ** allAdd = new BcpsObject* [numAll];
        int k;
        
        for (k = 0; k < cons_->numAdd; ++k) {
            allAdd[k] = cons_->objects[k];
        }
        for (k = 0; k < numAdd; ++k) {
            allAdd[(k+cons_->numAdd)] = addCons[k];
        }

        delete [] cons_->objects;
        cons_->numAdd = numAll;
        cons_->objects = allAdd;
    }

    void setAddedConstraints(int numAdd, BcpsObject **addCons){
        // NOTE: make sure objects can be safely deleted.
        if (cons_->objects) {
            for (int k = 0; k < cons_->numAdd; ++k) {
                delete cons_->objects[k];
            }
            delete [] cons_->objects;
        }
        cons_->numAdd = numAdd;
        cons_->objects = addCons;
    }

    void delConstraints(int numDel, int *indices){
        if ( cons_->posRemove) delete []  cons_->posRemove;
        cons_->numRemove = numDel;
        cons_->posRemove = indices;
    }

    void addVariables(int numAdd, BcpsObject **addVars){
        if (vars_->objects) {
            for (int k = 0; k < vars_->numAdd; ++k) {
                delete vars_->objects[k];
            }
            delete [] vars_->objects;
        }
        
        vars_->numAdd = numAdd;
        vars_->objects = addVars;
    }
    
    void delVariables(int numDel, int *indices){
        if (vars_->posRemove) delete []  vars_->posRemove;
        vars_->numRemove = numDel;
        vars_->posRemove = indices;
    }

 protected:

    AlpsReturnStatus encodeDblFieldMods(AlpsEncoded *encoded,
                                      BcpsFieldListMod<double> * field) const;

    AlpsReturnStatus encodeIntFieldMods(AlpsEncoded *encoded,
                                      BcpsFieldListMod<int> * field) const;
    
    AlpsReturnStatus encodeObjectMods(AlpsEncoded *encoded,
                                    BcpsObjectListMod *objMod) const;

    AlpsReturnStatus decodeDblFieldMods(AlpsEncoded &encoded,
                                      BcpsFieldListMod<double>*field);

    AlpsReturnStatus decodeIntFieldMods(AlpsEncoded &encoded,
                                      BcpsFieldListMod<int> *field);

    AlpsReturnStatus decodeObjectMods(AlpsEncoded &encoded,
                                    BcpsObjectListMod *objMod);
    
 public:

    AlpsReturnStatus encodeBcps(AlpsEncoded *encoded) const;

    AlpsReturnStatus decodeBcps(AlpsEncoded &encoded);
    
};

#endif /* End of file */

---