credalNet.h

Go to the documentation of this file.

#ifndef __CREDAL_NET__H__
#define __CREDAL_NET__H__

#include <agrum/agrum.h>

#include <iostream>
#include <vector>

#ifdef HAVE_UNISTD_H
#  include <unistd.h>
#else
#  include <agrum/core/mvsc/unistd.h>
#endif

//#include <sys/wait.h>
#include <algorithm>
#include <cstdlib>
#include <fcntl.h>
#include <fstream>
#include <set>
#include <sstream>
#include <string>
#include <sys/stat.h>

#include <utility>   

#include <agrum/core/math/math.h>
#include <agrum/BN/BayesNet.h>
#include <agrum/BN/io/BIF/BIFReader.h>
#include <agrum/BN/io/BIF/BIFWriter.h>
#include <agrum/core/exceptions.h>

#include <agrum/core/math/pow.h>   // custom pow functions with integers, faster implementation
#include <agrum/core/math/rational.h>   // custom decimal to rational

#include <agrum/CN/LrsWrapper.h>

#include <agrum/core/OMPThreads.h>

// 64 bits for windows (long is 32 bits)
#ifdef _MSC_VER
typedef __int64          int64_t;
typedef unsigned __int64 uint64_t;
#else
#  include <stdint.h>
#endif

namespace gum {
  namespace credal {

    template < typename GUM_SCALAR >
    class CredalNet {
      public:
      enum class NodeType : char { Precise, Credal, Vacuous, Indic };


      CredalNet();

      CredalNet(const std::string& src_min_num,
                const std::string& src_max_den = "");

      CredalNet(
         const BayesNet< GUM_SCALAR >& src_min_num,
         const BayesNet< GUM_SCALAR >& src_max_den = BayesNet< GUM_SCALAR >());

      ~CredalNet();



      NodeId addVariable(const std::string& name, const Size& card);

      void addArc(const NodeId& tail, const NodeId& head);

      void setCPTs(
         const NodeId&                                                  id,
         const std::vector< std::vector< std::vector< GUM_SCALAR > > >& cpt);

      void setCPT(const NodeId&                                   id,
                  Size&                                           entry,
                  const std::vector< std::vector< GUM_SCALAR > >& cpt);

      void setCPT(const NodeId&                                   id,
                  Instantiation                                   ins,
                  const std::vector< std::vector< GUM_SCALAR > >& cpt);

      void fillConstraints(const NodeId&                    id,
                           const std::vector< GUM_SCALAR >& lower,
                           const std::vector< GUM_SCALAR >& upper);

      void fillConstraint(const NodeId&                    id,
                          const Idx&                       entry,
                          const std::vector< GUM_SCALAR >& lower,
                          const std::vector< GUM_SCALAR >& upper);

      void fillConstraint(const NodeId&                    id,
                          Instantiation                    ins,
                          const std::vector< GUM_SCALAR >& lower,
                          const std::vector< GUM_SCALAR >& upper);

      Instantiation instantiation(const NodeId& id);

      Size domainSize(const NodeId& id);



      void bnToCredal(const GUM_SCALAR beta,
                      const bool       oneNet,
                      const bool       keepZeroes = false);

      void intervalToCredalWithFiles();

      void intervalToCredal();

      void lagrangeNormalization();

      void idmLearning(const Idx s = 0, const bool keepZeroes = false);

      void approximatedBinarization();


      // other utility member methods
      // PH void saveCNet ( const std::string &cn_path ) const;
      // PH void loadCNet ( const std::string &src_cn_path );

      void saveBNsMinMax(const std::string& min_path,
                         const std::string& max_path) const;

      // PH void vacants ( int &result ) const;
      // PH void notVacants ( int &result ) const;
      // PH void averageVertices ( GUM_SCALAR &result ) const;

      std::string toString() const;
      // PH void toPNG ( const std::string &png_path ) const;

      void computeCPTMinMax();   // REDO THIS IN PRIVATE !!!


      const BayesNet< GUM_SCALAR >& src_bn() const;

      const BayesNet< GUM_SCALAR >& current_bn() const;

      const NodeProperty<
         std::vector< std::vector< std::vector< GUM_SCALAR > > > >&
         credalNet_currentCpt() const;

      const NodeProperty<
         std::vector< std::vector< std::vector< GUM_SCALAR > > > >&
         credalNet_srcCpt() const;

      NodeType currentNodeType(const NodeId& id) const;

      NodeType nodeType(const NodeId& id) const;

      const GUM_SCALAR& epsilonMin() const;

      const GUM_SCALAR& epsilonMax() const;

      const GUM_SCALAR& epsilonMean() const;

      const bool isSeparatelySpecified() const;

      const bool hasComputedCPTMinMax() const;

      const std::vector< std::vector< GUM_SCALAR > >& get_CPT_min() const;

      const std::vector< std::vector< GUM_SCALAR > >& get_CPT_max() const;

      // PH const std::vector< std::vector< NodeId > > & var_bits() const;


      protected:
      private:
      GUM_SCALAR __precisionC;   // = 1e6;
      GUM_SCALAR __deltaC;   // = 5;

      GUM_SCALAR __epsilonMin;
      GUM_SCALAR __epsilonMax;
      GUM_SCALAR __epsilonMoy;

      GUM_SCALAR __epsRedund;   //= 1e-6;

      GUM_SCALAR __epsF;   // = 1e-6;
      GUM_SCALAR __denMax;   // = 1e6; // beware LRS

      GUM_SCALAR __precision;   // = 1e6; // beware LRS

      bool __separatelySpecified;

      BayesNet< GUM_SCALAR > __src_bn;

      BayesNet< GUM_SCALAR > __src_bn_min;
      BayesNet< GUM_SCALAR > __src_bn_max;

      BayesNet< GUM_SCALAR >* __current_bn;   // = nullptr;

      NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >
         __credalNet_src_cpt;

      NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >*
         __credalNet_current_cpt;   // =  nullptr;

      NodeProperty< std::vector< NodeId > > __var_bits;

      NodeProperty< NodeType > __original_nodeType;
      NodeProperty< NodeType >* __current_nodeType;   // = nullptr;

      bool __hasComputedCPTMinMax;
      typename std::vector< std::vector< GUM_SCALAR > > __binCptMin;

      typename std::vector< std::vector< GUM_SCALAR > > __binCptMax;

      void __sort_varType();

      int __find_dNode_card(
         const std::vector< std::vector< std::vector< GUM_SCALAR > > >& var_cpt)
         const;

      void __intervalToCredal();

      void __initParams();

      void __initCNNets(const std::string& src_min_num,
                        const std::string& src_max_den);

      void __initCNNets(const BayesNet< GUM_SCALAR >& src_min_num,
                        const BayesNet< GUM_SCALAR >& src_max_den);

      void __bnCopy(BayesNet< GUM_SCALAR >& bn_dest);

      // void __H2Vcdd ( const std::vector< std::vector< GUM_SCALAR > > & h_rep,
      // std::vector< std::vector< GUM_SCALAR > > & v_rep ) const;
      void __H2Vlrs(const std::vector< std::vector< GUM_SCALAR > >& h_rep,
                    std::vector< std::vector< GUM_SCALAR > >&       v_rep) const;

    };   // CredalNet


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

  }   // namespace credal
}   // namespace gum

#include <agrum/CN/credalNet_tpl.h>

#endif   // __CREDAL_NET__H__