regiongraph.h

Go to the documentation of this file.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
 *
 *  Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 */




#ifndef __defined_libdai_regiongraph_h
#define __defined_libdai_regiongraph_h


#include <iostream>
#include <dai/bipgraph.h>
#include <dai/factorgraph.h>
#include <dai/weightedgraph.h>


namespace dai {


class Region : public VarSet {
    private:
        Real _c;

    public:
        Region() : VarSet(), _c(1.0) {}

        Region( const VarSet& x, Real c ) : VarSet(x), _c(c) {}

        const Real& c() const { return _c; }

        Real& c() { return _c; }
};


class FRegion : public Factor {
    private:
        Real _c;

    public:
        FRegion() : Factor(), _c(1.0) {}

        FRegion( const Factor& x, Real c ) : Factor(x), _c(c) {}

        const Real& c() const { return _c; }

        Real& c() { return _c; }
};



class RegionGraph : public FactorGraph {
    protected:
        BipartiteGraph          _G;

        std::vector<FRegion>    _ORs;

        std::vector<Region>     _IRs;

        std::vector<size_t>     _fac2OR;


    public:

        RegionGraph() : FactorGraph(), _G(), _ORs(), _IRs(), _fac2OR() {}


        RegionGraph( const FactorGraph& fg, const std::vector<VarSet>& ors, const std::vector<Region>& irs, const std::vector<std::pair<size_t,size_t> >& edges ) : FactorGraph(), _G(), _ORs(), _IRs(), _fac2OR() {
            construct( fg, ors, irs, edges );

            // Check counting numbers
#ifdef DAI_DEBUG
            checkCountingNumbers();
#endif
        }


        RegionGraph( const FactorGraph& fg, const std::vector<VarSet>& cl ) : FactorGraph(), _G(), _ORs(), _IRs(), _fac2OR() {
            constructCVM( fg, cl );

            // Check counting numbers
#ifdef DAI_DEBUG
            checkCountingNumbers();
#endif
        }

        virtual RegionGraph* clone() const { return new RegionGraph(*this); }


        size_t nrORs() const { return _ORs.size(); }
        size_t nrIRs() const { return _IRs.size(); }

        const FRegion& OR( size_t alpha ) const {
            DAI_DEBASSERT( alpha < nrORs() );
            return _ORs[alpha]; 
        }
        FRegion& OR( size_t alpha ) {
            DAI_DEBASSERT( alpha < nrORs() );
            return _ORs[alpha]; 
        }

        const Region& IR( size_t beta ) const {
            DAI_DEBASSERT( beta < nrIRs() );
            return _IRs[beta]; 
        }
        Region& IR( size_t beta ) {
            DAI_DEBASSERT( beta < nrIRs() );
            return _IRs[beta];
        }

        size_t fac2OR( size_t I ) const {
            DAI_DEBASSERT( I < nrFactors() );
            DAI_DEBASSERT( I < _fac2OR.size() );
            return _fac2OR[I];
        }

        const Neighbors& nbOR( size_t alpha ) const { return _G.nb1(alpha); }

        const Neighbors& nbIR( size_t beta ) const { return _G.nb2(beta); }


        const BipartiteGraph& DAG() const { return _G; }



        bool checkCountingNumbers() const;


        virtual void setFactor( size_t I, const Factor& newFactor, bool backup = false ) {
            FactorGraph::setFactor( I, newFactor, backup );
            recomputeOR( I );
        }

        virtual void setFactors( const std::map<size_t, Factor>& facs, bool backup = false ) {
            FactorGraph::setFactors( facs, backup );
            VarSet ns;
            for( std::map<size_t, Factor>::const_iterator fac = facs.begin(); fac != facs.end(); fac++ )
                ns |= fac->second.vars();
            recomputeORs( ns );
        }



        virtual void ReadFromFile( const char* /*filename*/ ) {
            DAI_THROW(NOT_IMPLEMENTED);
        }


        virtual void WriteToFile( const char* /*filename*/, size_t /*precision*/=15 ) const {
            DAI_THROW(NOT_IMPLEMENTED);
        }

        friend std::ostream& operator<< ( std::ostream& os, const RegionGraph& rg );

        std::string toString() const {
            std::stringstream ss;
            ss << *this;
            return ss.str();
        }


        virtual void printDot( std::ostream& /*os*/ ) const {
            DAI_THROW(NOT_IMPLEMENTED);
        }

    protected:
        void construct( const FactorGraph& fg, const std::vector<VarSet>& ors, const std::vector<Region>& irs, const std::vector<std::pair<size_t,size_t> >& edges );

        void constructCVM( const FactorGraph& fg, const std::vector<VarSet>& cl, size_t verbose=0 );


        void recomputeORs();


        void recomputeORs( const VarSet& vs );


        void recomputeOR( size_t I );


        void calcCVMCountingNumbers();

};


} // end of namespace dai


#endif