CNLoopyPropagation.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Pierre-Henri WUILLEMIN and Christophe GONZALES  *
 *   {prenom.nom}_at_lip6.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#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