CbcFathomDynamicProgramming.hpp

Go to the documentation of this file.

/* $Id: CbcFathomDynamicProgramming.hpp 1432 2010-02-07 19:33:53Z bjarni $ */
// Copyright (C) 2004, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcFathomDynamicProgramming_H
#define CbcFathomDynamicProgramming_H

#include "CbcFathom.hpp"

//#############################################################################
class CbcFathomDynamicProgramming : public CbcFathom {
public:
    // Default Constructor
    CbcFathomDynamicProgramming ();

    // Constructor with model - assumed before cuts
    CbcFathomDynamicProgramming (CbcModel & model);
    // Copy constructor
    CbcFathomDynamicProgramming(const CbcFathomDynamicProgramming & rhs);

    virtual ~CbcFathomDynamicProgramming();

    virtual void setModel(CbcModel * model);

    virtual CbcFathom * clone() const;

    virtual void resetModel(CbcModel * model);

    virtual int fathom(double *& newSolution);

    inline int maximumSize() const {
        return maximumSizeAllowed_;
    }
    inline void setMaximumSize(int value) {
        maximumSizeAllowed_ = value;
    }
    int checkPossible(int allowableSize = 0);
    // set algorithm
    inline void setAlgorithm(int value) {
        algorithm_ = value;
    }
    bool tryColumn(int numberElements, const int * rows,
                   const double * coefficients, double cost,
                   int upper = COIN_INT_MAX);
    inline const double * cost() const {
        return cost_;
    }
    inline const int * back() const {
        return back_;
    }
    inline int target() const {
        return target_;
    }
    inline void setTarget(int value) {
        target_ = value;
    }
private:
    void gutsOfDelete();

    bool addOneColumn0(int numberElements, const int * rows,
                       double cost);
    bool addOneColumn1(int numberElements, const int * rows,
                       const int * coefficients, double cost);
    bool addOneColumn1A(int numberElements, const int * rows,
                        const int * coefficients, double cost);
    int bitPattern(int numberElements, const int * rows,
                   const int * coefficients);
    int bitPattern(int numberElements, const int * rows,
                   const double * coefficients);
    int decodeBitPattern(int bitPattern, int * values, int numberRows);

protected:

    int size_;
    int type_;
    double * cost_;
    int * back_;
    int * lookup_;
    int * indices_;
    int numberActive_;
    int maximumSizeAllowed_;
    int * startBit_;
    int * numberBits_;
    int * rhs_;
    int * coefficients_;
    int target_;
    int numberNonOne_;
    int bitPattern_;
    int algorithm_;
private:

    CbcFathomDynamicProgramming & operator=(const CbcFathomDynamicProgramming& rhs);

};

#endif