daialg.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_daialg_h
#define __defined_libdai_daialg_h


#include <string>
#include <iostream>
#include <vector>
#include <dai/factorgraph.h>
#include <dai/regiongraph.h>
#include <dai/cobwebgraph.h>
#include <dai/properties.h>


namespace dai {



class InfAlg {
    public:

        virtual ~InfAlg() {}

        virtual InfAlg* clone() const = 0;


        virtual InfAlg* construct( const FactorGraph &fg, const PropertySet &opts ) const = 0;


        virtual std::string name() const = 0;

        virtual std::string identify() const {
            return name() + printProperties();
        }

        virtual FactorGraph &fg() = 0;

        virtual const FactorGraph &fg() const = 0;



        virtual void init() = 0;


        virtual void init( const VarSet &vs ) = 0;


        virtual Real run() = 0;


        virtual Factor belief( const Var &v ) const { return belief( VarSet(v) ); }


        virtual Factor belief( const VarSet &vs ) const = 0;


        virtual Factor beliefV( size_t i ) const { return belief( fg().var(i) ); }


        virtual Factor beliefF( size_t I ) const { return belief( fg().factor(I).vars() ); }


        virtual std::vector<Factor> beliefs() const = 0;


        virtual Real logZ() const = 0;


        virtual std::vector<size_t> findMaximum() const { DAI_THROW(NOT_IMPLEMENTED); }


        virtual Real maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); };


        virtual size_t Iterations() const { DAI_THROW(NOT_IMPLEMENTED); };


        virtual void setMaxIter( size_t /*maxiter*/ ) { DAI_THROW(NOT_IMPLEMENTED); }



        virtual void clamp( size_t i, size_t x, bool backup = false ) = 0;


        virtual void makeCavity( size_t i, bool backup = false ) = 0;


        virtual void makeRegionCavity( std::vector<size_t> facInds, bool backup = false ) = 0;



        virtual void backupFactor( size_t I ) = 0;

        virtual void backupFactors( const VarSet &vs ) = 0;

        virtual void restoreFactor( size_t I ) = 0;
        virtual void restoreFactors( const VarSet &vs ) = 0;



        virtual void setProperties( const PropertySet &opts ) = 0;
        virtual PropertySet getProperties() const = 0;
        virtual std::string printProperties() const = 0;
};



template <class GRM>
class DAIAlg : public InfAlg, public GRM {
    public:

        DAIAlg() : InfAlg(), GRM() {}

        DAIAlg( const GRM &grm ) : InfAlg(), GRM(grm) {}


        FactorGraph &fg() { return (FactorGraph &)(*this); }

        const FactorGraph &fg() const { return (const FactorGraph &)(*this); }



        void clamp( size_t i, size_t x, bool backup = false ) { GRM::clamp( i, x, backup ); }


        void makeCavity( size_t i, bool backup = false ) { GRM::makeCavity( i, backup ); }


        void makeRegionCavity( std::vector<size_t> facInds, bool backup ){ GRM::makeRegionCavity( facInds, backup ); }


        void backupFactor( size_t I ) { GRM::backupFactor( I ); }
        void backupFactors( const VarSet &vs ) { GRM::backupFactors( vs ); }

        void restoreFactor( size_t I ) { GRM::restoreFactor( I ); }
        void restoreFactors( const VarSet &vs ) { GRM::restoreFactors( vs ); }
        void restoreFactors() { GRM::restoreFactors(); }
};


typedef DAIAlg<FactorGraph> DAIAlgFG;

typedef DAIAlg<RegionGraph> DAIAlgRG;

typedef DAIAlg<CobwebGraph> DAIAlgCG;



Factor calcMarginal( const InfAlg& obj, const VarSet& vs, bool reInit );



std::vector<Factor> calcPairBeliefs( const InfAlg& obj, const VarSet& vs, bool reInit, bool accurate=false );



std::vector<size_t> findMaximum( const InfAlg& obj );


} // end of namespace dai


#endif