SmiDiscreteDistribution.hpp

Go to the documentation of this file.

// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef SmiDiscreteRV_H
#define SmiDiscreteRV_H

#include "CoinPragma.hpp"
#include "SmiScnData.hpp"
#include "SmiLinearData.hpp"

#include <vector>

//forward declarations
class SmiDiscreteRV;

class SmiDiscreteDistribution
{
        friend void SmiDiscreteUnitTest();
public:
        void addDiscreteRV(SmiDiscreteRV *s)
        { smiDiscrete_.push_back(s); }

        SmiDiscreteRV * getDiscreteRV(int i) {return smiDiscrete_[i];}

        int getNumRV() { return (int)smiDiscrete_.size(); }

        SmiCoreData *getCore(){ return core_; }

        inline void setCombineWithCoreRule(SmiCoreCombineRule *r){
                        combineRule_ = r;
        }

        inline SmiCoreCombineRule *getCombineWithCoreRule() { return combineRule_;}

        
        SmiDiscreteDistribution(SmiCoreData *c, SmiCoreCombineRule *r=SmiCoreCombineReplace::Instance())
        {
                core_=c;
                this->setCombineWithCoreRule(r);                
        }

        ~SmiDiscreteDistribution();

private:
        SmiDiscreteDistribution(){core_=NULL;}
        SmiCoreData *core_;
        std::vector<SmiDiscreteRV *> smiDiscrete_;
        SmiCoreCombineRule *combineRule_;


};


class SmiDiscreteEvent : public SmiLinearData
{
        friend void SmiDiscreteUnitTest();
public:
        inline void setEventProb(double p) {prob_ = p;}
        inline const double getEventProb () { return prob_; }
        SmiDiscreteEvent(SmiLinearData d, double p):SmiLinearData(d),prob_(p){}
        ~SmiDiscreteEvent(){}
private:
        double prob_;
};


class SmiDiscreteRV
{
        friend void SmiDiscreteUnitTest();
public:
        void addEvent(CoinPackedMatrix &matrix,
                                CoinPackedVector &dclo, CoinPackedVector &dcup,
                                CoinPackedVector &dobj,
                                CoinPackedVector &drlo, CoinPackedVector &drup, double prob);
        void addEvent(OsiSolverInterface &osi, double prob)
        {
                SmiLinearData d(osi);
                SmiDiscreteEvent *e = new SmiDiscreteEvent(d,prob);
                events_.push_back(e); 
                prob_+=prob;
        }

        inline const CoinPackedMatrix &getEventMatrix(int i)   {return events_[i]->getMatrix(); }
        inline const CoinPackedVector &getEventColLower(int i) {return events_[i]->getColLower();}
        inline const CoinPackedVector &getEventColUpper(int i) {return events_[i]->getColUpper();}
        inline const CoinPackedVector &getEventObjective(int i){return events_[i]->getObjective();}
        inline const CoinPackedVector &getEventRowLower(int i) {return events_[i]->getRowLower();}
        inline const CoinPackedVector &getEventRowUpper(int i) {return events_[i]->getRowUpper();}
        double getEventProb(int i) { 
        //      return events_[i]->getEventProb()/prob_;
                        return events_[i]->getEventProb();
        }
        inline size_t getNumEvents() { return events_.size(); }
        inline int getStage() {return stg_;}
        inline void setStage(int p) {stg_=p;}
        SmiDiscreteRV(){prob_=0.0; stg_=-1;}
        SmiDiscreteRV(int p) {prob_=0.0; stg_=p;}
        ~SmiDiscreteRV(){
                for (size_t i=0; i<events_.size(); ++i)
                        delete events_[i];
        }
private:
        std::vector<SmiDiscreteEvent *> events_;
        SmiStageIndex  stg_;
        double prob_;
};

void SmiDiscreteUnitTest();

#endif //SmiDiscreteRV_H