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

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

Detailed Description

template<typename 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()

Definition at line 88 of file credalNet.h.

Member Enumeration Documentation

NodeType

template<typename GUM_SCALAR >

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

strong

NodeType to speed-up computations in some algorithms.

Enumerator
Precise
Credal
Vacuous
Indic

Definition at line 91 of file credalNet.h.

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

Constructor & Destructor Documentation

CredalNet() [1/3]

template<typename 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 potentials.

Definition at line 31 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);
    }

CredalNet() [2/3]

template<typename GUM_SCALAR >

gum::credal::CredalNet< GUM_SCALAR >::CredalNet	(	const std::string &	src_min_num,
		const std::string &	src_max_den = ""
	)

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

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 path to a BayesNet which contains lower probabilities.
src_max_den	The ( optional ) path to a BayesNet which contains upper probabilities.

Definition at line 404 of file credalNet_tpl.h.

                                                                     {
      initParams__();
      initCNNets__(src_min_num, src_max_den);

      GUM_CONSTRUCTOR(CredalNet);
    }

CredalNet() [3/3]

template<typename 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 413 of file credalNet_tpl.h.

                                                                                  {
      initParams__();
      initCNNets__(src_min_num, src_max_den);

      GUM_CONSTRUCTOR(CredalNet);
    }

~CredalNet()

template<typename GUM_SCALAR >

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

(

)

Destructor.

Definition at line 422 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);
    }

Member Function Documentation

addArc()

template<typename 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 59 of file credalNet_tpl.h.

                                                                               {
      src_bn__.addArc(tail, head);
      src_bn_min__.addArc(tail, head);
      src_bn_max__.addArc(tail, head);
    }

addVariable()

template<typename GUM_SCALAR >

NodeId gum::credal::CredalNet< GUM_SCALAR >::addVariable	(	const std::string &	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 42 of file credalNet_tpl.h.

                                                                         {
      LabelizedVariable var(name, "node " + 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;
    }

approximatedBinarization()

template<typename 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 981 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< nodeType > *current_nodeType__;
      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 ( this->current_nodeType__ == nullptr )
        current_nodeType__ = & this->nodeType__;
      else
        current_nodeType__ = this->current_nodeType__;*/

      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, c;
          superiorPow((unsigned long)var_dSize, b, c);
          Size nb_bits{Size(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";
            std::stringstream ss;
            ss << bit;
            bit_name += ss.str();

            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 {
          std::string       bit_name = current_bn->variable(node).name();
          LabelizedVariable var_bit(bit_name, "node " + bit_name, 2);
          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()) {
        NodeSet parents = current_bn->parents(node);

        if (!parents.empty()) {
          for (auto par: current_bn->parents(node)) {
            for (Size parent_bit = 0, spbits = Size(var_bits__[par].size());
                 parent_bit < spbits;
                 parent_bit++)
              for (Size var_bit = 0, mbits = 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
        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

      auto varsize = current_bn->size();

      for (Size var = 0; var < varsize; var++) {
        auto bitsize = var_bits__[var].size();

        for (Size i = 0; i < bitsize; i++) {
          Potential< GUM_SCALAR > const* potential(
             &bin_bn->cpt(var_bits__[var][i]));
          Instantiation ins(potential);
          ins.setFirst();

          auto entry_size = potential->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((unsigned long)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((unsigned long)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;

            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 */
      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++) {
          std::stringstream ss;
          ss << src_bn__.variable(i).name();
          ss << "-v";
          ss << 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();
    }

bnCopy__()

template<typename 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 1497 of file credalNet_tpl.h.

                                                                       {
      const BayesNet< GUM_SCALAR >* current_bn__;

      if (this->current_bn__ == nullptr)
        current_bn__ = &this->src_bn__;
      else
        current_bn__ = this->current_bn__;

      for (auto node: current_bn__->nodes())
        dest.add(current_bn__->variable(node));

      dest.beginTopologyTransformation();

      for (auto node: current_bn__->nodes()) {
        for (auto parent_idIt: current_bn__->cpt(node).variablesSequence()) {
          if (current_bn__->nodeId(*parent_idIt) != node)
            dest.addArc(current_bn__->nodeId(*parent_idIt), node);
        }   // end of : for each parent in order of appearence
      }     // end of : for each variable

      dest.endTopologyTransformation();
    }

bnToCredal()

template<typename GUM_SCALAR >

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

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 434 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 Potential< GUM_SCALAR >* const potential(&src_bn__.cpt(node));

        Potential< GUM_SCALAR >* const potential_min(
           const_cast< Potential< GUM_SCALAR >* const >(&src_bn_min__.cpt(node)));
        Potential< GUM_SCALAR >* const potential_max(
           const_cast< Potential< GUM_SCALAR >* const >(&src_bn_max__.cpt(node)));

        Size var_dSize  = src_bn__.variable(node).domainSize();
        Size entry_size = potential->domainSize() / var_dSize;

        Instantiation ins(potential);
        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_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 = potential_max->get(ins_max);

          Size nbm = 0;

          for (Size modality = 0; modality < var_dSize; modality++) {
            vertex[modality] = potential->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(CPTNoSumTo1,
                        src_bn__.variable(node).name() << "(" << epsRedund__ << ")"
                                                       << " " << 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;
            }

            potential_min->set(ins_min, min);
            potential_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__();
    }

computeBinaryCPTMinMax()

template<typename 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 1307 of file credalNet_tpl.h.

                                                         {
      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;
    }

credalNet_currentCpt()

template<typename 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 1269 of file credalNet_tpl.h.

                                                           {
      if (credalNet_current_cpt__ != nullptr) return *credalNet_current_cpt__;

      return credalNet_src_cpt__;
    }

credalNet_srcCpt()

template<typename 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 1277 of file credalNet_tpl.h.

                                                       {
      return credalNet_src_cpt__;
    }

current_bn()

template<typename 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 1408 of file credalNet_tpl.h.

                                                                            {
      if (current_bn__ != nullptr) return *current_bn__;

      return src_bn__;
    }

currentNodeType()

template<typename GUM_SCALAR >

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

(

const NodeId &

id

)

const

Parameters

id	The constant reference to the choosen NodeId

Returns

Returns the type of the choosen node in the ( up-to-date ) CredalNet current_bn__ if any, src_bn__ otherwise.

Definition at line 1283 of file credalNet_tpl.h.

                                                                      {
      if (current_nodeType__ != nullptr) return (*(current_nodeType__))[id];

      return original_nodeType__[id];
    }

domainSize()

template<typename GUM_SCALAR >

INLINE 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 397 of file credalNet_tpl.h.

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

epsilonMax()

template<typename 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 1355 of file credalNet_tpl.h.

                                                                {
      return epsilonMax__;
    }

epsilonMean()

template<typename 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 1360 of file credalNet_tpl.h.

                                                                 {
      return epsilonMoy__;
    }

epsilonMin()

template<typename 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 1350 of file credalNet_tpl.h.

                                                                {
      return epsilonMin__;
    }

fillConstraint() [1/2]

template<typename 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 275 of file credalNet_tpl.h.

                                             {
      Potential< GUM_SCALAR >* const potential_min(
         const_cast< Potential< GUM_SCALAR >* const >(&src_bn_min__.cpt(id)));
      Potential< GUM_SCALAR >* const potential_max(
         const_cast< Potential< 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 = potential_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(potential_min);
      Instantiation max(potential_max);
      min.setFirst();
      max.setFirst();

      Idx pos = 0;

      while (pos != entry) {
        ++min;
        ++max;
        ++pos;
      }

      for (Size i = 0; i < var_dSize; i++) {
        potential_min->set(min, lower[i]);
        potential_max->set(max, upper[i]);
        ++min;
        ++max;
      }
    }

fillConstraint() [2/2]

template<typename 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 ), therefor we pass it by value

Definition at line 324 of file credalNet_tpl.h.

                                             {
      const Potential< GUM_SCALAR >* const potential(&src_bn__.cpt(id));
      /*
      auto var_dSize = src_bn__.variable ( id ).domainSize();
      auto entry_size = potential->domainSize() / var_dSize;
      */
      // to be sure of entry index reorder ins according to the bayes net
      // potentials
      // ( 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(potential);
      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);
    }

fillConstraints()

template<typename 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 259 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);
      }
    }

find_dNode_card__()

template<typename 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 1483 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);
    }

get_binaryCPT_max()

template<typename 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 1345 of file credalNet_tpl.h.

                                                        {
      return binCptMax__;
    }

get_binaryCPT_min()

template<typename 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 1339 of file credalNet_tpl.h.

                                                        {
      return binCptMin__;
    }

H2Vlrs__()

template<typename 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 1573 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
      // lrs arguments
      char* args[3];

      std::string soft_name = "lrs";
      std::string extfile(sinefile);
      extfile += ".ext";

      args[0] = new char[soft_name.size()];
      args[1] = new char[sinefile.size()];
      args[2] = new char[extfile.size()];

      strcpy(args[0], soft_name.c_str());
      strcpy(args[1], sinefile.c_str());
      strcpy(args[2], extfile.c_str());

      // standard cout to null (avoid lrs flooding)
      int old_cout, new_cout;
      fflush(stdout);
      old_cout = dup(1);

      new_cout = open("/dev/null", O_WRONLY);
      dup2(new_cout, 1);
      close(new_cout);

      lrs_main(3, args);

      // restore standard cout
      fflush(stdout);
      dup2(old_cout, 1);
      close(old_cout);

      delete[] args[2];
      delete[] args[1];
      delete[] args[0];

      // 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 ouput 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[] p;
        delete[] cstr;

        bool is_redund = false;

#pragma omp parallel
        {
          int this_thread = getThreadNumber();
          int num_threads = 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)
            }
          }   // 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);
    }

hasComputedBinaryCPTMinMax()

template<typename GUM_SCALAR >

const 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 1301 of file credalNet_tpl.h.

                                                                         {
      return hasComputedBinaryCPTMinMax__;
    }

idmLearning()

template<typename 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 Potential< GUM_SCALAR >* const potential(&src_bn__.cpt(node));

        Potential< GUM_SCALAR >* const potential_min(
           const_cast< Potential< GUM_SCALAR >* const >(&src_bn_min__.cpt(node)));
        Potential< GUM_SCALAR >* const potential_max(
           const_cast< Potential< GUM_SCALAR >* const >(&src_bn_max__.cpt(node)));

        Size var_dSize  = src_bn__.variable(node).domainSize();
        Size entry_size = potential->domainSize() / var_dSize;

        Instantiation ins(potential);
        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_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] = potential->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);

            potential_min->set(ins_min, min);
            potential_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__();
    }

initCNNets__() [1/2]

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::initCNNets__ ( const std::string &  src_min_num, const std::string &  src_max_den  )

private

Initialize private BayesNet variables after the Constructor has been called.

Definition at line 1451 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();
    }

initCNNets__() [2/2]

template<typename 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 1470 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;
    }

initParams__()

template<typename GUM_SCALAR >

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

private

Initialize private constant variables after the Constructor has been called.

Definition at line 1424 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;
    }

instantiation()

template<typename GUM_SCALAR >

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

(

const NodeId &

id

)

Get an Instantiation from a node id, usefull 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 392 of file credalNet_tpl.h.

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

intervalToCredal()

template<typename 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 786 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 Potential< GUM_SCALAR >* const potential_min(
           &src_bn_min__.cpt(node));
        const Potential< GUM_SCALAR >* const potential_max(
           &src_bn_max__.cpt(node));

        Size var_dSize  = src_bn__.variable(node).domainSize();
        Size entry_size = potential_min->domainSize() / var_dSize;

        std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(
           entry_size);

        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_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 (potential_min->get(ins_min) > potential_max->get(ins_max)) {
              GUM_ERROR(CPTError,
                        "For variable " << src_bn__.variable(node).name()
                                        << " (at " << ins_min
                                        << "), the min is greater than the max : "
                                        << potential_min->get(ins_min) << ">"
                                        << potential_max->get(ins_max) << ".");
            }
            lrsWrapper.fillH(potential_min->get(ins_min),
                             potential_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;
    }

intervalToCredal__()

template<typename 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 689 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 Potential< GUM_SCALAR >* const potential_min(
           &src_bn_min__.cpt(node));
        const Potential< GUM_SCALAR >* const potential_max(
           &src_bn_max__.cpt(node));

        Size var_dSize  = src_bn__.variable(node).domainSize();
        Size entry_size = potential_min->domainSize() / var_dSize;

        std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(
           entry_size);

        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_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] = potential_min->get(ins_min);
            upper[modality] = potential_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(CPTNoSumTo1,
                        src_bn__.variable(node).name() << " " << 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(CPTNoSumTo1,
                        src_bn__.variable(node).name() << " " << 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;
    }

intervalToCredalWithFiles()

template<typename 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 846 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 Potential< GUM_SCALAR >* const potential_min(
           &src_bn_min__.cpt(node));
        const Potential< GUM_SCALAR >* const potential_max(
           &src_bn_max__.cpt(node));

        auto var_dSize  = src_bn__.variable(node).domainSize();
        auto entry_size = potential_min->domainSize() / var_dSize;

        std::vector< std::vector< std::vector< GUM_SCALAR > > > var_cpt(
           entry_size);

        Instantiation ins_min(potential_min);
        Instantiation ins_max(potential_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]     = -potential_min->get(ins_min);
            inequalities[modality * 2 + 1][0] = potential_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;
    }

isSeparatelySpecified()

template<typename GUM_SCALAR >

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

(

)

const

Returns

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

Definition at line 1296 of file credalNet_tpl.h.

                                                                    {
      return separatelySpecified__;
    }

lagrangeNormalization()

template<typename 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 567 of file credalNet_tpl.h.

                                                        {
      for (auto node: src_bn__.nodes()) {
        const Potential< GUM_SCALAR >* const potential(&src_bn__.cpt(node));

        auto var_dSize  = src_bn__.variable(node).domainSize();
        auto entry_size = potential->domainSize() / var_dSize;

        Instantiation ins(potential);

        ins.setFirst();

        std::vector< GUM_SCALAR > vertex(var_dSize);

        for (Size entry = 0; entry < entry_size; entry++) {
          GUM_SCALAR    den      = 0;
          bool          zeroes   = false;
          Instantiation ins_prev = ins;

          for (Size modality = 0; modality < var_dSize; modality++) {
            vertex[modality] = potential->get(ins);

            if (vertex[modality] < 1 && vertex[modality] > 0)
              GUM_ERROR(OperationNotAllowed,
                        "lagrangeNormalization : the BayesNet "
                        "contains probabilities and not event "
                        "counts.");

            den += vertex[modality];

            if (!zeroes && vertex[modality] == 0) { zeroes = true; }

            ++ins;
          }

          if (zeroes) {
            ins = ins_prev;

            for (Size modality = 0; modality < var_dSize; modality++) {
              potential->set(ins, potential->get(ins) + 1);
              ++ins;
            }
          }

        }   // end of : for each entry

      }   // end of : for each variable
    }

nodeType()

template<typename GUM_SCALAR >

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

(

const NodeId &

id

)

const

Parameters

id	The constant reference to the choosen NodeId

Returns

Returns the type of the choosen node in the ( up-to-date ) CredalNet in src_bn__.

Definition at line 1291 of file credalNet_tpl.h.

                                                               {
      return original_nodeType__[id];
    }

saveBNsMinMax()

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::saveBNsMinMax	(	const std::string &	min_path,
		const std::string &	max_path
	)		const

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 945 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();
    }

setCPT() [1/2]

template<typename GUM_SCALAR >

void gum::credal::CredalNet< GUM_SCALAR >::setCPT	(	const NodeId &	id,
		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 112 of file credalNet_tpl.h.

                                                        {
      const Potential< GUM_SCALAR >* const potential(&src_bn__.cpt(id));

      auto var_dSize  = src_bn__.variable(id).domainSize();
      auto entry_size = potential->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 (std::fabs(sum - 1) > 1e-6)
          GUM_ERROR(
             CPTNoSumTo1,
             "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;

    }

setCPT() [2/2]

template<typename 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 ), therefor we pass it by value

Definition at line 168 of file credalNet_tpl.h.

                                                        {
      const Potential< GUM_SCALAR >* const potential(&src_bn__.cpt(id));

      auto var_dSize  = src_bn__.variable(id).domainSize();
      auto entry_size = potential->domainSize() / var_dSize;

      // to be sure of entry index reorder ins according to the bayes net
      // potentials
      // ( 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(potential);
      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 (std::fabs(sum - 1) > 1e-6)
          GUM_ERROR(
             CPTNoSumTo1,
             "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;

    }

setCPTs()

template<typename 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 66 of file credalNet_tpl.h.

                                                                     {
      const Potential< GUM_SCALAR >* const potential(&src_bn__.cpt(id));

      auto var_dSize  = src_bn__.variable(id).domainSize();
      auto entry_size = potential->domainSize() / var_dSize;

      if (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 (std::fabs(sum - 1) > 1e-6)
            GUM_ERROR(CPTNoSumTo1,
                      "setCPTs : a vertex coordinates does not "
                      "sum to one for node id : "
                         << id << " with vertex " << vertex);
        }
      }

      credalNet_src_cpt__.insert(id, cpt);
    }

sort_varType__()

template<typename GUM_SCALAR >

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

private

Set the NodeType of each node

Definition at line 1766 of file credalNet_tpl.h.

                                                 {
      NodeProperty< NodeType >* current_nodeType__;
      const NodeProperty<
         std::vector< std::vector< std::vector< GUM_SCALAR > > > >*
         credalNet_current_cpt__;

      const BayesNet< GUM_SCALAR >* current_bn__;

      if (this->current_bn__ == nullptr)
        current_bn__ = &src_bn__;
      else
        current_bn__ = this->current_bn__;

      if (this->credalNet_current_cpt__ == nullptr)
        credalNet_current_cpt__ = &credalNet_src_cpt__;
      else
        credalNet_current_cpt__ = this->credalNet_current_cpt__;

      if (this->current_nodeType__ == nullptr)
        current_nodeType__ = &original_nodeType__;
      else
        current_nodeType__ = this->current_nodeType__;

      /*if ( ! current_nodeType__->empty() )
        current_nodeType__->clear();*/

      for (auto node: current_bn__->nodes()) {
        // indicatrices are already present
        if (current_nodeType__->exists(node)) continue;

        bool precise = true, vacuous = true;

        for (auto entry   = (*credalNet_current_cpt__)[node].cbegin(),
                  theEnd2 = (*credalNet_current_cpt__)[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

              break;   // not vacuous
            }          // end of : for each vertex

            for (auto /*std::vector< bool >::const_iterator*/ 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) {
            current_nodeType__->insert(node, NodeType::Credal);
            break;
          }

        }   // end of : for each parents entry

        if (vacuous)
          current_nodeType__->insert(node, NodeType::Vacuous);
        else if (precise)
          current_nodeType__->insert(node, NodeType::Precise);

      }   // end of : for each variable
    }

src_bn()

template<typename 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 1415 of file credalNet_tpl.h.

                                                                        {
      return src_bn__;
    }

toString()

template<typename 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 1365 of file credalNet_tpl.h.

                                                      {
      std::stringstream             output;
      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__;

      for (auto node: current_bn__->nodes()) {
        const Potential< GUM_SCALAR >* potential(&current_bn__->cpt(node));
        auto                           pconfs
           = potential->domainSize() / current_bn__->variable(node).domainSize();

        output << "\n" << current_bn__->variable(node) << "\n";

        Instantiation ins(potential);
        ins.forgetMaster();
        ins.erase(current_bn__->variable(node));
        ins.setFirst();

        for (Size pconf = 0; pconf < pconfs; pconf++) {
          output << ins << " : ";
          output << (*credalNet_current_cpt__)[node][pconf] << "\n";

          if (pconf < pconfs - 1) ++ins;
        }
      }

      output << "\n";

      return output.str();
    }

Member Data Documentation

binCptMax__

template<typename 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 637 of file credalNet.h.

binCptMin__

template<typename 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 629 of file credalNet.h.

credalNet_current_cpt__

template<typename 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 610 of file credalNet.h.

credalNet_src_cpt__

template<typename 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 606 of file credalNet.h.

current_bn__

template<typename GUM_SCALAR >

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

private

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

Definition at line 602 of file credalNet.h.

current_nodeType__

template<typename 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 618 of file credalNet.h.

deltaC__

template<typename GUM_SCALAR >

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

private

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

Definition at line 556 of file credalNet.h.

denMax__

template<typename 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 583 of file credalNet.h.

epsF__

template<typename 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 579 of file credalNet.h.

epsilonMax__

template<typename 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 565 of file credalNet.h.

epsilonMin__

template<typename 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 561 of file credalNet.h.

epsilonMoy__

template<typename 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 569 of file credalNet.h.

epsRedund__

template<typename 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 574 of file credalNet.h.

hasComputedBinaryCPTMinMax__

template<typename 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 622 of file credalNet.h.

original_nodeType__

template<typename GUM_SCALAR >

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

private

The NodeType of each node from the ORIGINAL network.

Definition at line 616 of file credalNet.h.

precision__

template<typename GUM_SCALAR >

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

private

Precision used by frac__.

Definition at line 586 of file credalNet.h.

precisionC__

template<typename GUM_SCALAR >

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

private

1e6 by default, used by fracC__ as precision.

Definition at line 554 of file credalNet.h.

separatelySpecified__

template<typename GUM_SCALAR >

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

private

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

Definition at line 591 of file credalNet.h.

src_bn__

template<typename 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 594 of file credalNet.h.

src_bn_max__

template<typename GUM_SCALAR >

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

private

BayesNet used to store upper probabilities.

Definition at line 599 of file credalNet.h.

src_bn_min__

template<typename GUM_SCALAR >

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

private

BayesNet used to store lower probabilities.

Definition at line 597 of file credalNet.h.

var_bits__

template<typename GUM_SCALAR >

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

private

Corresponding bits of each variable.

Deprecated:

Definition at line 613 of file credalNet.h.

---

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

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