CNLoopyPropagation.h

Go to the documentation of this file.

#ifndef __CN_LOOPY_PROPAGATION__H__
#define __CN_LOOPY_PROPAGATION__H__

#include <cstdlib>
#include <ctime>
#include <limits>

#include <agrum/CN/credalNet.h>
#include <agrum/CN/inferenceEngine.h>
#include <agrum/core/approximations/approximationScheme.h>
#include <agrum/core/math/pow.h>
#include <agrum/core/sequence.h>

#define _INF std::numeric_limits< GUM_SCALAR >::infinity()

namespace gum {
  namespace credal {

    template < typename GUM_SCALAR >
    class CNLoopyPropagation : public InferenceEngine< GUM_SCALAR > {
      public:
      using msg = std::vector< Potential< GUM_SCALAR >* >;
      using cArcP = const Arc*;

      enum class InferenceType : char {
        nodeToNeighbours, 
        ordered, 
        randomOrder 
      };


      void makeInference();



      void inferenceType(InferenceType inft);

      InferenceType inferenceType();



      void eraseAllEvidence();

      void saveInference(const std::string& path);



      explicit CNLoopyPropagation(const CredalNet< GUM_SCALAR >& cnet);
      virtual ~CNLoopyPropagation();

      protected:

      void _initialize();



      void _makeInferenceNodeToNeighbours();
      void _makeInferenceByOrderedArcs();
      void _makeInferenceByRandomOrder();

      void _updateMarginals();

      void _msgL(
         const NodeId X,
         const NodeId demanding_parent);   // allways sent from X to demanding_X

      void _compute_ext(GUM_SCALAR&                msg_l_min,
                        GUM_SCALAR&                msg_l_max,
                        std::vector< GUM_SCALAR >& lx,
                        GUM_SCALAR&                num_min,
                        GUM_SCALAR&                num_max,
                        GUM_SCALAR&                den_min,
                        GUM_SCALAR&                den_max);

      void _compute_ext(std::vector< std::vector< GUM_SCALAR > >& combi_msg_p,
                        const NodeId&                             id,
                        GUM_SCALAR&                               msg_l_min,
                        GUM_SCALAR&                               msg_l_max,
                        std::vector< GUM_SCALAR >&                lx,
                        const Idx&                                pos);

      void _enum_combi(
         std::vector< std::vector< std::vector< GUM_SCALAR > > >& msgs_p,
         const NodeId&                                            id,
         GUM_SCALAR&                                              msg_l_min,
         GUM_SCALAR&                                              msg_l_max,
         std::vector< GUM_SCALAR >&                               lx,
         const Idx&                                               pos);

      void _msgP(const NodeId X, const NodeId demanding_child);

      void _enum_combi(
         std::vector< std::vector< std::vector< GUM_SCALAR > > >& msgs_p,
         const NodeId&                                            id,
         GUM_SCALAR&                                              msg_p_min,
         GUM_SCALAR&                                              msg_p_max);

      void _compute_ext(std::vector< std::vector< GUM_SCALAR > >& combi_msg_p,
                        const NodeId&                             id,
                        GUM_SCALAR&                               msg_p_min,
                        GUM_SCALAR&                               msg_p_max);

      void _refreshLMsPIs(bool refreshIndic = false);

      GUM_SCALAR _calculateEpsilon();



      void _computeExpectations();

      void _updateIndicatrices();


      NodeProperty< bool > _update_p;
      NodeProperty< bool > _update_l;

      NodeSet active_nodes_set;
      NodeSet next_active_nodes_set;

      NodeProperty< NodeSet* > _msg_l_sent;

      ArcProperty< GUM_SCALAR > _ArcsL_min;
      ArcProperty< GUM_SCALAR > _ArcsP_min;
      NodeProperty< GUM_SCALAR > _NodesL_min;
      NodeProperty< GUM_SCALAR > _NodesP_min;

      ArcProperty< GUM_SCALAR > _ArcsL_max;
      ArcProperty< GUM_SCALAR > _ArcsP_max;
      NodeProperty< GUM_SCALAR > _NodesL_max;
      NodeProperty< GUM_SCALAR > _NodesP_max;

      bool _InferenceUpToDate;

      private:
      using __infE = InferenceEngine< GUM_SCALAR >;

      InferenceType __inferenceType;

      const CredalNet< GUM_SCALAR >* __cn;

      const IBayesNet< GUM_SCALAR >* __bnet;

      // typedef const CredalNet< GUM_SCALAR > * (infE::*cnfunc) ();
      // cnfunc getCN = &infE::getCN;
      public:
      virtual void insertEvidenceFile(const std::string& path) {
        InferenceEngine< GUM_SCALAR >::insertEvidenceFile(path);
      };
    };


#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
    extern template class CNLoopyPropagation< double >;
#endif
  }   // namespace credal
}   // namespace gum

#include <agrum/CN/CNLoopyPropagation_tpl.h>

#endif