gum::credal::CredalNet< GUM_SCALAR > Class Template Reference

Class template representing a Credal Network. More...

#include <agrum/CN/credalNet.h>

Collaboration diagram for gum::credal::CredalNet< GUM_SCALAR >:

Public Types
enum class	NodeType : char { Precise , Credal , Vacuous , Indic }
	NodeType to speed-up computations in some algorithms. More...

Public Member Functions
void	saveBNsMinMax (std::string_view min_path, std::string_view max_path)
	If this CredalNet was built over a perturbed BayesNet, one can save the intervals as two BayesNet.
std::string	toString () const
void	computeBinaryCPTMinMax ()
	Used with binary networks to speed-up L2U inference.
Constructors / Destructors
	CredalNet ()
	Constructor used to create a CredalNet step by step, i.e.
	CredalNet (std::string_view src_min_num, std::string_view src_max_den="")
	Constructor for interval defined credal network which takes 2 BayesNet file path.
	CredalNet (const BayesNet< GUM_SCALAR > &src_min_num, const BayesNet< GUM_SCALAR > &src_max_den=BayesNet< GUM_SCALAR >())
	Constructor for interval defined credal network which takes 2 BayesNet.
	~CredalNet ()
	Destructor.
Credal network creation
NodeId	addVariable (std::string_view name, const Size &card)
	Adds a discrete node into the network.
void	addArc (const NodeId &tail, const NodeId &head)
	Adds an arc between two nodes.
void	setCPTs (const NodeId &id, const std::vector< std::vector< std::vector< GUM_SCALAR > > > &cpt)
	Set the vertices of the credal sets ( all of the conditionals ) of a given node
void	setCPT (const NodeId &id, const Size &entry, const std::vector< std::vector< GUM_SCALAR > > &cpt)
	Set the vertices of one credal set of a given node ( any instantiation index )
void	setCPT (const NodeId &id, Instantiation ins, const std::vector< std::vector< GUM_SCALAR > > &cpt)
	Set the vertices of one credal set of a given node ( any instantiation )
void	fillConstraints (const NodeId &id, const std::vector< GUM_SCALAR > &lower, const std::vector< GUM_SCALAR > &upper)
	Set the interval constraints of the credal sets of a given node (all instantiations )
void	fillConstraint (const NodeId &id, const Idx &entry, const std::vector< GUM_SCALAR > &lower, const std::vector< GUM_SCALAR > &upper)
	Set the interval constraints of a credal set of a given node ( from an instantiation index )
void	fillConstraint (const NodeId &id, Instantiation ins, const std::vector< GUM_SCALAR > &lower, const std::vector< GUM_SCALAR > &upper)
	Set the interval constraints of a credal sets of a given node ( from an instantiation )
Instantiation	instantiation (const NodeId &id)
	Get an Instantiation from a node id, useful to fill the constraints of the network
Size	domainSize (const NodeId &id)
	Get the cardinality of a node
Public manipulation methods
void	bnToCredal (GUM_SCALAR beta, bool oneNet, bool keepZeroes)
	Perturbates the BayesNet provided as input for this CredalNet by generating intervals instead of point probabilities and then computes each vertex of each credal set.
void	bnToCredal (GUM_SCALAR beta, bool oneNet)
	Perturbates the BayesNet provided as input for this CredalNet by generating intervals instead of point probabilities and then computes each vertex of each credal set.
void	intervalToCredalWithFiles ()
void	intervalToCredal ()
	Computes the vertices of each credal set according to their interval definition (uses lrs).
void	lagrangeNormalization ()
	Normalize counts of a BayesNet storing counts of each events such that no probability is 0.
void	idmLearning (const Idx s=0, const bool keepZeroes=false)
	Learns parameters from a BayesNet storing counts of events.
void	approximatedBinarization ()
	Approximate binarization.
Getters and setters
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
bool	isSeparatelySpecified () const
bool	hasComputedBinaryCPTMinMax () const
const std::vector< std::vector< GUM_SCALAR > > &	get_binaryCPT_min () const
	Used with binary networks to speed-up L2U inference.
const std::vector< std::vector< GUM_SCALAR > > &	get_binaryCPT_max () const
	Used with binary networks to speed-up L2U inference.

Private Member Functions
void	_sort_varType_ ()
	Set the NodeType of each node
int	_find_dNode_card_ (const std::vector< std::vector< std::vector< GUM_SCALAR > > > &var_cpt) const
void	_intervalToCredal_ ()
	Computes the vertices of each credal set according to their interval definition (does not use lrs).
void	_initParams_ ()
	Initialize private constant variables after the Constructor has been called.
void	_initCNNets_ (std::string_view src_min_num, std::string_view src_max_den)
	Initialize private BayesNet variables after the Constructor has been called.
void	_initCNNets_ (const BayesNet< GUM_SCALAR > &src_min_num, const BayesNet< GUM_SCALAR > &src_max_den)
	Initialize private BayesNet variables after the Constructor has been called.
void	_bnCopy_ (BayesNet< GUM_SCALAR > &bn_dest)
void	_H2Vlrs_ (const std::vector< std::vector< GUM_SCALAR > > &h_rep, std::vector< std::vector< GUM_SCALAR > > &v_rep) const

Private Attributes
GUM_SCALAR	_precisionC_
	1e6 by default, used by fracC as precision.
GUM_SCALAR	_deltaC_
	5 by default, used by fracC as number of decimals.
GUM_SCALAR	_epsilonMin_
	The lowest perturbation of the BayesNet provided as input for this CredalNet.
GUM_SCALAR	_epsilonMax_
	The highest perturbation of the BayesNet provided as input for this CredalNet.
GUM_SCALAR	_epsilonMoy_
	The average perturbation of the BayesNet provided as input for this CredalNet.
GUM_SCALAR	_epsRedund_
	Value under which a decimal number is considered to be zero when computing redundant vertices.
GUM_SCALAR	_epsF_
	Value under which a decimal number is considered to be zero when using farey.
GUM_SCALAR	_denMax_
	Highest possible denominator allowed when using farey.
GUM_SCALAR	_precision_
	Precision used by frac.
bool	_separatelySpecified_
	TRUE if this CredalNet is separately and interval specified, FALSE otherwise.
BayesNet< GUM_SCALAR >	_src_bn_
	Original BayesNet (used as a DAG).
BayesNet< GUM_SCALAR >	_src_bn_min_
	BayesNet used to store lower probabilities.
BayesNet< GUM_SCALAR >	_src_bn_max_
	BayesNet used to store upper probabilities.
BayesNet< GUM_SCALAR > *	_current_bn_
	Up-to-date BayesNet (used as a DAG).
NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >	_credalNet_src_cpt_
	This CredalNet original CPTs.
NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > *	_credalNet_current_cpt_
	This CredalNet up-to-date CPTs.
NodeProperty< std::vector< NodeId > >	_var_bits_
	Corresponding bits of each variable.
NodeProperty< NodeType >	_original_nodeType_
	The NodeType of each node from the ORIGINAL network.
NodeProperty< NodeType > *	_current_nodeType_
	The NodeType of each node from the up-to-date network.
bool	_hasComputedBinaryCPTMinMax_
	Used by L2U, to know if lower and upper probabilities over the second modality has been stored in order to speed-up the algorithm.
std::vector< std::vector< GUM_SCALAR > >	_binCptMin_
	Used with binary networks to speed-up L2U inference.
std::vector< std::vector< GUM_SCALAR > >	_binCptMax_
	Used with binary networks to speed-up L2U inference.

Detailed Description

template<GUM_Numeric GUM_SCALAR>
class gum::credal::CredalNet< GUM_SCALAR >

Class template representing a Credal Network.

Template Parameters

GUM_SCALAR

A floating type ( float, GUM_SCALAR, long GUM_SCALAR ... ).

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN(_at_LIP6)

Definition at line 97 of file credalNet.h.

Member Enumeration Documentation

NodeType

template<GUM_Numeric GUM_SCALAR>

enum class gum::credal::CredalNet::NodeType : char

strong

NodeType to speed-up computations in some algorithms.

Enumerator
Precise
Credal
Vacuous
Indic

Definition at line 100 of file credalNet.h.

: char { Precise, Credal, Vacuous, Indic };

Constructor & Destructor Documentation

CredalNet() [1/3]

template<GUM_Numeric GUM_SCALAR>

gum::credal::CredalNet< GUM_SCALAR >::CredalNet

(

)

Constructor used to create a CredalNet step by step, i.e.

node by node, arc by arc, manually filling tensors.

Definition at line 55 of file credalNet_tpl.h.

                                       {
      _initParams_();
 
      _src_bn_     = BayesNet< GUM_SCALAR >();
      _src_bn_min_ = BayesNet< GUM_SCALAR >();
      _src_bn_max_ = BayesNet< GUM_SCALAR >();
 
      GUM_CONSTRUCTOR(CredalNet);
    }

References CredalNet(), _initParams_(), _src_bn_, _src_bn_max_, and _src_bn_min_.

Referenced by CredalNet(), CredalNet(), CredalNet(), and ~CredalNet().

Here is the call graph for this function:

Here is the caller graph for this function:

CredalNet() [2/3]

template<GUM_Numeric GUM_SCALAR>

gum::credal::CredalNet< GUM_SCALAR >::CredalNet	(	std::string_view	src_min_num,
		std::string_view	src_max_den = "" )

Constructor for interval defined credal network which takes 2 BayesNet file path.

One can also provide a single BayesNet to perturb it's probability distributions into credal sets according to another BayesNet containing the amount cases, for each node, of each parent instantiation met during learning, i.e. \( p(X = 0 \mid pa(X) = j) = N_{pa(X) = j} \).

Parameters

src_min_num	The path to a BayesNet which contains lower probabilities.
src_max_den	The ( optional ) path to a BayesNet which contains upper probabilities.

Definition at line 413 of file credalNet_tpl.h.

                                                                                             {
      _initParams_();
      _initCNNets_(src_min_num, src_max_den);
 
      GUM_CONSTRUCTOR(CredalNet);
    }

References CredalNet(), _initCNNets_(), and _initParams_().

Here is the call graph for this function:

CredalNet() [3/3]

template<GUM_Numeric GUM_SCALAR>

gum::credal::CredalNet< GUM_SCALAR >::CredalNet	(	const BayesNet< GUM_SCALAR > &	src_min_num,
		const BayesNet< GUM_SCALAR > &	src_max_den = BayesNet< GUM_SCALAR >() )

Constructor for interval defined credal network which takes 2 BayesNet.

One can also provide a single BayesNet in order to perturb it's probability distributions into credal sets according to another BayesNet containing the number of cases, for each node, of each parent instantiation met during learning, i.e. \( p(X = 0 \mid pa(X) = j) = N_{pa(X) = j} \).

Parameters

src_min_num	The BayesNet which contains lower probabilities.
src_max_den	The ( optional ) BayesNet which contains upper probabilities.

Definition at line 421 of file credalNet_tpl.h.

                                                                                  {
      _initParams_();
      _initCNNets_(src_min_num, src_max_den);
 
      GUM_CONSTRUCTOR(CredalNet);
    }

References CredalNet(), _initCNNets_(), and _initParams_().

Here is the call graph for this function:

~CredalNet()

template<GUM_Numeric GUM_SCALAR>

gum::credal::CredalNet< GUM_SCALAR >::~CredalNet

(

)

Destructor.

Definition at line 430 of file credalNet_tpl.h.

                                        {
      if (_current_bn_ != nullptr) delete _current_bn_;
 
      if (_credalNet_current_cpt_ != nullptr) delete _credalNet_current_cpt_;
 
      if (_current_nodeType_ != nullptr) delete _current_nodeType_;
 
      GUM_DESTRUCTOR(CredalNet);
    }

References CredalNet(), _credalNet_current_cpt_, _current_bn_, and _current_nodeType_.

Here is the call graph for this function:

Member Function Documentation

_bnCopy_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::_bnCopy_ ( BayesNet< GUM_SCALAR > & bn_dest )

private

Deprecated

Warning

May be useless since the BayesNet copy constructor seems to now work well (parent order is preserved).

Copy the up-to-date BayesNet associated with this CredalNet. Since all we care about is the DAG, only arcs are copied. Because the order with which arcs are created is important, the function iterates over the CPTs variables to be sure parent order stays the same from a net to it's copy.

Parameters

bn_dest

The reference to the new copy

Definition at line 1419 of file credalNet_tpl.h.

                                                                       {
      const BayesNet< GUM_SCALAR >* bn_ptr = (_current_bn_ != nullptr) ? _current_bn_ : &_src_bn_;
 
      for (auto node: bn_ptr->nodes())
        dest.add(bn_ptr->variable(node));
 
      dest.beginTopologyTransformation();
 
      for (auto node: bn_ptr->nodes()) {
        for (auto parent_idIt: bn_ptr->cpt(node).variablesSequence()) {
          if (bn_ptr->nodeId(*parent_idIt) != node) dest.addArc(bn_ptr->nodeId(*parent_idIt), node);
        }   // end of : for each parent in order of appearence
      }   // end of : for each variable
 
      dest.endTopologyTransformation();
    }

References _current_bn_, and _src_bn_.

_find_dNode_card_()

template<GUM_Numeric GUM_SCALAR>

int gum::credal::CredalNet< GUM_SCALAR >::_find_dNode_card_ ( const std::vector< std::vector< std::vector< GUM_SCALAR > > > & var_cpt ) const

private

Deprecated

Parameters

var_cpt

The reference to a node CPT which may need a Decision Node.

Returns

Returns the cardinality of the Decision Node.

Definition at line 1407 of file credalNet_tpl.h.

                                                                                {
      Size vertices_size = 0;
 
      for (auto entry = var_cpt.cbegin(), theEnd = var_cpt.cend(); entry != theEnd; ++entry) {
        if (entry->size() > vertices_size) vertices_size = Size(entry->size());
      }
 
      return int(vertices_size);
    }

_H2Vlrs_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::_H2Vlrs_ ( const std::vector< std::vector< GUM_SCALAR > > & h_rep, std::vector< std::vector< GUM_SCALAR > > & v_rep ) const

private

Deprecated

one should use the LrsWrapper class Computes the V-representation of a credal set, i.e. it's vertices, from it's H-representation, i.e. the hyper-plan inequalities. Uses lrs.

Parameters

h_rep	A constant reference to the H-representation of a credal set.
v_rep	A reference to the V-representation of the same credal set.

Definition at line 1489 of file credalNet_tpl.h.

                                                                                              {
      // write H rep file
      int64_t num, den;
 
      std::string sinefile = getUniqueFileName();   // generate unique file name, we
      // need to add .ine or .ext for lrs
      // to know which input it is (Hrep
      // to Vrep or Vrep to Hrep)
      sinefile += ".ine";
 
      std::ofstream h_file(sinefile.c_str(), std::ios::out | std::ios::trunc);
 
      if (!h_file.good())
        GUM_ERROR(IOError, " __H2Vlrs : could not open lrs input file : " << sinefile)
 
      h_file << "H - representation\n";
      h_file << "begin\n";
      h_file << h_rep.size() << ' ' << h_rep[0].size() << " rational\n";
 
      for (auto it = h_rep.cbegin(), theEnd = h_rep.cend(); it != theEnd; ++it) {
        for (auto it2 = it->cbegin(), theEnd2 = it->cend(); it2 != theEnd2; ++it2) {
          // get integer fraction from decimal value
          // smallest numerator & denominator is farley, also
          // best precision
          Rational< GUM_SCALAR >::farey(num,
                                        den,
                                        ((*it2 > 0) ? *it2 : -*it2),
                                        int64_t(_denMax_),
                                        _epsF_);
 
          h_file << ((*it2 > 0) ? num : -num) << '/' << den << ' ';
        }
 
        h_file << '\n';
      }
 
      h_file << "end\n";
      h_file.close();
 
      // call lrs
      std::string extfile(sinefile);
      extfile += ".ext";
 
      std::string lrs_arg0    = "lrs";
      std::string lrs_arg1    = sinefile;
      std::string lrs_arg2    = extfile;
      char*       lrs_argv[3] = {lrs_arg0.data(), lrs_arg1.data(), lrs_arg2.data()};
 
      // it may need to redirect stdout to a file
      lrs_main(3, lrs_argv);
 
      // read V rep file
      std::ifstream v_file(extfile.c_str() /*extfilename.c_str()*/, std::ios::in);
 
      if (!v_file.good()) GUM_ERROR(IOError, " __H2Vlrs : could not open lrs output file : ")
 
      std::string line, tmp;
      char *      cstr, *p;
      GUM_SCALAR  probability;
 
      std::string::size_type pos;
      bool                   keep_going = true;
      // int vertices;
 
      std::vector< GUM_SCALAR > vertex;
 
      v_file.ignore(256, 'l');
 
      while (v_file.good() && keep_going) {
        getline(v_file, line);
 
        if (line.size() == 0) continue;
        else if (line.compare("end") == 0) {
          keep_going = false;
          // this is to get vertices number :
          /*getline ( v_file, line );
          std::string::size_type pos, end_pos;
          pos = line.find ( "vertices = " );
          end_pos = line.find ( "rays", pos + 9 );
          vertices = atoi ( line.substr ( pos + 9, end_pos - pos - 9 ).c_str()
          );*/
          break;
        } else if (line[1] != '1') {
          GUM_ERROR(IOError,
                    " __H2Vlrs : reading something other than a vertex from "
                    "lrs output file : ");
        }
 
        line = line.substr(2);
        cstr = new char[line.size() + 1];
        strcpy(cstr, line.c_str());
 
        p = strtok(cstr, " ");
 
        while (p != nullptr) {
          tmp = p;
 
          if (tmp.compare("1") == 0 || tmp.compare("0") == 0)
            probability = GUM_SCALAR(atof(tmp.c_str()));
          else {
            pos         = tmp.find("/");
            probability = GUM_SCALAR(atof(tmp.substr(0, pos).c_str())
                                     / atof(tmp.substr(pos + 1, tmp.size()).c_str()));
          }
 
          vertex.push_back(probability);
          p = strtok(nullptr, " ");
        }   // end of : for all tokens
 
        delete[] cstr;
 
        // compute is_redund using multiple threads:
        // compute the max number of threads to use (avoid nested threads)
        const Size nb_threads = ThreadExecutor::nbRunningThreadsExecutors() == 0
                                  ? gum::getNumberOfThreads()
                                  : 1;   // no nested multithreading
 
        const auto nsize           = v_rep.size();
        const auto real_nb_threads = std::min(nb_threads, nsize);
 
        // prepare the data used by the threads
        const auto ranges = gum::dispatchRangeToThreads(0, nsize, (unsigned int)(real_nb_threads));
        std::vector< Size > t_redund(real_nb_threads);   // use Size to avoid false sharing
 
        // create the function to be executed by the threads
        auto threadedExec = [this, ranges, &t_redund, vertex, v_rep](const std::size_t this_thread,
                                                                     const std::size_t nb_threads) {
          const auto vsize         = vertex.size();
          auto&      thread_redund = t_redund[this_thread];
 
          for (Idx i = ranges[this_thread].first, end = ranges[this_thread].second; i < end; i++) {
            thread_redund = 1;
            for (Idx modality = 0; modality < vsize; ++modality) {
              if (std::fabs(vertex[modality] - v_rep[i][modality]) > _epsRedund_) {
                thread_redund = 0;
                break;
              }
            }
 
            if (thread_redund) return;
          }
        };
 
        // launch the threads
        ThreadExecutor::execute(real_nb_threads, threadedExec);
 
        // aggregate the results
        bool is_redund = false;
        for (const auto thread_redund: t_redund) {
          if (thread_redund) {
            is_redund = true;
            break;
          }
        }
 
 
        /*
        // old openMP code:
        #pragma omp parallel
        {
          int this_thread = threadsOMP::getThreadNumber();
          int num_threads = threadsOMP::getNumberOfRunningThreads();
 
          auto begin_pos = (this_thread + 0) * v_rep.size() / num_threads;
          auto end_pos   = (this_thread + 1) * v_rep.size() / num_threads;
 
          for (auto p = begin_pos; p < end_pos; p++) {
          #pragma omp flush(is_redund)
 
            if (is_redund) break;
 
            bool thread_redund = true;
 
            auto vsize = vertex.size();
 
            for (Size modality = 0; modality < vsize; modality++) {
              if (std::fabs(vertex[modality] - v_rep[p][modality]) > _epsRedund_) {
                thread_redund = false;
                break;
              }
            }
 
            if (thread_redund) {
              is_redund = true;
              #pragma omp flush(is_redund)
              int i=0; // this line to work around a weird syntax error with msvc
            }
          }   // end of : each thread for
        }     // end of : parallel
        */
 
        if (!is_redund) v_rep.push_back(vertex);
 
        vertex.clear();
      }   // end of : file
 
      v_file.close();
 
      if (std::remove(sinefile.c_str()) != 0) GUM_ERROR(IOError, "error removing : " + sinefile)
 
      if (std::remove(extfile.c_str()) != 0) GUM_ERROR(IOError, "error removing : " + extfile)
    }

References _denMax_, _epsF_, _epsRedund_, gum::dispatchRangeToThreads(), gum::threadsSTL::ThreadExecutor::execute(), gum::Rational< GUM_SCALAR >::farey(), gum::getNumberOfThreads(), gum::getUniqueFileName(), GUM_ERROR, and gum::threadsSTL::ThreadExecutor::nbRunningThreadsExecutors().

Referenced by intervalToCredalWithFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

_initCNNets_() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::_initCNNets_ ( const BayesNet< GUM_SCALAR > & src_min_num, const BayesNet< GUM_SCALAR > & src_max_den )

private

Initialize private BayesNet variables after the Constructor has been called.

Definition at line 1397 of file credalNet_tpl.h.

                                                                                          {
      _src_bn_     = src_min_num;
      _src_bn_min_ = src_min_num;
 
      if (src_max_den.size() > 0) _src_bn_max_ = src_max_den;
      else _src_bn_max_ = src_min_num;
    }

References _src_bn_, _src_bn_max_, and _src_bn_min_.

_initCNNets_() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::_initCNNets_ ( std::string_view src_min_num, std::string_view src_max_den )

private

Initialize private BayesNet variables after the Constructor has been called.

Definition at line 1380 of file credalNet_tpl.h.

                                                                           {
      BIFReader< GUM_SCALAR > reader(&_src_bn_, src_min_num);
      std::string             other;
 
      if (src_max_den.compare("") != 0) other = src_max_den;
      else other = src_min_num;
 
      BIFReader< GUM_SCALAR > reader_min(&_src_bn_min_, src_min_num);
      BIFReader< GUM_SCALAR > reader_max(&_src_bn_max_, other);
 
      reader.proceed();
      reader_min.proceed();
      reader_max.proceed();
    }

References _src_bn_, _src_bn_max_, _src_bn_min_, and gum::BIFReader< GUM_SCALAR >::proceed().

Referenced by CredalNet(), and CredalNet().

Here is the call graph for this function:

Here is the caller graph for this function:

_initParams_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::_initParams_ ( )

private

Initialize private constant variables after the Constructor has been called.

Definition at line 1353 of file credalNet_tpl.h.

                                               {
      _epsilonMin_ = 0;
      _epsilonMax_ = 0;
      _epsilonMoy_ = 0;
 
      _epsRedund_ = GUM_SCALAR(1e-6);
 
      // farey algorithm
      _epsF_   = GUM_SCALAR(1e-6);
      _denMax_ = GUM_SCALAR(1e6);   // beware LRSWrapper
 
      // continued fractions, beware LRSWrapper
      // decimal paces ( _epsC_ *  _precisionC_ == 1)
      _precisionC_ = GUM_SCALAR(1e6);
      _deltaC_     = 5;
 
      // old custom algorithm
      _precision_ = GUM_SCALAR(1e6);   // beware LRSWrapper
 
      _current_bn_            = nullptr;
      _credalNet_current_cpt_ = nullptr;
      _current_nodeType_      = nullptr;
 
      _hasComputedBinaryCPTMinMax_ = false;
    }

References _credalNet_current_cpt_, _current_bn_, _current_nodeType_, _deltaC_, _denMax_, _epsF_, _epsilonMax_, _epsilonMin_, _epsilonMoy_, _epsRedund_, _hasComputedBinaryCPTMinMax_, _precision_, and _precisionC_.

Referenced by CredalNet(), CredalNet(), and CredalNet().

Here is the caller graph for this function:

_intervalToCredal_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::_intervalToCredal_ ( )

private

Computes the vertices of each credal set according to their interval definition (does not use lrs).

Only works with credal sets defined such that when one modality reach it's upper probability, all others are at their lowest.

Called by bnToCredal and idmLearning.

Definition at line 687 of file credalNet_tpl.h.

                                                     {
      if (!_credalNet_src_cpt_.empty()) _credalNet_src_cpt_.clear();
 
      _credalNet_src_cpt_.resize(_src_bn_.size());
 
      for (auto node: _src_bn_.nodes()) {
        const Tensor< GUM_SCALAR >* const tensor_min(&_src_bn_min_.cpt(node));
        const Tensor< GUM_SCALAR >* const tensor_max(&_src_bn_max_.cpt(node));
 
        Size var_dSize  = _src_bn_.variable(node).domainSize();
        Size entry_size = tensor_min->domainSize() / var_dSize;
 
        std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(entry_size);
 
        Instantiation ins_min(tensor_min);
        Instantiation ins_max(tensor_max);
 
        ins_min.setFirst();
        ins_max.setFirst();
 
        std::vector< GUM_SCALAR > lower(var_dSize);
        std::vector< GUM_SCALAR > upper(var_dSize);
 
        for (Size entry = 0; entry < entry_size; entry++) {
          for (Size modality = 0; modality < var_dSize; modality++, ++ins_min, ++ins_max) {
            lower[modality] = tensor_min->get(ins_min);
            upper[modality] = tensor_max->get(ins_max);
          }
 
          bool                                     all_equals = true;
          std::vector< std::vector< GUM_SCALAR > > vertices;
 
          for (Size modality = 0; modality < var_dSize; modality++) {
            if (std::fabs(upper[modality] - lower[modality]) < 1e-6) continue;
 
            all_equals = false;
            std::vector< GUM_SCALAR > vertex(var_dSize);
            vertex[modality] = upper[modality];
 
            for (Size mod = 0; mod < var_dSize; mod++) {
              if (modality != mod) vertex[mod] = lower[mod];
            }
 
            GUM_SCALAR total = 0;
 
            auto vsize = vertex.size();
 
            for (Size i = 0; i < vsize; i++)
              total += vertex[i];
 
            if (std::fabs(total - 1.) > 1e-6)
              GUM_ERROR(CPTError,
                        _src_bn_.variable(node).name()
                            << "  does not sum to one for " << entry << std::endl
                            << vertex << std::endl);
 
            vertices.push_back(vertex);
          }
 
          if (all_equals) {
            std::vector< GUM_SCALAR > vertex(var_dSize);
 
            for (Size modality = 0; modality < var_dSize; modality++)
              vertex[modality] = lower[modality];
 
            GUM_SCALAR total = 0.;
 
            auto vsize = vertex.size();
 
            for (Size i = 0; i < vsize; i++)
              total += vertex[i];
 
            if (std::fabs(total - 1.) > 1e-6)
              GUM_ERROR(CPTError,
                        _src_bn_.variable(node).name()
                            << "  does not sum to one for " << entry << std::endl
                            << vertex << std::endl);
 
            vertices.push_back(vertex);
          }
 
          var_cpt[entry] = vertices;
        }
 
        _credalNet_src_cpt_.insert(node, var_cpt);
      }   // end of : for each variable (node)
 
      // get precise/credal/vacuous status of each variable
      _sort_varType_();
      _separatelySpecified_ = true;
    }

References _credalNet_src_cpt_, _separatelySpecified_, _sort_varType_(), _src_bn_, _src_bn_max_, _src_bn_min_, GUM_ERROR, and gum::Instantiation::setFirst().

Referenced by bnToCredal(), and idmLearning().

Here is the call graph for this function:

Here is the caller graph for this function:

_sort_varType_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::_sort_varType_ ( )

private

Set the NodeType of each node

Definition at line 1694 of file credalNet_tpl.h.

                                                 {
      const BayesNet< GUM_SCALAR >* bn_ptr = (_current_bn_ != nullptr) ? _current_bn_ : &_src_bn_;
      const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >* cpt_ptr
          = (_credalNet_current_cpt_ != nullptr) ? _credalNet_current_cpt_ : &_credalNet_src_cpt_;
      NodeProperty< NodeType >* nodeType_ptr
          = (_current_nodeType_ != nullptr) ? _current_nodeType_ : &_original_nodeType_;
 
      for (auto node: bn_ptr->nodes()) {
        // indicatrices are already present
        if (nodeType_ptr->exists(node)) continue;
 
        bool precise = true, vacuous = true;
 
        for (auto entry = (*cpt_ptr)[node].cbegin(), theEnd2 = (*cpt_ptr)[node].cend();
             entry != theEnd2;
             ++entry) {
          auto vertices  = entry->size();
          auto var_dSize = (*entry)[0].size();
 
          if (precise && vertices > 1) precise = false;
 
          if (vacuous && vertices == var_dSize) {
            std::vector< bool > elem(var_dSize, false);
 
            for (auto vertex = entry->cbegin(), vEnd = entry->cend(); vertex != vEnd; ++vertex) {
              for (auto probability = vertex->cbegin(), pEnd = vertex->cend(); probability != pEnd;
                   ++probability) {
                if (*probability == 1) {
                  elem[probability - vertex->begin()] = true;
                  break;
                }
              }   // end of : for each modality
            }   // end of : for each vertex
 
            for (auto probability = elem.cbegin(); probability != elem.cend(); ++probability)
              if (*probability == false) vacuous = false;
          }   // end of : if vertices == dSize
          else
            vacuous = false;
 
          if (vacuous == false && precise == false) {
            nodeType_ptr->insert(node, NodeType::Credal);
            break;
          }
        }   // end of : for each parents entry
 
        if (vacuous) nodeType_ptr->insert(node, NodeType::Vacuous);
        else if (precise) nodeType_ptr->insert(node, NodeType::Precise);
      }   // end of : for each variable
    }

References _credalNet_current_cpt_, _credalNet_src_cpt_, _current_bn_, _current_nodeType_, _original_nodeType_, _src_bn_, Credal, gum::HashTable< Key, Val >::exists(), gum::HashTable< Key, Val >::insert(), Precise, and Vacuous.

Referenced by _intervalToCredal_(), approximatedBinarization(), intervalToCredal(), and intervalToCredalWithFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

addArc()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::addArc	(	const NodeId &	tail,
		const NodeId &	head )

Adds an arc between two nodes.

Parameters

tail	The NodeId of the tail node
head	The NodeId of the head node

Definition at line 82 of file credalNet_tpl.h.

                                                                               {
      _src_bn_.addArc(tail, head);
      _src_bn_min_.addArc(tail, head);
      _src_bn_max_.addArc(tail, head);
    }

References _src_bn_, _src_bn_max_, and _src_bn_min_.

addVariable()

template<GUM_Numeric GUM_SCALAR>

NodeId gum::credal::CredalNet< GUM_SCALAR >::addVariable	(	std::string_view	name,
		const Size &	card )

Adds a discrete node into the network.

Parameters

name	The name of the discrete variable to be added
card	The cardinality of the variable

Returns

The NodeId of the variable in the network

Definition at line 66 of file credalNet_tpl.h.

                                                                                     {
      LabelizedVariable var(name, "node " + std::string{name}, card);
 
      NodeId a = _src_bn_.add(var);
      NodeId b = _src_bn_min_.add(var);
      NodeId c = _src_bn_max_.add(var);
 
      if (a != b || a != c /*|| b != c*/)
        GUM_ERROR(OperationNotAllowed,
                  "addVariable : not the same id over all networks : " << a << ", " << b << ", "
                                                                       << c);
 
      return a;
    }

References _src_bn_, _src_bn_max_, _src_bn_min_, and GUM_ERROR.

approximatedBinarization()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::approximatedBinarization

(

)

Approximate binarization.

Each bit has a lower and upper probability which is the lowest - resp. highest - over all vertices of the credal set. Enlarge the original credal sets and may induce huge imprecision.

Warning

Enlarge the original credal sets and therefore induce huge imprecision by propagation. Not recommended, use MCSampling or something else instead.

Definition at line 957 of file credalNet_tpl.h.

                                                           {
      // don't forget to delete the old one ( _current_), if necessary at the end
      auto bin_bn = new BayesNet< GUM_SCALAR >();
 
      // __bnCopy ( * _bin_bn_ );
      // delete old one too
      auto credalNet_bin_cpt
          = new NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >();
 
      // delete old one too
      auto bin_nodeType = new NodeProperty< NodeType >();
 
      const BayesNet< GUM_SCALAR >* current_bn;
      const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >*
          credalNet_current_cpt;
 
      if (this->_current_bn_ == nullptr) current_bn = &this->_src_bn_;
      else current_bn = this->_current_bn_;
 
      if (this->_credalNet_current_cpt_ == nullptr)
        credalNet_current_cpt = &this->_credalNet_src_cpt_;
      else credalNet_current_cpt = this->_credalNet_current_cpt_;
 
      if (!_var_bits_.empty()) _var_bits_.clear();
 
      bin_bn->beginTopologyTransformation();
 
      for (auto node: current_bn->nodes()) {
        auto var_dSize = current_bn->variable(node).domainSize();
 
        if (var_dSize != 2) {
          unsigned long b;
          unsigned long c;
          superiorPow(static_cast< unsigned long >(var_dSize), b, c);
          Size nb_bits{b};
 
          std::string           bit_name;
          std::vector< NodeId > bits(nb_bits);
 
          for (Size bit = 0; bit < nb_bits; bit++) {
            bit_name = current_bn->variable(node).name() + "-b";
            bit_name += std::to_string(bit);
 
            LabelizedVariable var_bit(bit_name, "node " + bit_name, 2);
            NodeId            iD = bin_bn->add(var_bit);
 
            bits[bit] = iD;
          }   // end of : for each bit
 
          _var_bits_.insert(node, bits);
        }   // end of : if variable is not binary
        else {
          const std::string bit_name = current_bn->variable(node).name();
          LabelizedVariable var_bit(bit_name, "node " + bit_name, 2);
          const NodeId      iD = bin_bn->add(var_bit);
 
          _var_bits_.insert(node, std::vector< NodeId >(1, iD));
        }
      }   // end of : for each original variable
 
      for (auto node: current_bn->nodes()) {
        if (NodeSet parents = current_bn->parents(node); !parents.empty()) {
          for (auto par: current_bn->parents(node)) {
            for (Size parent_bit = 0, spbits = static_cast< Size >(_var_bits_[par].size());
                 parent_bit < spbits;
                 parent_bit++)
              for (Size var_bit = 0, mbits = static_cast< Size >(_var_bits_[node].size());
                   var_bit < mbits;
                   var_bit++)
                bin_bn->addArc(_var_bits_[par][parent_bit], _var_bits_[node][var_bit]);
          }
        }
 
        // arcs with one's bits
        const auto bitsize = _var_bits_[node].size();
 
        for (Size bit_c = 1; bit_c < bitsize; bit_c++)
          for (Size bit_p = 0; bit_p < bit_c; bit_p++)
            bin_bn->addArc(_var_bits_[node][bit_p], _var_bits_[node][bit_c]);
      }   // end of : for each original variable
 
      bin_bn->endTopologyTransformation();
 
      // binarization of cpts
 
      const auto varsize = current_bn->size();
 
      for (Size var = 0; var < varsize; var++) {
        const auto bitsize = _var_bits_[var].size();
 
        for (Size i = 0; i < bitsize; i++) {
          Tensor< GUM_SCALAR > const* tensor(&bin_bn->cpt(_var_bits_[var][i]));
          Instantiation               ins(tensor);
          ins.setFirst();
 
          auto entry_size = tensor->domainSize() / 2;
          std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(entry_size);
 
          Size old_conf = 0;
 
          for (Size conf = 0; conf < entry_size; conf++) {
            std::vector< std::vector< GUM_SCALAR > > pvar_cpt;
            auto verticessize = (*credalNet_current_cpt)[var][old_conf].size();
 
            for (Size old_distri = 0; old_distri < verticessize; old_distri++) {
              const std::vector< GUM_SCALAR >& vertex
                  = (*credalNet_current_cpt)[var][old_conf][old_distri];
              auto vertexsize = vertex.size();
 
              std::vector< Idx > incc(vertexsize, 0);
 
              for (Size preced = 0; preced < i; preced++) {
                auto bit_pos = ins.pos(bin_bn->variable(_var_bits_[var][preced]));
                auto val     = ins.val(bit_pos);
 
                Size pas = Size(int2Pow(preced));
                Size elem;
 
                if (val == 0) elem = 0;
                else elem = pas;
 
                while (elem < vertexsize) {
                  incc[elem]++;
                  elem++;
 
                  if (elem % pas == 0) elem += pas;
                }
              }
 
              Size pas = Size(int2Pow(i));
 
              std::vector< GUM_SCALAR > distri(2, 0);
              int                       pos = 1;
 
              for (Size elem = 0; elem < vertexsize; elem++) {
                if (elem % pas == 0) pos = -pos;
 
                if (incc[elem] == i)
                  (pos < 0) ? (distri[0] += vertex[elem]) : (distri[1] += vertex[elem]);
              }
 
              if (i > 0) {
                GUM_SCALAR den = distri[0] + distri[1];
 
                if (den == 0) {
                  distri[0] = 0;
                  distri[1] = 0;
                } else {
                  distri[0] /= den;
                  distri[1] /= den;
                }
              }
 
              pvar_cpt.push_back(distri);
            }   // end of old distris
 
            // get min/max approx, 2 vertices
            std::vector< std::vector< GUM_SCALAR > > vertices(2, std::vector< GUM_SCALAR >(2, 1));
            vertices[1][1] = 0;
 
            const auto new_verticessize = pvar_cpt.size();
 
            for (Size v = 0; v < new_verticessize; v++) {
              if (pvar_cpt[v][1] < vertices[0][1]) vertices[0][1] = pvar_cpt[v][1];
 
              if (pvar_cpt[v][1] > vertices[1][1]) vertices[1][1] = pvar_cpt[v][1];
            }
 
            vertices[0][0] = 1 - vertices[0][1];
            vertices[1][0] = 1 - vertices[1][1];
 
            pvar_cpt = vertices;
 
            var_cpt[conf] = pvar_cpt;
 
            ++ins;
            ++ins;
 
            old_conf++;
 
            if (old_conf == (*credalNet_current_cpt)[var].size()) old_conf = 0;
          }   // end of new parent conf
 
          credalNet_bin_cpt->insert(_var_bits_[var][i], var_cpt);
        }   // end of bit i
      }   // end of old variable
 
      bin_bn->beginTopologyTransformation();
 
      /* indicatrices variables */
      const auto old_varsize = _var_bits_.size();
 
      for (Size i = 0; i < old_varsize; i++) {
        auto bitsize = _var_bits_[i].size();
 
        // binary variable
        if (bitsize == 1) continue;
 
        auto old_card = _src_bn_.variable(i).domainSize();
 
        for (Size mod = 0; mod < old_card; mod++) {
          auto ss_str = std::format("{}-v{}", _src_bn_.variable(i).name(), mod);
 
          LabelizedVariable var(ss_str, "node " + ss_str, 2);
          const NodeId      indic = bin_bn->add(var);
 
          // arcs from one's bits
          for (Size bit = 0; bit < bitsize; bit++)
            bin_bn->addArc(_var_bits_[i][bit], indic);
 
          // cpt
          Size num = Size(int2Pow(long(bitsize)));
 
          std::vector< std::vector< std::vector< GUM_SCALAR > > > icpt(num);
 
          for (Size entry = 0; entry < num; entry++) {
            std::vector< std::vector< GUM_SCALAR > > vertices(1, std::vector< GUM_SCALAR >(2, 0));
 
            if (mod == entry) vertices[0][1] = 1;
            else vertices[0][0] = 1;
 
            icpt[entry] = vertices;
          }
 
          credalNet_bin_cpt->insert(indic, icpt);
 
          bin_nodeType->insert(indic, NodeType::Indic);
        }   // end of each modality, i.e. as many indicatrice
      }
 
      bin_bn->endTopologyTransformation();
 
      if (this->_current_bn_ != nullptr) delete this->_current_bn_;
 
      this->_current_bn_ = bin_bn;
 
      if (this->_credalNet_current_cpt_ != nullptr) delete this->_credalNet_current_cpt_;
 
      this->_credalNet_current_cpt_ = credalNet_bin_cpt;
 
      if (this->_current_nodeType_ != nullptr) delete this->_current_nodeType_;
 
      this->_current_nodeType_ = bin_nodeType;
 
      _sort_varType_();   // will fill  _bin_nodeType_ except for NodeType::Indic
      // variables
 
      computeBinaryCPTMinMax();
    }

References _credalNet_current_cpt_, _credalNet_src_cpt_, _current_bn_, _current_nodeType_, _sort_varType_(), _src_bn_, _var_bits_, computeBinaryCPTMinMax(), current_bn(), Indic, gum::HashTable< Key, Val >::insert(), gum::int2Pow(), gum::Instantiation::pos(), gum::Instantiation::setFirst(), gum::superiorPow(), and gum::Instantiation::val().

Here is the call graph for this function:

bnToCredal() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::bnToCredal	(	GUM_SCALAR	beta,
		bool	oneNet )

Perturbates the BayesNet provided as input for this CredalNet by generating intervals instead of point probabilities and then computes each vertex of each credal set.

The perturbations are done according to the number of cases met for each node and each of it's parent instantiation, i.e. \( \epsilon = *\beta^{ln(N_{pa(X) = j} + 1)} \) is the imprecision introduced which leads to \( \underline{p}(X = i \mid pa(X) = j) = (1 - \epsilon) p(X = i *\mid pa(X) = j) \) and \( \overline{p}(X = i \mid pa(X) = j) *=\underline{p}(X =i \mid pa(X) = j) + \epsilon \). Use this method when using a single BayesNet storing counts of events with oneNet set to TRUE or when using two BayesNet, one with lower probabilities and one with upper probabilities, with oneNet set to FALSE.

Parameters

beta	The beta used to perturbate the network. \( 0 \leq \beta *\leq 1 \).
oneNet	Boolean used as a flag. Set to TRUE if one BayesNet if provided with counts, to FALSE if two BayesNet are provided; one with probabilities (the lower net) and one with denominators over the first modalities (the upper net).
keepZeroes	Boolean used as a flag as whether or not - respectively TRUE or FALSE - we keep zeroes as zeroes. Default is FALSE, i.e. zeroes are not kept.

Definition at line 442 of file credalNet_tpl.h.

                                                                         {
      this->bnToCredal(beta, oneNet, false);
    }

References bnToCredal().

Here is the call graph for this function:

bnToCredal() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::bnToCredal	(	GUM_SCALAR	beta,
		bool	oneNet,
		bool	keepZeroes )

Perturbates the BayesNet provided as input for this CredalNet by generating intervals instead of point probabilities and then computes each vertex of each credal set.

The perturbations are done according to the number of cases met for each node and each of it's parent instantiation, i.e. \( \epsilon = *\beta^{ln(N_{pa(X) = j} + 1)} \) is the imprecision introduced which leads to \( \underline{p}(X = i \mid pa(X) = j) = (1 - \epsilon) p(X = i *\mid pa(X) = j) \) and \( \overline{p}(X = i \mid pa(X) = j) *=\underline{p}(X =i \mid pa(X) = j) + \epsilon \). Use this method when using a single BayesNet storing counts of events with oneNet set to TRUE or when using two BayesNet, one with lower probabilities and one with upper probabilities, with oneNet set to FALSE.

Parameters

beta	The beta used to perturbate the network. \( 0 \leq \beta *\leq 1 \).
oneNet	Boolean used as a flag. Set to TRUE if one BayesNet if provided with counts, to FALSE if two BayesNet are provided; one with probabilities (the lower net) and one with denominators over the first modalities (the upper net).
keepZeroes	Boolean used as a flag as whether or not - respectively TRUE or FALSE - we keep zeroes as zeroes. Default is FALSE, i.e. zeroes are not kept.

Definition at line 447 of file credalNet_tpl.h.

                                                                                          {
      GUM_SCALAR epsi_min = 1.;
      GUM_SCALAR epsi_max = 0.;
      GUM_SCALAR epsi_moy = 0.;
      GUM_SCALAR epsi_den = 0.;
 
      for (auto node: src_bn().nodes()) {
        const Tensor< GUM_SCALAR >* const tensor(&_src_bn_.cpt(node));
 
        Tensor< GUM_SCALAR >* const tensor_min(
            const_cast< Tensor< GUM_SCALAR >* const >(&_src_bn_min_.cpt(node)));
        Tensor< GUM_SCALAR >* const tensor_max(
            const_cast< Tensor< GUM_SCALAR >* const >(&_src_bn_max_.cpt(node)));
 
        Size var_dSize  = _src_bn_.variable(node).domainSize();
        Size entry_size = tensor->domainSize() / var_dSize;
 
        Instantiation ins(tensor);
        Instantiation ins_min(tensor_min);
        Instantiation ins_max(tensor_max);
 
        ins.setFirst();
        ins_min.setFirst();
        ins_max.setFirst();
 
        std::vector< GUM_SCALAR > vertex(var_dSize);
 
        for (Size entry = 0; entry < entry_size; entry++) {
          GUM_SCALAR den;
 
          if (oneNet) den = 0;
          else den = tensor_max->get(ins_max);
 
          Size nbm = 0;
 
          for (Size modality = 0; modality < var_dSize; modality++) {
            vertex[modality] = tensor->get(ins);
 
            if (oneNet) {
              den += vertex[modality];
 
              if (vertex[modality] < 1 && vertex[modality] > 0)
                GUM_ERROR(OperationNotAllowed,
                          "bnToCredal : the BayesNet contains "
                          "probabilities and not event counts "
                          "although user precised oneNet = "
                              << oneNet);
            }
 
            if (vertex[modality] > 0) nbm++;
 
            ++ins;
          }

          if (!oneNet) {
            GUM_SCALAR sum = 0;
 
            for (auto modality = vertex.cbegin(), theEnd = vertex.cend(); modality != theEnd;
                 ++modality) {
              sum += *modality;
            }
 
            if (std::fabs(1. - sum) > _epsRedund_) {
              GUM_ERROR(CPTError,
                        _src_bn_.variable(node).name()
                            << "(" << _epsRedund_ << ")  does not sum to one for" << " " << entry
                            << std::endl
                            << vertex << std::endl
                            << ins << std::endl);
            }
          }

 
          GUM_SCALAR epsilon;
 
          if (beta == 0) epsilon = 0;
          else if (den == 0 || beta == 1) epsilon = GUM_SCALAR(1.0);
          else epsilon = GUM_SCALAR(std::pow(beta, std::log1p(den)));
 
          epsi_moy += epsilon;
          epsi_den += 1;
 
          if (epsilon > epsi_max) epsi_max = epsilon;
 
          if (epsilon < epsi_min) epsi_min = epsilon;
 
          GUM_SCALAR min, max;
 
          for (Size modality = 0; modality < var_dSize; modality++) {
            if ((vertex[modality] > 0 && nbm > 1) || !keepZeroes) {
              min = GUM_SCALAR((1. - epsilon) * vertex[modality]);
 
              if (oneNet) min = GUM_SCALAR(min * 1.0 / den);
 
              max = GUM_SCALAR(min + epsilon);
            } else {
              // if ( ( vertex[modality] == 0 && keepZeroes ) || (
              // vertex[modality] > 0 && nbm <= 1 ) || ( vertex[modality] == 0
              // && nbm <= 1 ) ) {
              min = vertex[modality];
 
              if (oneNet) min = GUM_SCALAR(min * 1.0 / den);
 
              max = min;
            }
 
            tensor_min->set(ins_min, min);
            tensor_max->set(ins_max, max);
 
            ++ins_min;
            ++ins_max;
          }   // end of : for each modality
        }   // end of : for each entry
      }   // end of : for each variable
 
      _epsilonMin_ = epsi_min;
      _epsilonMax_ = epsi_max;
      _epsilonMoy_ = (GUM_SCALAR)epsi_moy / (GUM_SCALAR)epsi_den;
 
      _intervalToCredal_();
    }

References _epsilonMax_, _epsilonMin_, _epsilonMoy_, _epsRedund_, _intervalToCredal_(), _src_bn_, _src_bn_max_, _src_bn_min_, GUM_ERROR, gum::Instantiation::setFirst(), and src_bn().

Referenced by bnToCredal().

Here is the call graph for this function:

Here is the caller graph for this function:

computeBinaryCPTMinMax()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::computeBinaryCPTMinMax

(

)

Used with binary networks to speed-up L2U inference.

Store the lower and upper probabilities of each node X over the "true" modality, i.e. respectively \( \underline{p}(X = 1 \mid pa(X) = j) \) and \( \overline{p}(X = 1 \mid pa(X) = j) \).

Definition at line 1247 of file credalNet_tpl.h.

                                                         {
      // ASSUMPTION: NodeIds are dense 0..N-1 (no nodes ever removed from the BN).
      // If sparse NodeIds are introduced, indexing by node will go out of bounds.
      _binCptMin_.resize(current_bn().size());
      _binCptMax_.resize(current_bn().size());
 
      for (auto node: current_bn().nodes()) {
        auto                      pConf = credalNet_currentCpt()[node].size();
        std::vector< GUM_SCALAR > min(pConf);
        std::vector< GUM_SCALAR > max(pConf);
 
        for (Size pconf = 0; pconf < pConf; pconf++) {
          GUM_SCALAR v1, v2;
          v1 = credalNet_currentCpt()[node][pconf][0][1];
 
          if (credalNet_currentCpt()[node][pconf].size() > 1)
            v2 = credalNet_currentCpt()[node][pconf][1][1];
          else v2 = v1;
 
          GUM_SCALAR delta = v1 - v2;
          min[pconf]       = (delta >= 0) ? v2 : v1;
          max[pconf]       = (delta >= 0) ? v1 : v2;
        }
 
        _binCptMin_[node] = min;
        _binCptMax_[node] = max;
      }
 
      _hasComputedBinaryCPTMinMax_ = true;
    }

References _binCptMax_, _binCptMin_, _hasComputedBinaryCPTMinMax_, credalNet_currentCpt(), and current_bn().

Referenced by approximatedBinarization().

Here is the call graph for this function:

Here is the caller graph for this function:

credalNet_currentCpt()

template<GUM_Numeric GUM_SCALAR>

const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > & gum::credal::CredalNet< GUM_SCALAR >::credalNet_currentCpt

(

)

const

Returns

Returns a constant reference to the ( up-to-date ) CredalNet CPTs.

Definition at line 1209 of file credalNet_tpl.h.

                                                            {
      if (_credalNet_current_cpt_ != nullptr) return *_credalNet_current_cpt_;
 
      return _credalNet_src_cpt_;
    }

References _credalNet_current_cpt_, and _credalNet_src_cpt_.

Referenced by computeBinaryCPTMinMax(), and gum::credal::VarMod2BNsMap< GUM_SCALAR >::setCNet().

Here is the caller graph for this function:

credalNet_srcCpt()

template<GUM_Numeric GUM_SCALAR>

const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > & gum::credal::CredalNet< GUM_SCALAR >::credalNet_srcCpt

(

)

const

Returns

Returns a constant reference to the ( up-to-date ) CredalNet CPTs.

Definition at line 1217 of file credalNet_tpl.h.

                                                        {
      return _credalNet_src_cpt_;
    }

References _credalNet_src_cpt_.

current_bn()

template<GUM_Numeric GUM_SCALAR>

const BayesNet< GUM_SCALAR > & gum::credal::CredalNet< GUM_SCALAR >::current_bn

(

)

const

Returns

Returs a constant reference to the actual BayesNet (used as a DAG, it's CPTs does not matter).

Definition at line 1337 of file credalNet_tpl.h.

                                                                            {
      if (_current_bn_ != nullptr) return *_current_bn_;
 
      return _src_bn_;
    }

References _current_bn_, and _src_bn_.

Referenced by approximatedBinarization(), and computeBinaryCPTMinMax().

Here is the caller graph for this function:

currentNodeType()

template<GUM_Numeric GUM_SCALAR>

CredalNet< GUM_SCALAR >::NodeType gum::credal::CredalNet< GUM_SCALAR >::currentNodeType

(

const NodeId &

id

)

const

Parameters

id	The constant reference to the chosen NodeId

Returns

Returns the type of the chosen node in the ( up-to-date ) CredalNet current_bn if any, src_bn otherwise.

Definition at line 1223 of file credalNet_tpl.h.

                                                                       {
      if (_current_nodeType_ != nullptr) return (*(_current_nodeType_))[id];
 
      return _original_nodeType_[id];
    }

References _current_nodeType_, and _original_nodeType_.

domainSize()

template<GUM_Numeric GUM_SCALAR>

Size gum::credal::CredalNet< GUM_SCALAR >::domainSize

(

const NodeId &

id

)

Get the cardinality of a node

Parameters

id	The NodeId of the node

Returns

The cardinality of the node

Definition at line 406 of file credalNet_tpl.h.

                                                             {
      return _src_bn_.variable(id).domainSize();
    }

References _src_bn_.

epsilonMax()

template<GUM_Numeric GUM_SCALAR>

const GUM_SCALAR & gum::credal::CredalNet< GUM_SCALAR >::epsilonMax

(

)

const

Returns

Returns a constant reference to the highest perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 1296 of file credalNet_tpl.h.

                                                                {
      return _epsilonMax_;
    }

References _epsilonMax_.

epsilonMean()

template<GUM_Numeric GUM_SCALAR>

const GUM_SCALAR & gum::credal::CredalNet< GUM_SCALAR >::epsilonMean

(

)

const

Returns

Returns a constant reference to the average perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 1301 of file credalNet_tpl.h.

                                                                 {
      return _epsilonMoy_;
    }

References _epsilonMoy_.

epsilonMin()

template<GUM_Numeric GUM_SCALAR>

const GUM_SCALAR & gum::credal::CredalNet< GUM_SCALAR >::epsilonMin

(

)

const

Returns

Returns a constant reference to the lowest perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 1291 of file credalNet_tpl.h.

                                                                {
      return _epsilonMin_;
    }

References _epsilonMin_.

fillConstraint() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

Set the interval constraints of a credal set of a given node ( from an instantiation index )

Parameters

id	The NodeId of the node
entry	The index of the instantiation excluding the given node ( only the parents are used to compute the index of the credal set )
lower	The lower value for each probability in correct order
upper	The upper value for each probability in correct order

You need to call intervalToCredal when done filling all constraints.

Warning

: DOES change the BayesNet (s) associated to this credal net !

Note

we forget the master ref of ins to check variable order in the instantiation ( to get index ), therefore we pass it by value

Definition at line 287 of file credalNet_tpl.h.

                                                                                       {
      Tensor< GUM_SCALAR >* const tensor_min(
          const_cast< Tensor< GUM_SCALAR >* const >(&_src_bn_min_.cpt(id)));
      Tensor< GUM_SCALAR >* const tensor_max(
          const_cast< Tensor< GUM_SCALAR >* const >(&_src_bn_max_.cpt(id)));
 
      auto var_dSize = _src_bn_.variable(id).domainSize();
 
      if (lower.size() != var_dSize || upper.size() != var_dSize)
        GUM_ERROR(SizeError,
                  "setCPT : variable modalities in cpts does not match for node id : "
                      << id << " with sizes of constraints : ( " << lower.size() << " || "
                      << upper.size() << " ) != " << var_dSize);
 
      auto entry_size = tensor_min->domainSize() / var_dSize;
 
      if (entry >= entry_size)
        GUM_ERROR(SizeError,
                  "setCPT : entry is greater or equal than entry size "
                  "(entries start at 0 up to entry_size - 1) : "
                      << entry << " >= " << entry_size);
 
      Instantiation min(tensor_min);
      Instantiation max(tensor_max);
      min.setFirst();
      max.setFirst();
 
      Idx pos = 0;
 
      while (pos != entry) {
        ++min;
        ++max;
        ++pos;
      }
 
      for (Size i = 0; i < var_dSize; i++) {
        tensor_min->set(min, lower[i]);
        tensor_max->set(max, upper[i]);
        ++min;
        ++max;
      }
    }

References _src_bn_, _src_bn_max_, _src_bn_min_, GUM_ERROR, and gum::Instantiation::setFirst().

Referenced by fillConstraint().

Here is the call graph for this function:

Here is the caller graph for this function:

fillConstraint() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

Set the interval constraints of a credal sets of a given node ( from an instantiation )

Parameters

id	The NodeId of the node
ins	The Instantiation
lower	The lower value for each probability in correct order
upper	The upper value for each probability in correct order

You need to call intervalToCredal when done filling all constraints.

Warning

: DOES change the BayesNet (s) associated to this credal net !

Note

we forget the master ref of ins to check variable order in the instantiation ( to get index ), therefore we pass it by value

Definition at line 334 of file credalNet_tpl.h.

                                                                                       {
      const Tensor< GUM_SCALAR >* const tensor(&_src_bn_.cpt(id));
      /*
      auto var_dSize =  _src_bn_.variable ( id ).domainSize();
      auto entry_size = tensor->domainSize() / var_dSize;
      */
      // to be sure of entry index reorder ins according to the bayes net
      // tensors
      // ( of the credal net )
      // it WONT throw an error if the sequences are not equal not because of
      // order
      // but content, so we double check (before & after order correction)
      // beware of slaves & master
      Instantiation ref(tensor);
      ref.forgetMaster();
 
      ins.forgetMaster();
 
      const auto& vseq = ref.variablesSequence();
 
      if (ins.variablesSequence() != vseq) {
        ins.reorder(ref);
 
        if (ins.variablesSequence() != vseq)
          GUM_ERROR(OperationNotAllowed,
                    "setCPT : instantiation : "
                        << ins << " is not valid for node id " << id
                        << " which accepts instantiations such as (order is not "
                           "important) : "
                        << ref);
      }
 
      Idx entry = 0, jump = 1;
 
      for (Idx i = 0, end = ins.nbrDim(); i < end; i++) {
        if (_src_bn_.nodeId(ins.variable(i)) == id) continue;
 
        entry += ins.val(i) * jump;
 
        jump *= ins.variable(i).domainSize();
      }
 
      /*
      if ( entry >= entry_size )
        GUM_ERROR ( SizeError, "setCPT : entry is greater or equal than entry
      size
      (entries start at 0 up to entry_size - 1) : " << entry << " >= " <<
      entry_size
      );
 
      if ( lower.size() != var_dSize || upper.size() != var_dSize )
        GUM_ERROR ( SizeError, "setCPT : variable modalities in cpts does not
      match
      for node id : " << id << " with sizes of constraints : ( "<< lower.size()
      << "
      || " << upper.size() << " ) != " << var_dSize );
      */
      fillConstraint(id, entry, lower, upper);
    }

References _src_bn_, gum::DiscreteVariable::domainSize(), fillConstraint(), gum::Instantiation::forgetMaster(), GUM_ERROR, gum::Instantiation::nbrDim(), gum::Instantiation::reorder(), gum::Instantiation::val(), gum::Instantiation::variable(), and gum::Instantiation::variablesSequence().

Here is the call graph for this function:

fillConstraints()

template<GUM_Numeric GUM_SCALAR>

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

Set the interval constraints of the credal sets of a given node (all instantiations )

Parameters

id	The NodeId of the node
lower	The lower value for each probability in correct order
upper	The upper value for each probability in correct order

You need to call intervalToCredal when done filling all constraints.

Warning

: DOES change the BayesNet (s) associated to this credal net !

Note

we forget the master ref of ins to check variable order in the instantiation ( to get index ), therefore we pass it by value

Definition at line 274 of file credalNet_tpl.h.

                                                                                        {
      try {
        _src_bn_min_.cpt(id).fillWith(lower);
        _src_bn_max_.cpt(id).fillWith(upper);
      } catch (const SizeError&) {
        GUM_ERROR(SizeError,
                  "fillConstraints : sizes does not match in fillWith for node id : " << id);
      }
    }

References _src_bn_max_, _src_bn_min_, and GUM_ERROR.

get_binaryCPT_max()

template<GUM_Numeric GUM_SCALAR>

const std::vector< std::vector< GUM_SCALAR > > & gum::credal::CredalNet< GUM_SCALAR >::get_binaryCPT_max

(

)

const

Used with binary networks to speed-up L2U inference.

Returns

Returns a constant reference to the upper probabilities of each node X over the "true" modality, i.e. \( \overline{p}(X = 1 \mid pa(X) = j) *\).

Definition at line 1286 of file credalNet_tpl.h.

                                                         {
      return _binCptMax_;
    }

References _binCptMax_.

get_binaryCPT_min()

template<GUM_Numeric GUM_SCALAR>

const std::vector< std::vector< GUM_SCALAR > > & gum::credal::CredalNet< GUM_SCALAR >::get_binaryCPT_min

(

)

const

Used with binary networks to speed-up L2U inference.

Returns

Returns a constant reference to the lower probabilities of each node X over the "true" modality, i.e. \( \underline{p}(X = 1 \mid pa(X) = j) *\).

Definition at line 1280 of file credalNet_tpl.h.

                                                         {
      return _binCptMin_;
    }

References _binCptMin_.

hasComputedBinaryCPTMinMax()

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::CredalNet< GUM_SCALAR >::hasComputedBinaryCPTMinMax

(

)

const

Returns

Returns TRUE if this CredalNet has called computeBinaryCPTMinMax() to speed-up inference with binary networks and L2U. This needs to be reworked as it is too easy to forget to call it and it can't be called within the inference engine (constness).

Definition at line 1241 of file credalNet_tpl.h.

                                                                   {
      return _hasComputedBinaryCPTMinMax_;
    }

References _hasComputedBinaryCPTMinMax_.

idmLearning()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::idmLearning	(	const Idx	s = 0,
		const bool	keepZeroes = false )

Learns parameters from a BayesNet storing counts of events.

Use this method when using a single BayesNet storing counts of events. IDM model if s > 0, standard point probability if s = 0 (default value if none precised).

Parameters

s	The IDM parameter.
keepZeroes	Boolean used as a flag as whether or not - respectively TRUE or FALSE - we keep zeroes as zeroes. Default is FALSE, i.e. zeroes are not kept.

Definition at line 616 of file credalNet_tpl.h.

                                                                                {
      for (auto node: _src_bn_.nodes()) {
        const Tensor< GUM_SCALAR >* const tensor(&_src_bn_.cpt(node));
 
        Tensor< GUM_SCALAR >* const tensor_min(
            const_cast< Tensor< GUM_SCALAR >* const >(&_src_bn_min_.cpt(node)));
        Tensor< GUM_SCALAR >* const tensor_max(
            const_cast< Tensor< GUM_SCALAR >* const >(&_src_bn_max_.cpt(node)));
 
        Size var_dSize  = _src_bn_.variable(node).domainSize();
        Size entry_size = tensor->domainSize() / var_dSize;
 
        Instantiation ins(tensor);
        Instantiation ins_min(tensor_min);
        Instantiation ins_max(tensor_max);
 
        ins.setFirst();
        ins_min.setFirst();
        ins_max.setFirst();
 
        std::vector< GUM_SCALAR > vertex(var_dSize);
 
        for (Size entry = 0; entry < entry_size; entry++) {
          GUM_SCALAR den = 0;
          Size       nbm = 0;
 
          for (Size modality = 0; modality < var_dSize; modality++) {
            vertex[modality] = tensor->get(ins);
 
            if (vertex[modality] < 1 && vertex[modality] > 0)
              GUM_ERROR(OperationNotAllowed,
                        "idmLearning : the BayesNet contains "
                        "probabilities and not event counts.");
 
            den += vertex[modality];
 
            if (vertex[modality] > 0) nbm++;
 
            ++ins;
          }
 
          if (nbm > 1 || !keepZeroes) den += s;
 
          GUM_SCALAR min, max;
 
          for (Size modality = 0; modality < var_dSize; modality++) {
            min = vertex[modality];
            max = min;
 
            if ((vertex[modality] > 0 && nbm > 1) || !keepZeroes) { max += s; }
 
            min = GUM_SCALAR(min * 1.0 / den);
            max = GUM_SCALAR(max * 1.0 / den);
 
            tensor_min->set(ins_min, min);
            tensor_max->set(ins_max, max);
 
            ++ins_min;
            ++ins_max;
          }   // end of : for each modality
        }   // end of : for each entry
      }   // end of : for each variable
 
      _epsilonMin_ = GUM_SCALAR(s);
      _epsilonMax_ = GUM_SCALAR(s);
      _epsilonMoy_ = GUM_SCALAR(s);
      _intervalToCredal_();
    }

References _epsilonMax_, _epsilonMin_, _epsilonMoy_, _intervalToCredal_(), _src_bn_, _src_bn_max_, _src_bn_min_, GUM_ERROR, and gum::Instantiation::setFirst().

Here is the call graph for this function:

instantiation()

template<GUM_Numeric GUM_SCALAR>

Instantiation gum::credal::CredalNet< GUM_SCALAR >::instantiation

(

const NodeId &

id

)

Get an Instantiation from a node id, useful to fill the constraints of the network

bnet accessors / shortcuts

Parameters

id	The NodeId we want an instantiation from

Returns

The instantiation

Definition at line 401 of file credalNet_tpl.h.

                                                                         {
      return Instantiation(_src_bn_.cpt(id));
    }

References _src_bn_.

intervalToCredal()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::intervalToCredal

(

)

Computes the vertices of each credal set according to their interval definition (uses lrs).

Use this method when using two BayesNet, one with lower probabilities and one with upper probabilities.

Definition at line 781 of file credalNet_tpl.h.

                                                   {
      if (!_credalNet_src_cpt_.empty()) _credalNet_src_cpt_.clear();
 
      _credalNet_src_cpt_.resize(_src_bn_.size());
 
      LRSWrapper< GUM_SCALAR > lrsWrapper;
 
      for (auto node: _src_bn_.nodes()) {
        const Tensor< GUM_SCALAR >* const tensor_min(&_src_bn_min_.cpt(node));
        const Tensor< GUM_SCALAR >* const tensor_max(&_src_bn_max_.cpt(node));
 
        Size var_dSize  = _src_bn_.variable(node).domainSize();
        Size entry_size = tensor_min->domainSize() / var_dSize;
 
        std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(entry_size);
 
        Instantiation ins_min(tensor_min);
        Instantiation ins_max(tensor_max);
 
        ins_min.setFirst();
        ins_max.setFirst();
 
        lrsWrapper.setUpH(var_dSize);
 
        for (Size entry = 0; entry < entry_size; entry++) {
          for (Size modality = 0; modality < var_dSize; modality++) {
            if (tensor_min->get(ins_min) > tensor_max->get(ins_max)) {
              GUM_ERROR(CPTError,
                        "For variable "
                            << _src_bn_.variable(node).name() << " (at " << ins_min
                            << "), the min is greater than the max : " << tensor_min->get(ins_min)
                            << ">" << tensor_max->get(ins_max) << ".");
            }
            lrsWrapper.fillH(tensor_min->get(ins_min), tensor_max->get(ins_max), modality);
            ++ins_min;
            ++ins_max;
          }
 
          lrsWrapper.H2V();
          var_cpt[entry] = lrsWrapper.getOutput();
          lrsWrapper.nextHInput();
        }
 
        _credalNet_src_cpt_.insert(node, var_cpt);
      }   // end of : for each variable (node)
 
      // get precise/credal/vacuous status of each variable
      _sort_varType_();
      _separatelySpecified_ = true;
    }

References _credalNet_src_cpt_, _separatelySpecified_, _sort_varType_(), _src_bn_, _src_bn_max_, _src_bn_min_, gum::credal::LRSWrapper< GUM_SCALAR >::fillH(), gum::credal::LRSWrapper< GUM_SCALAR >::getOutput(), GUM_ERROR, gum::credal::LRSWrapper< GUM_SCALAR >::H2V(), gum::credal::LRSWrapper< GUM_SCALAR >::nextHInput(), gum::Instantiation::setFirst(), and gum::credal::LRSWrapper< GUM_SCALAR >::setUpH().

Here is the call graph for this function:

intervalToCredalWithFiles()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::intervalToCredalWithFiles

(

)

Deprecated

Use intervalToCredal ( lrsWrapper with no input / output files needed ).

Computes the vertices of each credal set according to their interval definition (uses lrs).

Use this method when using a single BayesNet storing counts of events.

Definition at line 834 of file credalNet_tpl.h.

                                                            {
      if (!_credalNet_src_cpt_.empty()) _credalNet_src_cpt_.clear();
 
      _credalNet_src_cpt_.resize(_src_bn_.size());
 
      for (auto node: _src_bn_.nodes()) {
        const Tensor< GUM_SCALAR >* const tensor_min(&_src_bn_min_.cpt(node));
        const Tensor< GUM_SCALAR >* const tensor_max(&_src_bn_max_.cpt(node));
 
        auto var_dSize  = _src_bn_.variable(node).domainSize();
        auto entry_size = tensor_min->domainSize() / var_dSize;
 
        std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(entry_size);
 
        Instantiation ins_min(tensor_min);
        Instantiation ins_max(tensor_max);
 
        ins_min.setFirst();
        ins_max.setFirst();
 
        // use iterator
        for (Size entry = 0; entry < entry_size; entry++) {
          std::vector< std::vector< GUM_SCALAR > > vertices;
          std::vector< GUM_SCALAR >                vertex(var_dSize);   // if not interval
 
          std::vector< std::vector< GUM_SCALAR > > inequalities(
              var_dSize * 2,
              std::vector< GUM_SCALAR >(var_dSize + 1, 0));
 
          std::vector< GUM_SCALAR > sum_ineq1(var_dSize + 1, -1);
          std::vector< GUM_SCALAR > sum_ineq2(var_dSize + 1, 1);
          sum_ineq1[0] = 1;
          sum_ineq2[0] = -1;
 
          bool isInterval = false;
 
          for (Size modality = 0; modality < var_dSize; modality++) {
            inequalities[modality * 2][0]                = -tensor_min->get(ins_min);
            inequalities[modality * 2 + 1][0]            = tensor_max->get(ins_max);
            inequalities[modality * 2][modality + 1]     = 1;
            inequalities[modality * 2 + 1][modality + 1] = -1;
 
            vertex[modality] = inequalities[modality * 2 + 1][0];
 
            if (!isInterval
                && (-inequalities[modality * 2][0] != inequalities[modality * 2 + 1][0]))
              isInterval = true;
 
            ++ins_min;
            ++ins_max;
          }
 
          inequalities.push_back(sum_ineq1);
          inequalities.push_back(sum_ineq2);
 
          if (!isInterval) {
            vertices.push_back(vertex);
          } else {
            try {
              _H2Vlrs_(inequalities, vertices);
              // __H2Vcdd ( inequalities, vertices );
            } catch (const std::exception& err) {
              std::cout << err.what() << std::endl;
              throw;
            }
          }   // end of : is interval
 
          if (entry == 0 && vertices.size() >= 2) {
            auto tmp    = vertices[0];
            vertices[0] = vertices[1];
            vertices[1] = tmp;
          }
 
          var_cpt[entry] = vertices;
        }   // end of : for each entry
 
        _credalNet_src_cpt_.insert(node, var_cpt);
        // std::cout <<  _src_bn_.variable(node_idIt).name() << std::endl;
        // std::cout << var_cpt << std::endl;
      }   // end of : for each variable (node)
 
      // get precise/credal/vacuous status of each variable
      _sort_varType_();
      _separatelySpecified_ = true;
    }

References _credalNet_src_cpt_, _H2Vlrs_(), _separatelySpecified_, _sort_varType_(), _src_bn_, _src_bn_max_, _src_bn_min_, and gum::Instantiation::setFirst().

Here is the call graph for this function:

isSeparatelySpecified()

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::CredalNet< GUM_SCALAR >::isSeparatelySpecified

(

)

const

Returns

Returns TRUE if this CredalNet is separately and interval specified, FALSE otherwise.

Definition at line 1236 of file credalNet_tpl.h.

                                                              {
      return _separatelySpecified_;
    }

References _separatelySpecified_.

lagrangeNormalization()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::lagrangeNormalization

(

)

Normalize counts of a BayesNet storing counts of each events such that no probability is 0.

Use this method when using a single BayesNet storing counts of events. Lagrange normalization. This call is irreversible and modify counts stored by _src_bn_.

Doest not performs computations of the parameters but keeps normalized counts of events only. Call idmLearning to compute the probabilities (with any parameter value).

Definition at line 572 of file credalNet_tpl.h.

                                                        {
      for (auto node: _src_bn_.nodes()) {
        const Tensor< GUM_SCALAR >* const tensor(&_src_bn_.cpt(node));
 
        auto var_dSize  = _src_bn_.variable(node).domainSize();
        auto entry_size = tensor->domainSize() / var_dSize;
 
        Instantiation ins(tensor);
 
        ins.setFirst();
 
        std::vector< GUM_SCALAR > vertex(var_dSize);
 
        for (Size entry = 0; entry < entry_size; entry++) {
          bool          zeroes   = false;
          Instantiation ins_prev = ins;
 
          for (Size modality = 0; modality < var_dSize; modality++) {
            vertex[modality] = tensor->get(ins);
 
            if (vertex[modality] < 1 && vertex[modality] > 0)
              GUM_ERROR(OperationNotAllowed,
                        "lagrangeNormalization : the BayesNet "
                        "contains probabilities and not event "
                        "counts.");
 
            if (!zeroes && vertex[modality] == 0) { zeroes = true; }
 
            ++ins;
          }
 
          if (zeroes) {
            ins = ins_prev;
 
            for (Size modality = 0; modality < var_dSize; modality++) {
              tensor->set(ins, tensor->get(ins) + 1);
              ++ins;
            }
          }
        }   // end of : for each entry
      }   // end of : for each variable
    }

References _src_bn_, GUM_ERROR, and gum::Instantiation::setFirst().

Here is the call graph for this function:

nodeType()

template<GUM_Numeric GUM_SCALAR>

CredalNet< GUM_SCALAR >::NodeType gum::credal::CredalNet< GUM_SCALAR >::nodeType

(

const NodeId &

id

)

const

Parameters

id	The constant reference to the chosen NodeId

Returns

Returns the type of the chosen node in the ( up-to-date ) CredalNet in src_bn.

Definition at line 1231 of file credalNet_tpl.h.

                                                                {
      return _original_nodeType_[id];
    }

References _original_nodeType_.

saveBNsMinMax()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CredalNet< GUM_SCALAR >::saveBNsMinMax	(	std::string_view	min_path,
		std::string_view	max_path )

If this CredalNet was built over a perturbed BayesNet, one can save the intervals as two BayesNet.

to call after bnToCredal( GUM_SCALAR beta ) save a BN with lower probabilities and a BN with upper ones

Parameters

min_path	The path to save the BayesNet which contains the lower probabilities of each node X, i.e. \( \underline{p}(X = i \mid pa(X) = *j) *\).
max_path	The path to save the BayesNet which contains the upper probabilities of each node X, i.e. \( \overline{p}(X = i \mid pa(X) = *j) *\).

Definition at line 925 of file credalNet_tpl.h.

                                                                         {
      BIFWriter< GUM_SCALAR > writer;
 
      std::string   minfilename(min_path);   //"min.bif";
      std::string   maxfilename(max_path);   //"max.bif";
      std::ofstream min_file(minfilename.c_str(), std::ios::out | std::ios::trunc);
      std::ofstream max_file(maxfilename.c_str(), std::ios::out | std::ios::trunc);
 
      if (!min_file.good())
        GUM_ERROR(IOError, "bnToCredal() : could not open stream : min_file : " << minfilename);
 
      if (!max_file.good()) {
        min_file.close();
        GUM_ERROR(IOError, "bnToCredal() : could not open stream : min_file : " << maxfilename);
      }
 
      try {
        writer.write(min_file, _src_bn_min_);
        writer.write(max_file, _src_bn_max_);
      } catch (Exception& err) {
        GUM_SHOWERROR(err);
        min_file.close();
        max_file.close();
        throw(err);
      }
 
      min_file.close();
      max_file.close();
    }

References _src_bn_max_, _src_bn_min_, GUM_ERROR, GUM_SHOWERROR, and gum::BNWriter< GUM_SCALAR >::write().

Here is the call graph for this function:

setCPT() [1/2]

template<GUM_Numeric GUM_SCALAR>

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

Set the vertices of one credal set of a given node ( any instantiation index )

Parameters

id	The NodeId of the node
entry	The index of the instantiation ( from 0 to K - 1 ) excluding the given node ( only the parents are used to compute the index of the credal set )
cpt	The vertices of every credal set ( for each instantiation of the parents )

Use this with either LRSWrapper or LpInterface to get the vertices of a credal set represented by linear constraints.

Warning

: Does not change the BayesNet (s) associated to this credal net !

Definition at line 133 of file credalNet_tpl.h.

                                                                                          {
      const Tensor< GUM_SCALAR >* const tensor(&_src_bn_.cpt(id));
 
      auto var_dSize  = _src_bn_.variable(id).domainSize();
      auto entry_size = tensor->domainSize() / var_dSize;
 
      if (entry >= entry_size)
        GUM_ERROR(SizeError,
                  "setCPT : entry is greater or equal than entry size "
                  "(entries start at 0 up to entry_size - 1) : "
                      << entry << " >= " << entry_size);
 
      if (cpt.size() == 0) GUM_ERROR(SizeError, "setCPT : empty credal set for entry : " << entry)
 
      for (const auto& vertex: cpt) {
        if (vertex.size() != var_dSize)
          GUM_ERROR(SizeError,
                    "setCPT : variable modalities in cpts does not "
                    "match for node id : "
                        << id << " with vertex " << vertex << " at entry " << entry << " : "
                        << vertex.size() << " != " << var_dSize);
 
        GUM_SCALAR sum = 0;
 
        for (const auto& prob: vertex) {
          sum += prob;
        }
 
        if (!gum::isCloseToOne(sum, GUM_SCALAR(1e-6)))
          GUM_ERROR(CPTError,
                    "setCPT : a vertex coordinates does not sum to one for node id : "
                        << id << " at entry " << entry << " with vertex " << vertex);
      }
 
      // !! auto does NOT use adress (if available) unless explicitly asked !!
      auto& node_cpt = _credalNet_src_cpt_.getWithDefault(
          id,
          std::vector< std::vector< std::vector< GUM_SCALAR > > >(entry_size));
 
      if (node_cpt[entry].size() != 0)
        GUM_ERROR(DuplicateElement,
                  "setCPT : vertices of entry id " << entry
                                                   << " already set to : " << node_cpt[entry]
                                                   << ", cannot insert : " << cpt);
 
      node_cpt[entry] = cpt;

    }

References _credalNet_src_cpt_, _src_bn_, GUM_ERROR, and gum::isCloseToOne().

Here is the call graph for this function:

setCPT() [2/2]

template<GUM_Numeric GUM_SCALAR>

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

Set the vertices of one credal set of a given node ( any instantiation )

Parameters

id	The NodeId of the node
ins	The Instantiation ( only the parents matter to find the credal set index )
cpt	The vertices of every credal set ( for each instantiation of the parents )

Use this with either LRSWrapper or LpInterface to get the vertices of a credal set represented by linear constraints.

Warning

: Does not change the BayesNet (s) associated to this credal net !

Note

we forget the master ref of ins to check variable order in the instantiation ( to get index ), therefore we pass it by value

Definition at line 186 of file credalNet_tpl.h.

                                                                                          {
      const Tensor< GUM_SCALAR >* const tensor(&_src_bn_.cpt(id));
 
      auto var_dSize  = _src_bn_.variable(id).domainSize();
      auto entry_size = tensor->domainSize() / var_dSize;
 
      // to be sure of entry index reorder ins according to the bayes net
      // tensors
      // ( of the credal net )
      // it WONT throw an error if the sequences are not equal not because of
      // order
      // but content, so we double check (before & after order correction)
      // beware of slaves & master
      Instantiation ref(tensor);
      ref.forgetMaster();
 
      ins.forgetMaster();
 
      const auto& vseq = ref.variablesSequence();
 
      if (ins.variablesSequence() != vseq) {
        ins.reorder(ref);
 
        if (ins.variablesSequence() != vseq)
          GUM_ERROR(OperationNotAllowed,
                    "setCPT : instantiation : "
                        << ins << " is not valid for node id " << id
                        << " which accepts instantiations such as (order is not "
                           "important) : "
                        << ref);
      }
 
      Idx entry = 0, jump = 1;
 
      for (Idx i = 0, end = ins.nbrDim(); i < end; i++) {
        if (_src_bn_.nodeId(ins.variable(i)) == id) continue;
 
        entry += ins.val(i) * jump;
 
        jump *= ins.variable(i).domainSize();
      }
 
      if (entry >= entry_size)
        GUM_ERROR(SizeError,
                  "setCPT : entry is greater or equal than entry size "
                  "(entries start at 0 up to entry_size - 1) : "
                      << entry << " >= " << entry_size);
 
      if (cpt.size() == 0) GUM_ERROR(SizeError, "setCPT : empty credal set for entry : " << entry)
 
      for (const auto& vertex: cpt) {
        if (vertex.size() != var_dSize)
          GUM_ERROR(SizeError,
                    "setCPT : variable modalities in cpts does not "
                    "match for node id : "
                        << id << " with vertex " << vertex << " at entry " << entry << " : "
                        << vertex.size() << " != " << var_dSize);
 
        GUM_SCALAR sum = 0;
 
        for (const auto& prob: vertex) {
          sum += prob;
        }
 
        if (!gum::isCloseToOne(sum, GUM_SCALAR(1e-6)))
          GUM_ERROR(CPTError,
                    "setCPT : a vertex coordinates does not sum to one for node id : "
                        << id << " at entry " << entry << " with vertex " << vertex);
      }
 
      auto& node_cpt = _credalNet_src_cpt_.getWithDefault(
          id,
          std::vector< std::vector< std::vector< GUM_SCALAR > > >(entry_size));
 
      if (node_cpt[entry].size() != 0)
        GUM_ERROR(DuplicateElement,
                  "setCPT : vertices of entry : " << ins << " id " << entry
                                                  << " already set to : " << node_cpt[entry]
                                                  << ", cannot insert : " << cpt);
 
      node_cpt[entry] = cpt;

    }

References _credalNet_src_cpt_, _src_bn_, gum::DiscreteVariable::domainSize(), gum::Instantiation::forgetMaster(), GUM_ERROR, gum::isCloseToOne(), gum::Instantiation::nbrDim(), gum::Instantiation::reorder(), gum::Instantiation::val(), gum::Instantiation::variable(), and gum::Instantiation::variablesSequence().

Here is the call graph for this function:

setCPTs()

template<GUM_Numeric GUM_SCALAR>

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

Set the vertices of the credal sets ( all of the conditionals ) of a given node

Parameters

id	The NodeId of the node
cpt	The vertices of every credal set ( for each instantiation of the parents )

Warning

: Does not change the BayesNet (s) associated to this credal net !

First dimension is instantiation position ( from 0 to K - 1 ). Second is the credal set vertice index Third is the vertex

Definition at line 89 of file credalNet_tpl.h.

                                                                      {
      const Tensor< GUM_SCALAR >* const tensor(&_src_bn_.cpt(id));
 
      auto var_dSize = _src_bn_.variable(id).domainSize();
 
      if (auto entry_size = tensor->domainSize() / var_dSize; cpt.size() != entry_size)
        GUM_ERROR(SizeError,
                  "setCPTs : entry sizes of cpts does not match for node id : "
                      << id << " : " << cpt.size() << " != " << entry_size);
 
      for (const auto& cset: cpt) {
        if (cset.size() == 0)
          GUM_ERROR(SizeError,
                    "setCPTs : vertices in credal set does not match for node id : "
                        << id << " with 0 vertices");
 
        for (const auto& vertex: cset) {
          if (vertex.size() != var_dSize)
            GUM_ERROR(SizeError,
                      "setCPTs : variable modalities in cpts does "
                      "not match for node id : "
                          << id << " with vertex " << vertex << " : " << vertex.size()
                          << " != " << var_dSize);
 
          GUM_SCALAR sum = 0;
 
          for (const auto& prob: vertex) {
            sum += prob;
          }
 
          if (!gum::isCloseToOne(sum, GUM_SCALAR(1e-6)))
            GUM_ERROR(CPTError,
                      "setCPTs : a vertex coordinates does not "
                      "sum to one for node id : "
                          << id << " with vertex " << vertex);
        }
      }
 
      _credalNet_src_cpt_.insert(id, cpt);
    }

References _credalNet_src_cpt_, _src_bn_, GUM_ERROR, and gum::isCloseToOne().

Here is the call graph for this function:

src_bn()

template<GUM_Numeric GUM_SCALAR>

const BayesNet< GUM_SCALAR > & gum::credal::CredalNet< GUM_SCALAR >::src_bn

(

)

const

Returns

Returns a constant reference to the original BayesNet (used as a DAG, it's CPTs does not matter).

Definition at line 1344 of file credalNet_tpl.h.

                                                                        {
      return _src_bn_;
    }

References _src_bn_.

Referenced by bnToCredal().

Here is the caller graph for this function:

toString()

template<GUM_Numeric GUM_SCALAR>

std::string gum::credal::CredalNet< GUM_SCALAR >::toString

(

)

const

Returns

Returns the string representation of this CredalNet, i.e. it's CPTs (which also represent arcs).

Definition at line 1306 of file credalNet_tpl.h.

                                                      {
      std::stringstream             output;
      const BayesNet< GUM_SCALAR >* bn_ptr = (_current_bn_ != nullptr) ? _current_bn_ : &_src_bn_;
      const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >* cpt_ptr
          = (_credalNet_current_cpt_ != nullptr) ? _credalNet_current_cpt_ : &_credalNet_src_cpt_;
 
      for (auto node: bn_ptr->nodes()) {
        const Tensor< GUM_SCALAR >* tensor(&bn_ptr->cpt(node));
        auto pconfs = tensor->domainSize() / bn_ptr->variable(node).domainSize();
 
        output << "\n" << bn_ptr->variable(node) << "\n";
 
        Instantiation ins(tensor);
        ins.forgetMaster();
        ins.erase(bn_ptr->variable(node));
        ins.setFirst();
 
        for (Size pconf = 0; pconf < pconfs; pconf++) {
          output << ins << " : ";
          output << (*cpt_ptr)[node][pconf] << "\n";
 
          if (pconf < pconfs - 1) ++ins;
        }
      }
 
      output << "\n";
 
      return output.str();
    }

References _credalNet_current_cpt_, _credalNet_src_cpt_, _current_bn_, _src_bn_, gum::Instantiation::erase(), gum::Instantiation::forgetMaster(), and gum::Instantiation::setFirst().

Here is the call graph for this function:

Member Data Documentation

_binCptMax_

template<GUM_Numeric GUM_SCALAR>

std::vector< std::vector< GUM_SCALAR > > gum::credal::CredalNet< GUM_SCALAR >::_binCptMax_

private

Used with binary networks to speed-up L2U inference.

Store the upper probabilities of each node X over the "true" modality, i.e. \(\overline{p}(X = 1 \mid pa(X) = j) \).

Definition at line 633 of file credalNet.h.

Referenced by computeBinaryCPTMinMax(), and get_binaryCPT_max().

_binCptMin_

template<GUM_Numeric GUM_SCALAR>

std::vector< std::vector< GUM_SCALAR > > gum::credal::CredalNet< GUM_SCALAR >::_binCptMin_

private

Used with binary networks to speed-up L2U inference.

Store the lower probabilities of each node X over the "true" modality, i.e. \(\underline{p}(X = 1 \mid pa(X) = j) \).

Definition at line 625 of file credalNet.h.

Referenced by computeBinaryCPTMinMax(), and get_binaryCPT_min().

_credalNet_current_cpt_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >* gum::credal::CredalNet< GUM_SCALAR >::_credalNet_current_cpt_

private

This CredalNet up-to-date CPTs.

Definition at line 606 of file credalNet.h.

Referenced by ~CredalNet(), _initParams_(), _sort_varType_(), approximatedBinarization(), credalNet_currentCpt(), and toString().

_credalNet_src_cpt_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > gum::credal::CredalNet< GUM_SCALAR >::_credalNet_src_cpt_

private

This CredalNet original CPTs.

Definition at line 602 of file credalNet.h.

Referenced by _intervalToCredal_(), _sort_varType_(), approximatedBinarization(), credalNet_currentCpt(), credalNet_srcCpt(), intervalToCredal(), intervalToCredalWithFiles(), setCPT(), setCPT(), setCPTs(), and toString().

_current_bn_

template<GUM_Numeric GUM_SCALAR>

BayesNet< GUM_SCALAR >* gum::credal::CredalNet< GUM_SCALAR >::_current_bn_

private

Up-to-date BayesNet (used as a DAG).

Definition at line 599 of file credalNet.h.

Referenced by ~CredalNet(), _bnCopy_(), _initParams_(), _sort_varType_(), approximatedBinarization(), current_bn(), and toString().

_current_nodeType_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< NodeType >* gum::credal::CredalNet< GUM_SCALAR >::_current_nodeType_

private

The NodeType of each node from the up-to-date network.

Definition at line 614 of file credalNet.h.

Referenced by ~CredalNet(), _initParams_(), _sort_varType_(), approximatedBinarization(), and currentNodeType().

_deltaC_

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_deltaC_

private

5 by default, used by fracC as number of decimals.

Definition at line 553 of file credalNet.h.

Referenced by _initParams_().

_denMax_

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_denMax_

private

Highest possible denominator allowed when using farey.

A value too high may lead to lrs being unable to find vertices.

Definition at line 580 of file credalNet.h.

Referenced by _H2Vlrs_(), and _initParams_().

_epsF_

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsF_

private

Value under which a decimal number is considered to be zero when using farey.

Definition at line 576 of file credalNet.h.

Referenced by _H2Vlrs_(), and _initParams_().

_epsilonMax_

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsilonMax_

private

The highest perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 562 of file credalNet.h.

Referenced by _initParams_(), bnToCredal(), epsilonMax(), and idmLearning().

_epsilonMin_

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsilonMin_

private

The lowest perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 558 of file credalNet.h.

Referenced by _initParams_(), bnToCredal(), epsilonMin(), and idmLearning().

_epsilonMoy_

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsilonMoy_

private

The average perturbation of the BayesNet provided as input for this CredalNet.

Definition at line 566 of file credalNet.h.

Referenced by _initParams_(), bnToCredal(), epsilonMean(), and idmLearning().

_epsRedund_

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_epsRedund_

private

Value under which a decimal number is considered to be zero when computing redundant vertices.

Definition at line 571 of file credalNet.h.

Referenced by _H2Vlrs_(), _initParams_(), and bnToCredal().

_hasComputedBinaryCPTMinMax_

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::CredalNet< GUM_SCALAR >::_hasComputedBinaryCPTMinMax_

private

Used by L2U, to know if lower and upper probabilities over the second modality has been stored in order to speed-up the algorithm.

Definition at line 618 of file credalNet.h.

Referenced by _initParams_(), computeBinaryCPTMinMax(), and hasComputedBinaryCPTMinMax().

_original_nodeType_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< NodeType > gum::credal::CredalNet< GUM_SCALAR >::_original_nodeType_

private

The NodeType of each node from the ORIGINAL network.

Definition at line 612 of file credalNet.h.

Referenced by _sort_varType_(), currentNodeType(), and nodeType().

_precision_

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_precision_

private

Precision used by frac.

Definition at line 583 of file credalNet.h.

Referenced by _initParams_().

_precisionC_

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CredalNet< GUM_SCALAR >::_precisionC_

private

1e6 by default, used by fracC as precision.

Definition at line 551 of file credalNet.h.

Referenced by _initParams_().

_separatelySpecified_

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::CredalNet< GUM_SCALAR >::_separatelySpecified_

private

TRUE if this CredalNet is separately and interval specified, FALSE otherwise.

Definition at line 588 of file credalNet.h.

Referenced by _intervalToCredal_(), intervalToCredal(), intervalToCredalWithFiles(), and isSeparatelySpecified().

_src_bn_

template<GUM_Numeric GUM_SCALAR>

BayesNet< GUM_SCALAR > gum::credal::CredalNet< GUM_SCALAR >::_src_bn_

private

Original BayesNet (used as a DAG).

Is never modified.

Definition at line 591 of file credalNet.h.

Referenced by CredalNet(), _bnCopy_(), _initCNNets_(), _initCNNets_(), _intervalToCredal_(), _sort_varType_(), addArc(), addVariable(), approximatedBinarization(), bnToCredal(), current_bn(), domainSize(), fillConstraint(), fillConstraint(), idmLearning(), instantiation(), intervalToCredal(), intervalToCredalWithFiles(), lagrangeNormalization(), setCPT(), setCPT(), setCPTs(), src_bn(), and toString().

_src_bn_max_

template<GUM_Numeric GUM_SCALAR>

BayesNet< GUM_SCALAR > gum::credal::CredalNet< GUM_SCALAR >::_src_bn_max_

private

BayesNet used to store upper probabilities.

Definition at line 596 of file credalNet.h.

Referenced by CredalNet(), _initCNNets_(), _initCNNets_(), _intervalToCredal_(), addArc(), addVariable(), bnToCredal(), fillConstraint(), fillConstraints(), idmLearning(), intervalToCredal(), intervalToCredalWithFiles(), and saveBNsMinMax().

_src_bn_min_

template<GUM_Numeric GUM_SCALAR>

BayesNet< GUM_SCALAR > gum::credal::CredalNet< GUM_SCALAR >::_src_bn_min_

private

BayesNet used to store lower probabilities.

Definition at line 594 of file credalNet.h.

Referenced by CredalNet(), _initCNNets_(), _initCNNets_(), _intervalToCredal_(), addArc(), addVariable(), bnToCredal(), fillConstraint(), fillConstraints(), idmLearning(), intervalToCredal(), intervalToCredalWithFiles(), and saveBNsMinMax().

_var_bits_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< std::vector< NodeId > > gum::credal::CredalNet< GUM_SCALAR >::_var_bits_

private

Corresponding bits of each variable.

Deprecated

Definition at line 609 of file credalNet.h.

Referenced by approximatedBinarization().

---

The documentation for this class was generated from the following files:

• agrum/CN/credalNet.h
• agrum/CN/credalNet_tpl.h