gum::AggregatorDecomposition< GUM_SCALAR > Class Template Reference

<agrum/BN/inference/tools/aggregatorDecomposition.h> More...

#include <aggregatorDecomposition.h>

Public Member Functions
Constructor & destructor.
	AggregatorDecomposition ()
	Default constructor. More...
virtual	~AggregatorDecomposition ()
	Destructor. More...
BayesNet< GUM_SCALAR > &	getDecomposedAggregator (BayesNet< GUM_SCALAR > &bn)
	Default constructor. More...
Getters & setters.
virtual std::string	name () const
gum::Size	getMaximumArity ()
void	setMaximumArity (gum::Size arity)

Protected Member Functions
Private evidence handling methods and members.
NodeId	addAggregator_ (BayesNet< GUM_SCALAR > &bn, std::string aggType, const DiscreteVariable &var, Idx value)
BayesNet< GUM_SCALAR > &	decomposeAggregator_ (BayesNet< GUM_SCALAR > &bn, NodeId node)
Set< NodeId >	addDepthLayer_ (BayesNet< GUM_SCALAR > &bn, Set< NodeId > nodes, NodeId initialAggregator, int &j)

Detailed Description

template<typename GUM_SCALAR>
class gum::AggregatorDecomposition< GUM_SCALAR >

<agrum/BN/inference/tools/aggregatorDecomposition.h>

This class is used to decompose aggregator in PRM<GUM_SCALAR>.

Definition at line 42 of file aggregatorDecomposition.h.

Constructor & Destructor Documentation

AggregatorDecomposition()

template<typename GUM_SCALAR >

INLINE gum::AggregatorDecomposition< GUM_SCALAR >::AggregatorDecomposition

(

)

Default constructor.

Definition at line 36 of file aggregatorDecomposition_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                        {
    arity__ = 2;
    GUM_CONSTRUCTOR(AggregatorDecomposition);
  }

Here is the call graph for this function:

~AggregatorDecomposition()

template<typename GUM_SCALAR >

gum::AggregatorDecomposition< GUM_SCALAR >::~AggregatorDecomposition ( )

virtual

Destructor.

Definition at line 42 of file aggregatorDecomposition_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                  {
    GUM_DESTRUCTOR(AggregatorDecomposition);
  }

Here is the call graph for this function:

Member Function Documentation

addAggregator_()

template<typename GUM_SCALAR >

NodeId gum::AggregatorDecomposition< GUM_SCALAR >::addAggregator_ ( BayesNet< GUM_SCALAR > &  bn, std::string  aggType, const DiscreteVariable &  var, Idx  value  )

protected

Definition at line 61 of file aggregatorDecomposition_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                    {
    if (toLower(aggType) == "min") {
      return bn.addMIN(var);
    } else if (toLower(aggType) == "max") {
      return bn.addMAX(var);
    } else if (toLower(aggType) == "count") {
      return bn.addCOUNT(var, value);
    } else if (toLower(aggType) == "exists") {
      return bn.addEXISTS(var, value);
    } else if (toLower(aggType) == "or") {
      return bn.addOR(var);
    } else if (toLower(aggType) == "and") {
      return bn.addAND(var);
    } else if (toLower(aggType) == "forall") {
      return bn.addFORALL(var);
    } else if (toLower(aggType) == "amplitude") {
      return bn.addAMPLITUDE(var);
    } else if (toLower(aggType) == "median") {
      return bn.addMEDIAN(var);
    } else if (toLower(aggType) == "sum") {
      return bn.addSUM(var);
    } else {
      std::string msg = "Unknown aggregate: ";
      msg.append(aggType);
      GUM_ERROR(NotFound, msg);
    }
  }

Here is the call graph for this function:

addDepthLayer_()

template<typename GUM_SCALAR >

Set< NodeId > gum::AggregatorDecomposition< GUM_SCALAR >::addDepthLayer_ ( BayesNet< GUM_SCALAR > &  bn, Set< NodeId >  nodes, NodeId  initialAggregator, int &  j  )

protected

Definition at line 237 of file aggregatorDecomposition_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                {
    auto p
       = static_cast< const gum::aggregator::MultiDimAggregator< GUM_SCALAR >* >(
          bn.cpt(initialAggregator).content());

    gum::Size   arity   = getMaximumArity();
    std::string aggType = p->aggregatorName();

    if (nodes.size() <= arity) {
      return nodes;
    } else {
      auto newAgg = bn.variable(initialAggregator).clone();

      Set< NodeId > newAggs = Set< NodeId >();

      List< NodeId > newAggParents;

      std::list< NodeId > orderedParents = {};

      for (const auto& elt: nodes) {
        orderedParents.push_back(elt);
      }

      orderedParents.sort();

      gum::Size i      = 0;
      gum::Size q      = 0;
      long      minVal = 0;
      long      maxVal = 0;

      j++;

      std::string newName = std::string(bn.variable(initialAggregator).name())
                          + "_" + std::to_string(j);

      newAgg->setName(newName);
      newAgg->setDescription(aggType);

      // for(Set<NodeId>::iterator it = nodes.begin(); it!= nodes.end(); ++it){
      for (auto it = orderedParents.begin(); it != orderedParents.end(); ++it) {
        if (q < nodes.size() - nodes.size() % arity) {
          if (i == arity) {
            i = 0;
            j++;

            if (newAgg->varType() == VarType::Labelized) {
              addAggregator_(bn, aggType, *newAgg, p->domainSize());
            } else if (newAgg->varType() == VarType::Range) {
              static_cast< RangeVariable* >(newAgg)->setMinVal(minVal);
              static_cast< RangeVariable* >(newAgg)->setMaxVal(maxVal);
              addAggregator_(bn, aggType, *newAgg, 0);
            } else {
              GUM_ERROR(OperationNotAllowed,
                        "Decomposition is not available for type : " + aggType);
            }

            for (NodeId node: newAggParents) {
              bn.addArc(node, bn.idFromName(newName));
            }

            newAggs.insert(bn.idFromName(newName));

            newAggParents.clear();

            minVal = 0;
            maxVal = 0;

            newName = std::string(bn.variable(initialAggregator).name()) + "_"
                    + std::to_string(j);

            delete (newAgg);
            newAgg = bn.variable(initialAggregator).clone();
            newAgg->setName(newName);
            newAgg->setDescription(aggType);

            if (bn.variable(*it).varType() == VarType::Range) {
              minVal
                 += static_cast< const RangeVariable& >(bn.variable(*it)).minVal();
              maxVal
                 += static_cast< const RangeVariable& >(bn.variable(*it)).maxVal();
            }

            newAggParents.push_back(*it);
            i++;
          } else {
            if (bn.variable(*it).varType() == VarType::Range) {
              minVal
                 += static_cast< const RangeVariable& >(bn.variable(*it)).minVal();
              maxVal
                 += static_cast< const RangeVariable& >(bn.variable(*it)).maxVal();
            }

            newAggParents.push_back(*it);
            i++;
          }
        } else {
          newAggs.insert(*it);
        }
        q++;
      }

      if (newAgg->varType() == VarType::Labelized) {
        addAggregator_(bn, aggType, *newAgg, p->domainSize());
      } else if (newAgg->varType() == VarType::Range) {
        static_cast< RangeVariable* >(newAgg)->setMinVal(minVal);
        static_cast< RangeVariable* >(newAgg)->setMaxVal(maxVal);
        addAggregator_(bn, aggType, *newAgg, 0);
      } else {
        GUM_ERROR(OperationNotAllowed,
                  "Decomposition is not available for type : " + aggType);
      }

      newAggs.insert(bn.idFromName(newName));

      for (NodeId node: newAggParents) {
        bn.addArc(node, bn.idFromName(newName));
      }

      delete (newAgg);
      return addDepthLayer_(bn, newAggs, initialAggregator, j);
    }
  }

Here is the call graph for this function:

decomposeAggregator_()

template<typename GUM_SCALAR >

BayesNet< GUM_SCALAR > & gum::AggregatorDecomposition< GUM_SCALAR >::decomposeAggregator_ ( BayesNet< GUM_SCALAR > &  bn, NodeId  node  )

protected

Definition at line 95 of file aggregatorDecomposition_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                   {
    auto p
       = static_cast< const gum::aggregator::MultiDimAggregator< GUM_SCALAR >* >(
          bn.cpt(initialAggregator).content());
    auto newAgg = bn.variable(initialAggregator).clone();

    Set< NodeId > parents = bn.parents(initialAggregator);

    std::list< NodeId > orderedParents = {};

    for (const auto& elt: parents) {
      orderedParents.push_back(elt);
    }

    orderedParents.sort();

    Set< NodeId >  newAggs = Set< NodeId >();
    List< NodeId > newAggParents;

    gum::Size arity = getMaximumArity();
    gum::Size q     = 0;
    gum::Size i     = 0;

    long minVal = 0;
    long maxVal = 0;

    int j = 1;

    std::string newName = std::string(bn.variable(initialAggregator).name()) + "_"
                        + std::to_string(j);
    std::string aggType = p->aggregatorName();

    for (auto parent: parents) {
      bn.eraseArc(parent, initialAggregator);
    }

    /*
     * We are constructing the new aggregator with a clone of the former
     */
    newAgg->setName(newName);
    newAgg->setDescription(aggType);

    // for(Set<NodeId>::iterator it = parents.begin(); it!= parents.end(); ++it){
    for (auto it = orderedParents.begin(); it != orderedParents.end(); ++it) {
      if (q < parents.size() - parents.size() % arity) {
        if (i == arity) {
          i = 0;
          j++;

          if (newAgg->varType() == VarType::Labelized) {
            addAggregator_(bn, aggType, *newAgg, p->domainSize());
          } else if (newAgg->varType() == VarType::Range) {
            static_cast< RangeVariable* >(newAgg)->setMinVal(minVal);
            static_cast< RangeVariable* >(newAgg)->setMaxVal(maxVal);
            addAggregator_(bn, aggType, *newAgg, 0);
          } else {
            GUM_ERROR(OperationNotAllowed,
                      "Decomposition is not available for type : " + aggType);
          }

          /*
           * Adding arcs in the new node from its parents and adding thoses into
           * the temporary potential
           */
          for (NodeId node: newAggParents) {
            bn.addArc(node, bn.idFromName(newName));
          }

          /*
           * Adding the new aggregator in t
           */
          newAggs.insert(bn.idFromName(newName));

          newAggParents.clear();

          minVal = 0;
          maxVal = 0;

          newName = std::string(bn.variable(initialAggregator).name()) + "_"
                  + std::to_string(j);

          delete (newAgg);
          newAgg = bn.variable(initialAggregator).clone();
          newAgg->setName(newName);
          newAgg->setDescription(aggType);

          if (bn.variable(*it).varType() == VarType::Range) {
            minVal
               += static_cast< const RangeVariable& >(bn.variable(*it)).minVal();
            maxVal
               += static_cast< const RangeVariable& >(bn.variable(*it)).maxVal();
          }

          newAggParents.push_back(*it);
          i++;
        } else {
          if (bn.variable(*it).varType() == VarType::Range) {
            minVal
               += static_cast< const RangeVariable& >(bn.variable(*it)).minVal();
            maxVal
               += static_cast< const RangeVariable& >(bn.variable(*it)).maxVal();
          }

          newAggParents.push_back(*it);
          i++;
        }
      } else {
        newAggs.insert(*it);
      }
      q++;
    }

    if (newAgg->varType() == VarType::Labelized) {
      addAggregator_(bn, aggType, *newAgg, p->domainSize());
    } else if (newAgg->varType() == VarType::Range) {
      static_cast< RangeVariable* >(newAgg)->setMinVal(minVal);
      static_cast< RangeVariable* >(newAgg)->setMaxVal(maxVal);
      addAggregator_(bn, aggType, *newAgg, 0);
    } else {
      GUM_ERROR(OperationNotAllowed,
                "Decomposition is not available for type : " + aggType);
    }

    newAggs.insert(bn.idFromName(newName));

    for (NodeId node: newAggParents) {
      bn.addArc(node, bn.idFromName(newName));
    }

    Set< NodeId > final = addDepthLayer_(bn, newAggs, initialAggregator, j);

    for (auto agg: final) {
      bn.addArc(agg, initialAggregator);
    }

    delete (newAgg);
    return bn;
  }

Here is the call graph for this function:

getDecomposedAggregator()

template<typename GUM_SCALAR >

BayesNet< GUM_SCALAR > & gum::AggregatorDecomposition< GUM_SCALAR >::getDecomposedAggregator

(

BayesNet< GUM_SCALAR > &

bn

)

Default constructor.

Definition at line 48 of file aggregatorDecomposition_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                    {
    for (NodeId node: bn.nodes().asNodeSet()) {
      std::string description = bn.cpt(node).toString();
      auto        p           = dynamic_cast<
         const gum::aggregator::MultiDimAggregator< GUM_SCALAR >* >(
         bn.cpt(node).content());
      if (p != nullptr && p->isDecomposable()) { decomposeAggregator_(bn, node); }
    }
    return bn;
  }

Here is the call graph for this function:

getMaximumArity()

template<typename GUM_SCALAR >

gum::Size gum::AggregatorDecomposition< GUM_SCALAR >::getMaximumArity

(

)

Definition at line 375 of file aggregatorDecomposition_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                 {
    return arity__;
  }

Here is the call graph for this function:

name()

template<typename GUM_SCALAR >

INLINE std::string gum::AggregatorDecomposition< GUM_SCALAR >::name ( ) const

virtual

Definition at line 380 of file aggregatorDecomposition_tpl.h.

                                                                     {
    return "aggregator decomposition";
  }

setMaximumArity()

template<typename GUM_SCALAR >

INLINE void gum::AggregatorDecomposition< GUM_SCALAR >::setMaximumArity

(

gum::Size

arity

)

Definition at line 367 of file aggregatorDecomposition_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                         {
    if (arity < 2) {
      GUM_ERROR(OperationNotAllowed, "Maximum arity should be at least 2");
    }
    arity__ = arity;
  }

Here is the call graph for this function:

Member Data Documentation

arity__

template<typename GUM_SCALAR >

gum::Size gum::AggregatorDecomposition< GUM_SCALAR >::arity__

private

Definition at line 90 of file aggregatorDecomposition.h.

---

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

• agrum/BN/inference/tools/aggregatorDecomposition.h
• agrum/BN/inference/tools/aggregatorDecomposition_tpl.h