structuredBayesBall.h

Go to the documentation of this file.

#include <sstream>
#include <string>
#include <utility>

#include <agrum/core/hashTable.h>
#include <agrum/core/set.h>

#include <agrum/PRM/PRM.h>
#include <agrum/PRM/inference/PRMInference.h>

#ifndef GUM_STRUCTURED_BB_H
#  define GUM_STRUCTURED_BB_H
namespace gum {
  namespace prm {

    template < typename GUM_SCALAR >
    class StructuredBayesBall {
      public:
      // ========================================================================
      // ========================================================================

      StructuredBayesBall(const PRMInference< GUM_SCALAR >& inference);

      ~StructuredBayesBall();

      // ========================================================================
      // ========================================================================

      const std::string& key(const PRMInstance< GUM_SCALAR >* i) const;

      const std::string& key(const PRMInstance< GUM_SCALAR >& i) const;

      const Set< NodeId >&
         requisiteNodes(const PRMInstance< GUM_SCALAR >* i) const;

      const Set< NodeId >&
         requisiteNodes(const PRMInstance< GUM_SCALAR >& i) const;

      Size occurrence(const std::string& key) const;

      float liftRatio() const;

      bool exists(const PRMInstance< GUM_SCALAR >* i) const;

      bool exists(const PRMInstance< GUM_SCALAR >& i) const;


      void compute(const PRMInstance< GUM_SCALAR >* i, NodeId n);

      void compute(const PRMInstance< GUM_SCALAR >& i, NodeId n);

      bool __isHardEvidence(const PRMInstance< GUM_SCALAR >* i, NodeId n);

      private:
      StructuredBayesBall(const StructuredBayesBall& source);

      StructuredBayesBall& operator=(const StructuredBayesBall& source);

      typedef HashTable< NodeId, std::pair< bool, bool > > MarkMap;
      typedef HashTable< const PRMInstance< GUM_SCALAR >*, MarkMap* > InstanceMap;
      std::pair< bool, bool >& __getMark(InstanceMap&                     marks,
                                         const PRMInstance< GUM_SCALAR >* i,
                                         NodeId                           n);
      const PRMSlotChain< GUM_SCALAR >& __getSC(const PRMInstance< GUM_SCALAR >* i,
                                                NodeId n);

      void __clean();

      void __compute(const PRMInstance< GUM_SCALAR >* i, NodeId n);

      void __fromChild(const PRMInstance< GUM_SCALAR >* i,
                       NodeId                           n,
                       InstanceMap&                     marks);

      void __fromParent(const PRMInstance< GUM_SCALAR >* i,
                        NodeId                           n,
                        InstanceMap&                     marks);

      void __fillMaps(InstanceMap& marks);

      std::string __buildHashKey(const PRMInstance< GUM_SCALAR >* i,
                                 Set< NodeId >&                   req_nodes);

      const PRMInference< GUM_SCALAR >* __inf;

      HashTable< const PRMInstance< GUM_SCALAR >*,
                 std::pair< std::string, Set< NodeId >* > >
         __keyMap;

      HashTable< std::string, std::pair< Set< NodeId >*, Size > > __reqMap;
    };


#  ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
    extern template class StructuredBayesBall< double >;
#  endif


  } /* namespace prm */
} /* namespace gum */

#  include <agrum/PRM/inference/structuredBayesBall_tpl.h>

#endif /* GUM_STRUCTURED_BB_H */