treeep.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_treeep_h
#define __defined_libdai_treeep_h


#include <dai/dai_config.h>
#ifdef DAI_WITH_TREEEP


#include <vector>
#include <string>
#include <dai/daialg.h>
#include <dai/varset.h>
#include <dai/regiongraph.h>
#include <dai/factorgraph.h>
#include <dai/clustergraph.h>
#include <dai/weightedgraph.h>
#include <dai/jtree.h>
#include <dai/properties.h>
#include <dai/enum.h>


namespace dai {


class TreeEP : public JTree {
    private:
        Real                  _maxdiff;
        size_t                _iters;

    public:
        struct Properties {

            DAI_ENUM(TypeType,ORG,ALT);

            size_t verbose;

            size_t maxiter;

            double maxtime;

            Real tol;

            TypeType type;
        } props;

    private:

        class TreeEPSubTree {
            private:
                std::vector<Factor>  _Qa;
                std::vector<Factor>  _Qb;
                RootedTree           _RTree;
                std::vector<size_t>  _a;        
                std::vector<size_t>  _b;
                const Factor *       _I;
                VarSet               _ns;
                VarSet               _nsrem;
                Real                 _logZ;

            public:

                TreeEPSubTree() : _Qa(), _Qb(), _RTree(), _a(), _b(), _I(NULL), _ns(), _nsrem(), _logZ(0.0) {}

                TreeEPSubTree( const TreeEPSubTree &x ) : _Qa(x._Qa), _Qb(x._Qb), _RTree(x._RTree), _a(x._a), _b(x._b), _I(x._I), _ns(x._ns), _nsrem(x._nsrem), _logZ(x._logZ) {}

                TreeEPSubTree & operator=( const TreeEPSubTree& x ) {
                    if( this != &x ) {
                        _Qa         = x._Qa;
                        _Qb         = x._Qb;
                        _RTree      = x._RTree;
                        _a          = x._a;
                        _b          = x._b;
                        _I          = x._I;
                        _ns         = x._ns;
                        _nsrem      = x._nsrem;
                        _logZ       = x._logZ;
                    }
                    return *this;
                }

                TreeEPSubTree( const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector<Factor> &jt_Qa, const std::vector<Factor> &jt_Qb, const Factor *I );

                void init();

                void InvertAndMultiply( const std::vector<Factor> &Qa, const std::vector<Factor> &Qb );

                void HUGIN_with_I( std::vector<Factor> &Qa, std::vector<Factor> &Qb );

                Real logZ( const std::vector<Factor> &Qa, const std::vector<Factor> &Qb ) const;

                const Factor *& I() { return _I; }
        };

        std::map<size_t, TreeEPSubTree>  _Q;

    public:
        TreeEP() : JTree(), _maxdiff(0.0), _iters(0), props(), _Q() {}

        TreeEP( const TreeEP &x ) : JTree(x), _maxdiff(x._maxdiff), _iters(x._iters), props(x.props), _Q(x._Q) {
            for( size_t I = 0; I < nrFactors(); I++ )
                if( offtree( I ) )
                    _Q[I].I() = &factor(I);
        }

        TreeEP& operator=( const TreeEP &x ) {
            if( this != &x ) {
                JTree::operator=( x );
                _maxdiff = x._maxdiff;
                _iters   = x._iters;
                props    = x.props;
                _Q       = x._Q;
                for( size_t I = 0; I < nrFactors(); I++ )
                    if( offtree( I ) )
                        _Q[I].I() = &factor(I);
            }
            return *this;
        }


        TreeEP( const FactorGraph &fg, const PropertySet &opts );



        virtual TreeEP* clone() const { return new TreeEP(*this); }
        virtual TreeEP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new TreeEP( fg, opts ); }
        virtual std::string name() const { return "TREEEP"; }
        virtual Real logZ() const;
        virtual void init();
        virtual void init( const VarSet &/*ns*/ ) { init(); }
        virtual Real run();
        virtual Real maxDiff() const { return _maxdiff; }
        virtual size_t Iterations() const { return _iters; }
        virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; }
        virtual void setProperties( const PropertySet &opts );
        virtual PropertySet getProperties() const;
        virtual std::string printProperties() const;

    private:
        void construct( const FactorGraph& fg, const RootedTree& tree );
        bool offtree( size_t I ) const { return (fac2OR(I) == -1U); }
};


} // end of namespace dai


#endif


#endif