cobwebgraph.h

Go to the documentation of this file.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  Copyright (c) 2006-2012, 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_cobwebgraph_h
#define __defined_libdai_cobwebgraph_h


#include <iostream>
#include <dai/factorgraph.h>
#include <dai/weightedgraph.h>
#include <dai/smallset.h>
#include <dai/enum.h>
#include <algorithm>
#include <map>
#include <set>


namespace dai {



class CobwebGraph : public FactorGraph {
    public:
        struct Connection {
            size_t my;
            size_t his;
            size_t iter;
            size_t dual;
            Factor msg;
            std::vector<size_t> varinds;

            Factor newmsg;
            std::vector<size_t> fc;
            std::vector<VarSet> subregions;
        };

        DAI_ENUM(NeighborType,ALL,TOP,CLOSEST);

    protected:
        std::vector<SmallSet<size_t> >        _INRs;
        std::vector<SmallSet<size_t> >        _EXRs;
        std::vector<SmallSet<size_t> >        _Rfs;
        std::vector<SmallSet<size_t> >        _Rifs;
        std::vector<SmallSet<size_t> >        _Rxfs;
        std::vector<std::vector<VarSet> >     _outM;
        std::vector<std::vector<Connection> > _M;

        std::vector<std::vector<size_t> > _var2CW;

        std::vector<std::map<VarSet, std::pair<int,std::vector<size_t> > > > _cn;

        bool isPartition;

    public:

        CobwebGraph() : FactorGraph(), _INRs(), _EXRs(),_Rfs(),_Rifs(),_Rxfs(), _M(), _var2CW(), _cn(), isPartition(true) {}

        CobwebGraph( const FactorGraph& fg ): FactorGraph(), _INRs(), _EXRs(),_Rfs(), _M(), _var2CW(), _cn(), isPartition(true) {
            // Copy factor graph structure
            FactorGraph::operator=( fg );
        }

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


        size_t nrCWs() const { return _INRs.size(); }

        const std::map<VarSet, std::pair<int,std::vector<size_t> > >& cn( size_t R ) const {
            DAI_DEBASSERT( R < nrCWs() );
            return _cn[R];
        }

        std::map<VarSet, std::pair<int,std::vector<size_t> > >& cn( size_t R ) {
            DAI_DEBASSERT( R < nrCWs() );
            return _cn[R];
        }

        const std::vector<VarSet>& outM( size_t R ) const {
            DAI_DEBASSERT( R < _outM.size() );
            return _outM[R];
        }

        std::vector<VarSet>& outM( size_t R ) {
            DAI_DEBASSERT( R < _outM.size() );
            return _outM[R];
        }


        const VarSet& outM( size_t R, size_t j ) const {
            DAI_DEBASSERT( R < _outM.size() );
            DAI_DEBASSERT( j < _outM[R].size() );
            return _outM[R][j];
        }


        VarSet& outM( size_t R, size_t j ) {
            DAI_DEBASSERT( R < _outM.size() );
            DAI_DEBASSERT( j < _outM[R].size() );
            return _outM[R][j];
        }

        const SmallSet<size_t>& Rfs( size_t R ) const {
            DAI_DEBASSERT( R < _Rfs.size() );
            return _Rfs[R];
        }

        SmallSet<size_t>& Rfs( size_t R ) {
            DAI_DEBASSERT( R < _Rfs.size() );
            return _Rfs[R];
        }

        const SmallSet<size_t>& EXRs( size_t R ) const {
            DAI_DEBASSERT( R < _EXRs.size() );
            return _EXRs[R];
        }

        SmallSet<size_t>& EXRs( size_t R ) {
            DAI_DEBASSERT( R < _EXRs.size() );
            return _EXRs[R];
        }

        const SmallSet<size_t>& INRs( size_t R ) const {
            DAI_DEBASSERT( R < _INRs.size() );
            return _INRs[R];
        }

        SmallSet<size_t>& INRs( size_t R ) {
            DAI_DEBASSERT( R < _INRs.size() );
            return _INRs[R];
        }

        const Connection& M( size_t R, size_t i  ) const {
            DAI_DEBASSERT(R < _M.size());
            DAI_DEBASSERT(i < _M[R].size());
            return _M[R][i]; }

        Connection& M( size_t R, size_t i  ) {
            DAI_DEBASSERT(R < _M.size());
            DAI_DEBASSERT(i < _M[R].size());
            return _M[R][i]; }

        const std::vector<Connection>& M( size_t R ) const {
            DAI_DEBASSERT(R < _M.size());
            return _M[R]; 
        }

        std::vector<Connection>& M( size_t R ) { return _M[R]; }

        const std::vector<size_t>& var2CW( size_t i ) const { return _var2CW[i]; }


        void setRgn( std::vector<SmallSet<size_t> > regions, NeighborType neighbors, bool debugging = false );



        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 CobwebGraph& /*rg*/ ) {
            DAI_THROW(NOT_IMPLEMENTED);
        }

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


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


    protected:
        bool checkPartition( const std::vector<SmallSet<size_t> >& regions ) const;

        void setVar2CW();

        void setExtnFact();

        void setMSGs( NeighborType neighbors );

        void setCountingNumbers( bool debugging = false );

        void eraseNonMaximal( std::vector<SmallSet<size_t> >& regions );
};


} // end of namespace dai


#endif