gum::BayesNetFactory< GUM_SCALAR > Class Template Reference

A factory class to ease BayesNet construction. More...

#include <agrum/BN/BayesNetFactory.h>

Inheritance diagram for gum::BayesNetFactory< GUM_SCALAR >:

Collaboration diagram for gum::BayesNetFactory< GUM_SCALAR >:

Public Types
enum class	factory_state : char {   NONE , NETWORK , VARIABLE , PARENTS ,   RAW_CPT , FACT_CPT , FACT_ENTRY }
	The enumeration of states in which the factory can be in. More...

Public Member Functions
Constructor & destructor.
	BayesNetFactory (BayesNet< GUM_SCALAR > *bn)
	Use this constructor if you want to use an already created BayesNet.
	BayesNetFactory (const BayesNetFactory< GUM_SCALAR > &source)
	Copy constructor.
virtual	~BayesNetFactory ()
	Destructor.
Getter and setters.
BayesNet< GUM_SCALAR > *	bayesNet ()
	Returns the BayesNet created by this factory.
const DiscreteVariable &	varInBN (NodeId id) final
	short-cut accessor for a DiscreveVariable in the BN
factory_state	state () const final
	Returns the current state of the factory.
NodeId	variableId (const std::string &name) const final
	Returns the NodeId of a variable given it's name.
const DiscreteVariable &	variable (const std::string &name) const
	Returns a constant reference on a variable given it's name.
Size	cptDomainSize (NodeId n) const final
	Returns the domainSize of the cpt for the node n.
Network declaration methods (NONE -> NETWORK)
void	startNetworkDeclaration () final
	Tells the factory that we're in a network declaration.
void	variableType (const VarType &type)
	Tells the factory the current variable's type.
void	addNetworkProperty (const std::string &propName, const std::string &propValue) final
	Tells the factory to add a property to the current network.
void	endNetworkDeclaration () final
	Tells the factory that we're out of a network declaration.
Variable declaration methods (NONE -> VARIABLE)
void	startVariableDeclaration () final
	Tells the factory that we're in a variable declaration.
void	variableName (const std::string &name) final
	Tells the factory the current variable's name.
void	variableDescription (const std::string &desc) final
	Tells the factory the current variable's description.
void	addModality (const std::string &name) final
	Adds a modality to the current labelized variable.
void	addMin (const long &min)
	Adds the min value of the current range variable.
void	addMax (const long &max)
	Adds the max value of the current range variable.
void	addTick (const GUM_SCALAR &tick)
	Adds a tick to the current Discretized variable.
void	setVariableCPTImplementation (MultiDimAdressable *adressable) final
	Defines the implementation to use for var's Tensor.
NodeId	endVariableDeclaration () final
	Tells the factory that we're out of a variable declaration.
Parents declaration methods (NONE -> PARENTS)
void	startParentsDeclaration (const std::string &var) final
	Tells the factory that we're declaring parents for some variable.
void	addParent (const std::string &var) final
	Tells the factory for which variable we're declaring parents.
void	endParentsDeclaration () final
	Tells the factory that we've finished declaring parents for some variable.
Raw Probability table declaration methods (NONE -> RAW_CPT)
void	startRawProbabilityDeclaration (const std::string &var) final
	Tells the factory that we're declaring a conditional probability table for some variable.
void	rawConditionalTable (const std::vector< std::string > &variables, const std::vector< float > &rawTable) final
	Fills the variable's table with the values in rawTable.
void	rawConditionalTable (const std::vector< float > &rawTable) final
	Fills the variable's table with the values in rawTable.
void	endRawProbabilityDeclaration () final
	Tells the factory that we finished declaring a conditional probability table.
Factorized probability table declaration methods
void	startFactorizedProbabilityDeclaration (const std::string &var) final
	Tells the factory that we're starting a factorized declaration.
void	startFactorizedEntry () final
	Tells the factory that we start an entry of a factorized conditional probability table.
void	endFactorizedEntry () final
	Tells the factory that we end an entry of a factorized conditional probability table.
void	setParentModality (const std::string &parent, const std::string &modality) final
	Tells the factory on which modality we want to instantiate one of variable's parent.
void	setVariableValuesUnchecked (const std::vector< float > &values) final
	Gives the values of the variable with respect to precedent parents modality.
void	setVariableValues (const std::vector< float > &values) final
	same than below with gum::OperationNotAllowed exception if value's size not OK.
void	endFactorizedProbabilityDeclaration () final
	Tells the factory that we finished declaring a conditional probability table.
Delegated CPT definitions methods
(NONE, NETWORK)
void	setVariable (const DiscreteVariable &var) final
	Define a variable.
void	setVariableCPT (const std::string &varName, MultiDimAdressable *table, bool redefineParents) final
	Define a variable's CPT.
verbosity control
void	setVerbose ()
void	resetVerbose ()
bool	isVerbose ()

Private Member Functions
BayesNetFactory< GUM_SCALAR > &	operator= (const BayesNetFactory< GUM_SCALAR > &source)=delete
	Copy operator is illegal, use only copy constructor.
void	_illegalStateError_ (const std::string &s)
	Raise an OperationNotAllowed with the message "Illegal state.".
void	_checkVariableName_ (const std::string &name) const
	Check if a variable with the given name exists, if not raise an NotFound exception.
Idx	_checkVariableModality_ (const std::string &name, const std::string &mod)
	Check if var exists and if mod is one of it's modality, if not raise an NotFound exception.
void	_checkModalityInBag_ (const std::string &mod)
	Check if in stringBag there is no other modality with the same name.
void	_setCPTAndParents_ (const DiscreteVariable &var, Tensor< GUM_SCALAR > *table)
	Sub method of setVariableCPT() which redefine the BayesNet's DAG with respect to table.
void	_resetParts_ ()
	Reset the different parts used to constructed the BayesNet.
void	_fillProbaWithValuesTable_ (const std::vector< std::string > &variables, const std::vector< float > &rawTable)
	Fill a tensor from a raw CPT.
void	_fillProbaWithValuesTable_ (const std::vector< float > &rawTable)
	Fill a tensor from a raw CPT.(using the canonical order of vars).
bool	_increment_ (std::vector< gum::Idx > &modCounter, List< const DiscreteVariable * > &varList) const
	Increment a modality counter for the fillProbaWithValuesTable method.

Private Attributes
std::vector< factory_state >	_states_
	State stack.
BayesNet< GUM_SCALAR > *	_bn_
	The constructed BayesNet.
HashTable< std::string, NodeId >	_varNameMap_
	Mapping between a declared variable's name and it's node id.
bool	_verbose_
Current constructed BayesNet's parts.
bool	_foo_flag_
	Depending on the context this flag is used for some VERY important reasons.
bool	_bar_flag_
	Depending on the context this flag is used for some VERY important reasons.
std::vector< std::string >	_stringBag_
	Just to keep track of strings between two start/end calls.
Instantiation *	_parents_
	Used when a factorized CPT is built.
MultiDimImplementation< GUM_SCALAR > *	_impl_
	Implementation of variable between two startVariableDeclaration/endVariableDeclaration calls.

Detailed Description

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

A factory class to ease BayesNet construction.

A BayesNetFactory will never create a BayesNet and works on only one BayesNet.

The only exception of this behaviour is when you create a copy of the factory, it will create a copy of it's BayesNet. This is useful if you want to create two BayesNet sharing a common base.

However be very careful because the copy will not delete it's BayesNet.

Each method will raise an OperationNotAllowed if you call it when the factory is not in a valid state for that call. The error message is "Illegal state.".

Definition at line 81 of file BayesNetFactory.h.

Member Enumeration Documentation

factory_state

enum class gum::IBayesNetFactory::factory_state : char

stronginherited

The enumeration of states in which the factory can be in.

Every documentation section's name indicates from which state you can call it's methods, and in which state it places the factory.

There is an exception for the delegated CPT definition methods which do not change the state of the factory.

Enumerator
NONE
NETWORK
VARIABLE
PARENTS
RAW_CPT
FACT_CPT
FACT_ENTRY

Definition at line 79 of file IBayesNetFactory.h.

                             : char {
      NONE,
      NETWORK,
      VARIABLE,
      PARENTS,
      RAW_CPT,
      FACT_CPT,
      FACT_ENTRY
    };

Constructor & Destructor Documentation

BayesNetFactory() [1/2]

template<typename GUM_SCALAR>

INLINE gum::BayesNetFactory< GUM_SCALAR >::BayesNetFactory ( BayesNet< GUM_SCALAR > * bn )

explicit

Use this constructor if you want to use an already created BayesNet.

Parameters

bn	A pointer over the BayesNet filled by this factory.

Exceptions

DuplicateElement

Raised if two variables in bn share the same name.

Definition at line 60 of file BayesNetFactory_tpl.h.

                                                                                  :
      _parents_(nullptr), _impl_(0), _bn_(bn) {
    GUM_CONSTRUCTOR(BayesNetFactory);
    _states_.push_back(factory_state::NONE);
 
    for (auto node: bn->nodes()) {
      if (_varNameMap_.exists(bn->variable(node).name()))
        GUM_ERROR(DuplicateElement, "Name already used: " << bn->variable(node).name())
 
      _varNameMap_.insert(bn->variable(node).name(), node);
    }
 
    resetVerbose();
  }

References BayesNetFactory(), _bn_, _impl_, _parents_, _states_, _varNameMap_, GUM_ERROR, gum::IBayesNetFactory::NONE, and gum::IBayesNetFactory::resetVerbose().

Referenced by BayesNetFactory(), BayesNetFactory(), ~BayesNetFactory(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

BayesNetFactory() [2/2]

template<typename GUM_SCALAR>

INLINE gum::BayesNetFactory< GUM_SCALAR >::BayesNetFactory

(

const BayesNetFactory< GUM_SCALAR > &

source

)

Copy constructor.

The copy will have an exact copy of the constructed BayesNet in source.

Warning

You can only copy a factory if its current state is NONE or NETWORK.

Exceptions

OperationNotAllowed

Raised if the state of source is not NONE or NETWORK.

Definition at line 79 of file BayesNetFactory_tpl.h.

                                                                                                :
      _parents_(nullptr), _impl_(nullptr), _bn_(nullptr) {
    GUM_CONS_CPY(BayesNetFactory);
 
    if (source.state() != factory_state::NONE) {
      GUM_ERROR(OperationNotAllowed, "Illegal state to proceed make a copy.")
    } else {
      _states_ = source._states_;
      _bn_     = new BayesNet< GUM_SCALAR >(*(source._bn_));
    }
  }

References BayesNetFactory(), _bn_, _impl_, _parents_, _states_, GUM_ERROR, gum::IBayesNetFactory::NONE, and state().

Here is the call graph for this function:

~BayesNetFactory()

template<typename GUM_SCALAR>

INLINE gum::BayesNetFactory< GUM_SCALAR >::~BayesNetFactory ( )

virtual

Destructor.

To prevent strange behaviour you should always destroy a BayesNetFactory when it's state equals NONE.

Exceptions

FatalError

Raised if the state of the factory prevents it to die peacefully.

Definition at line 93 of file BayesNetFactory_tpl.h.

                                                         {
    GUM_DESTRUCTOR(BayesNetFactory);
 
    if (_parents_ != nullptr) delete _parents_;
 
    if (_impl_ != nullptr) {
      //@todo better than throwing an exception from inside a destructor but
      // still ...
      std::cerr << "[BN factory] Implementation defined for a variable but not used. "
                   "You should call endVariableDeclaration() before "
                   "deleting me."
                << std::endl;
      exit(1);
    }
  }

References BayesNetFactory(), _impl_, and _parents_.

Here is the call graph for this function:

Member Function Documentation

_checkModalityInBag_()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::_checkModalityInBag_ ( const std::string & mod )

private

Check if in stringBag there is no other modality with the same name.

Definition at line 917 of file BayesNetFactory_tpl.h.

                                                                                      {
    for (size_t i = 3; i < _stringBag_.size(); ++i) {
      if (mod == _stringBag_[i]) { GUM_ERROR(DuplicateElement, "Label already used: " << mod) }
    }
  }

References _stringBag_, and GUM_ERROR.

Referenced by addModality().

Here is the caller graph for this function:

_checkVariableModality_()

template<typename GUM_SCALAR>

INLINE Idx gum::BayesNetFactory< GUM_SCALAR >::_checkVariableModality_ ( const std::string & name, const std::string & mod )

private

Check if var exists and if mod is one of it's modality, if not raise an NotFound exception.

Definition at line 903 of file BayesNetFactory_tpl.h.

                                                                                          {
    _checkVariableName_(name);
    const DiscreteVariable& var = _bn_->variable(_varNameMap_[name]);
 
    for (Idx i = 0; i < var.domainSize(); ++i) {
      if (mod == var.label(i)) { return i; }
    }
 
    GUM_ERROR(NotFound, mod)
  }

References _bn_, _checkVariableName_(), _varNameMap_, gum::DiscreteVariable::domainSize(), GUM_ERROR, and gum::DiscreteVariable::label().

Referenced by setParentModality().

Here is the call graph for this function:

Here is the caller graph for this function:

_checkVariableName_()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::_checkVariableName_ ( const std::string & name ) const

private

Check if a variable with the given name exists, if not raise an NotFound exception.

Definition at line 896 of file BayesNetFactory_tpl.h.

                                                                                            {
    if (!_varNameMap_.exists(name)) { GUM_ERROR(NotFound, name) }
  }

References _varNameMap_, and GUM_ERROR.

Referenced by _checkVariableModality_(), _setCPTAndParents_(), addParent(), setParentModality(), setVariable(), setVariableCPT(), startFactorizedProbabilityDeclaration(), startParentsDeclaration(), and startRawProbabilityDeclaration().

Here is the caller graph for this function:

_fillProbaWithValuesTable_() [1/2]

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::_fillProbaWithValuesTable_ ( const std::vector< float > & rawTable )

private

Fill a tensor from a raw CPT.(using the canonical order of vars).

Definition at line 546 of file BayesNetFactory_tpl.h.

                                          {
    const Tensor< GUM_SCALAR >& table = _bn_->cpt(_varNameMap_[_stringBag_[0]]);
 
    Instantiation cptInst(table);
 
    // the main loop is on the first variables. The others are in the right
    // order.
    const DiscreteVariable& first = table.variable(0);
    Idx                     j     = 0;
 
    for (cptInst.setFirstVar(first); !cptInst.end(); cptInst.incVar(first)) {
      for (cptInst.setFirstNotVar(first); !cptInst.end(); cptInst.incNotVar(first))
        table.set(cptInst,
                  (j < rawTable.size()) ? static_cast< GUM_SCALAR >(rawTable[j++])
                                        : static_cast< GUM_SCALAR >(0));
 
      cptInst.unsetEnd();
    }
  }

References _bn_, _stringBag_, _varNameMap_, gum::Instantiation::end(), gum::Instantiation::incNotVar(), gum::Instantiation::incVar(), gum::Instantiation::setFirstNotVar(), gum::Instantiation::setFirstVar(), and gum::Instantiation::unsetEnd().

Here is the call graph for this function:

_fillProbaWithValuesTable_() [2/2]

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::_fillProbaWithValuesTable_ ( const std::vector< std::string > & variables, const std::vector< float > & rawTable )

private

Fill a tensor from a raw CPT.

Definition at line 503 of file BayesNetFactory_tpl.h.

                                                {
    const Tensor< GUM_SCALAR >& table = _bn_->cpt(_varNameMap_[_stringBag_[0]]);
    Instantiation               cptInst(table);
 
    List< const DiscreteVariable* > varList;
    table.fillWith(GUM_SCALAR(0.0));
 
    for (size_t i = 0; i < variables.size(); ++i) {
      varList.pushBack(&(_bn_->variable(_varNameMap_[variables[i]])));
    }
 
    Idx nbrVar = varList.size();
 
    std::vector< Idx > modCounter;
 
    // initializing the array
    for (NodeId i = 0; i < nbrVar; i++) {
      modCounter.push_back(Idx(0));
    }
 
    for (Idx j = 0; j < rawTable.size(); j++) {
      for (NodeId i = 0; i < nbrVar; i++) {
        cptInst.chgVal(*(varList[i]), modCounter[i]);
      }
 
      table.set(cptInst, static_cast< GUM_SCALAR >(rawTable[j]));
      if (!_increment_(modCounter, varList)) { break; }   // too many values (just not read)
    }
  }

References _bn_, _increment_(), _stringBag_, _varNameMap_, gum::Instantiation::chgVal(), gum::List< Val >::pushBack(), and gum::List< Val >::size().

Referenced by rawConditionalTable(), and rawConditionalTable().

Here is the call graph for this function:

Here is the caller graph for this function:

_illegalStateError_()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::_illegalStateError_ ( const std::string & s )

private

Raise an OperationNotAllowed with the message "Illegal state.".

Definition at line 844 of file BayesNetFactory_tpl.h.

                                                                                   {
    std::string msg = "Illegal state call (";
    msg += s;
    msg += ") in state ";
 
    switch (state()) {
      case factory_state::NONE : {
        msg += "NONE";
        break;
      }
 
      case factory_state::NETWORK : {
        msg += "NETWORK";
        break;
      }
 
      case factory_state::VARIABLE : {
        msg += "VARIABLE";
        break;
      }
 
      case factory_state::PARENTS : {
        msg += "PARENTS";
        break;
      }
 
      case factory_state::RAW_CPT : {
        msg += "RAW_CPT";
        break;
      }
 
      case factory_state::FACT_CPT : {
        msg += "FACT_CPT";
        break;
      }
 
      case factory_state::FACT_ENTRY : {
        msg += "FACT_ENTRY";
        break;
      }
 
      default : {
        msg += "Unknown state";
      }
    }
 
    GUM_ERROR(OperationNotAllowed, msg)
  }

References gum::IBayesNetFactory::FACT_CPT, gum::IBayesNetFactory::FACT_ENTRY, GUM_ERROR, gum::IBayesNetFactory::NETWORK, gum::IBayesNetFactory::NONE, gum::IBayesNetFactory::PARENTS, gum::IBayesNetFactory::RAW_CPT, state(), and gum::IBayesNetFactory::VARIABLE.

Referenced by addMax(), addMin(), addModality(), addParent(), addTick(), endFactorizedEntry(), endFactorizedProbabilityDeclaration(), endNetworkDeclaration(), endParentsDeclaration(), endRawProbabilityDeclaration(), endVariableDeclaration(), rawConditionalTable(), rawConditionalTable(), setParentModality(), setVariable(), setVariableCPT(), setVariableCPTImplementation(), setVariableValues(), setVariableValuesUnchecked(), startFactorizedEntry(), startFactorizedProbabilityDeclaration(), startNetworkDeclaration(), startParentsDeclaration(), startRawProbabilityDeclaration(), startVariableDeclaration(), variableDescription(), variableName(), and variableType().

Here is the call graph for this function:

Here is the caller graph for this function:

_increment_()

template<typename GUM_SCALAR>

INLINE bool gum::BayesNetFactory< GUM_SCALAR >::_increment_ ( std::vector< gum::Idx > & modCounter, List< const DiscreteVariable * > & varList ) const

private

Increment a modality counter for the fillProbaWithValuesTable method.

Definition at line 569 of file BayesNetFactory_tpl.h.

                                                                                                 {
    bool last = true;
 
    for (NodeId j = 0; j < modCounter.size(); j++) {
      last = (modCounter[j] == (varList[j]->domainSize() - 1)) && last;
 
      if (!last) break;
    }
 
    if (last) { return false; }
 
    bool add = false;
 
    auto i = NodeId(varList.size() - 1);
 
    do {
      if (modCounter[i] == (varList[i]->domainSize() - 1)) {
        modCounter[i] = 0;
        add           = true;
      } else {
        modCounter[i] += 1;
        add = false;
      }
 
      i--;
    } while (add);
 
    return true;
  }

References gum::List< Val >::size().

Referenced by _fillProbaWithValuesTable_().

Here is the call graph for this function:

Here is the caller graph for this function:

_resetParts_()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::_resetParts_ ( )

private

Reset the different parts used to constructed the BayesNet.

Definition at line 944 of file BayesNetFactory_tpl.h.

                                                          {
    _foo_flag_ = false;
    _bar_flag_ = false;
    _stringBag_.clear();
  }

References _bar_flag_, _foo_flag_, and _stringBag_.

Referenced by endFactorizedProbabilityDeclaration(), endParentsDeclaration(), endRawProbabilityDeclaration(), and endVariableDeclaration().

Here is the caller graph for this function:

_setCPTAndParents_()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::_setCPTAndParents_ ( const DiscreteVariable & var, Tensor< GUM_SCALAR > * table )

private

Sub method of setVariableCPT() which redefine the BayesNet's DAG with respect to table.

Definition at line 926 of file BayesNetFactory_tpl.h.

                                                                                               {
    NodeId varId = _varNameMap_[var.name()];
    _bn_->dag_.eraseParents(varId);
 
    for (auto v: table->variablesSequence()) {
      if (v != (&var)) {
        _checkVariableName_(v->name());
        _bn_->dag_.addArc(_varNameMap_[v->name()], varId);
      }
    }
 
    // CPT are created when a variable is added.
    _bn_->_unsafeChangeTensor_(varId, table);
  }

References _bn_, _checkVariableName_(), _varNameMap_, and gum::Variable::name().

Referenced by setVariableCPT().

Here is the call graph for this function:

Here is the caller graph for this function:

addMax()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::addMax ( const long & max )

virtual

Adds the max value of the current range variable.

Implements gum::IBayesNetFactory.

Definition at line 272 of file BayesNetFactory_tpl.h.

                                                                   {
    if (state() != factory_state::VARIABLE) {
      _illegalStateError_("addMax");
    } else {
      _stringBag_.push_back(std::to_string(max));
    }
  }

References _illegalStateError_(), _stringBag_, state(), and gum::IBayesNetFactory::VARIABLE.

Here is the call graph for this function:

addMin()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::addMin ( const long & min )

virtual

Adds the min value of the current range variable.

Implements gum::IBayesNetFactory.

Definition at line 260 of file BayesNetFactory_tpl.h.

                                                                   {
    if (state() != factory_state::VARIABLE) {
      _illegalStateError_("addMin");
    } else {
      _stringBag_.push_back(std::to_string(min));
    }
  }

References _illegalStateError_(), _stringBag_, state(), and gum::IBayesNetFactory::VARIABLE.

Here is the call graph for this function:

addModality()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::addModality ( const std::string & name )

finalvirtual

Adds a modality to the current labelized variable.

Implements gum::IBayesNetFactory.

Definition at line 247 of file BayesNetFactory_tpl.h.

                                                                              {
    if (state() != factory_state::VARIABLE) {
      _illegalStateError_("addModality");
    } else {
      _checkModalityInBag_(name);
      _stringBag_.push_back(name);
    }
  }

References _checkModalityInBag_(), _illegalStateError_(), _stringBag_, state(), and gum::IBayesNetFactory::VARIABLE.

Referenced by gum::prm::PRMSystem< double >::getArrayType().

Here is the call graph for this function:

Here is the caller graph for this function:

addNetworkProperty()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::addNetworkProperty ( const std::string & propName, const std::string & propValue )

finalvirtual

Tells the factory to add a property to the current network.

Implements gum::IBayesNetFactory.

Definition at line 166 of file BayesNetFactory_tpl.h.

                                                                                            {
    _bn_->setProperty(propName, propValue);
  }

References _bn_.

Referenced by gum::prm::PRMSystem< GUM_SCALAR >::groundedBN().

Here is the caller graph for this function:

addParent()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::addParent ( const std::string & var )

finalvirtual

Tells the factory for which variable we're declaring parents.

Parameters

var	The parent's name.

Exceptions

NotFound

Raised if var does not exists.

Implements gum::IBayesNetFactory.

Definition at line 433 of file BayesNetFactory_tpl.h.

                                                                           {
    if (state() != factory_state::PARENTS) {
      _illegalStateError_("addParent");
    } else {
      _checkVariableName_(var);
      _stringBag_.push_back(var);
    }
  }

References _checkVariableName_(), _illegalStateError_(), _stringBag_, gum::IBayesNetFactory::PARENTS, and state().

Referenced by gum::prm::PRMSystem< GUM_SCALAR >::_groundRef_().

Here is the call graph for this function:

Here is the caller graph for this function:

addTick()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::addTick

(

const GUM_SCALAR &

tick

)

Adds a tick to the current Discretized variable.

Definition at line 284 of file BayesNetFactory_tpl.h.

                                                                           {
    if (state() != factory_state::VARIABLE) {
      _illegalStateError_("addTick");
    } else {
      _stringBag_.push_back(std::to_string(tick));
    }
  }

References _illegalStateError_(), _stringBag_, state(), and gum::IBayesNetFactory::VARIABLE.

Here is the call graph for this function:

bayesNet()

template<typename GUM_SCALAR>

INLINE BayesNet< GUM_SCALAR > * gum::BayesNetFactory< GUM_SCALAR >::bayesNet

(

)

Returns the BayesNet created by this factory.

Exceptions

OperationNotAllowed

Raise if the state of the factory is different than NONE.

Definition at line 111 of file BayesNetFactory_tpl.h.

                                                                         {
    return _bn_;
  }

References _bn_.

cptDomainSize()

template<typename GUM_SCALAR>

INLINE Size gum::BayesNetFactory< GUM_SCALAR >::cptDomainSize ( NodeId n ) const

finalvirtual

Returns the domainSize of the cpt for the node n.

Exceptions

NotFound

raised if no such NodeId exists.

Implements gum::IBayesNetFactory.

Definition at line 150 of file BayesNetFactory_tpl.h.

                                                                               {
    return _bn_->cpt(n).domainSize();
  }

References _bn_.

endFactorizedEntry()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::endFactorizedEntry ( )

finalvirtual

Tells the factory that we end an entry of a factorized conditional probability table.

Implements gum::IBayesNetFactory.

Definition at line 640 of file BayesNetFactory_tpl.h.

                                                                {
    if (state() != factory_state::FACT_ENTRY) {
      _illegalStateError_("endFactorizedEntry");
    } else {
      delete _parents_;
      _parents_ = nullptr;
      _states_.pop_back();
    }
  }

References _illegalStateError_(), _parents_, _states_, gum::IBayesNetFactory::FACT_ENTRY, and state().

Here is the call graph for this function:

endFactorizedProbabilityDeclaration()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::endFactorizedProbabilityDeclaration ( )

finalvirtual

Tells the factory that we finished declaring a conditional probability table.

Implements gum::IBayesNetFactory.

Definition at line 759 of file BayesNetFactory_tpl.h.

                                                                                 {
    if (state() != factory_state::FACT_CPT) {
      _illegalStateError_("endFactorizedProbabilityDeclaration");
    } else {
      _resetParts_();
      _states_.pop_back();
    }
  }

References _illegalStateError_(), _resetParts_(), _states_, gum::IBayesNetFactory::FACT_CPT, and state().

Here is the call graph for this function:

endNetworkDeclaration()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::endNetworkDeclaration ( )

finalvirtual

Tells the factory that we're out of a network declaration.

Implements gum::IBayesNetFactory.

Definition at line 173 of file BayesNetFactory_tpl.h.

                                                                   {
    if (state() != factory_state::NETWORK) {
      _illegalStateError_("endNetworkDeclaration");
    } else {
      _states_.pop_back();
    }
  }

References _illegalStateError_(), _states_, gum::IBayesNetFactory::NETWORK, and state().

Referenced by gum::prm::PRMSystem< GUM_SCALAR >::groundedBN().

Here is the call graph for this function:

Here is the caller graph for this function:

endParentsDeclaration()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::endParentsDeclaration ( )

finalvirtual

Tells the factory that we've finished declaring parents for some variable.

Warning

When parents exist, endParentsDeclaration creates some arcs. Due to the order used in BIF file for probability specification, these arcs are created in the inverse order of the order of the parent specifications.

Implements gum::IBayesNetFactory.

Definition at line 447 of file BayesNetFactory_tpl.h.

                                                                   {
    if (state() != factory_state::PARENTS) {
      _illegalStateError_("endParentsDeclaration");
    } else {
      NodeId id = _varNameMap_[_stringBag_[0]];
 
      // PLEASE NOTE THAT THE ORDER IS INVERSE
 
      for (size_t i = _stringBag_.size() - 1; i > 0; --i) {
        _bn_->addArc(_varNameMap_[_stringBag_[i]], id);
      }
 
      _resetParts_();
 
      _states_.pop_back();
    }
  }

References _bn_, _illegalStateError_(), _resetParts_(), _states_, _stringBag_, _varNameMap_, gum::IBayesNetFactory::PARENTS, and state().

Here is the call graph for this function:

endRawProbabilityDeclaration()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::endRawProbabilityDeclaration ( )

finalvirtual

Tells the factory that we finished declaring a conditional probability table.

Implements gum::IBayesNetFactory.

Definition at line 603 of file BayesNetFactory_tpl.h.

                                                                          {
    if (state() != factory_state::RAW_CPT) {
      _illegalStateError_("endRawProbabilityDeclaration");
    } else {
      _resetParts_();
      _states_.pop_back();
    }
  }

References _illegalStateError_(), _resetParts_(), _states_, gum::IBayesNetFactory::RAW_CPT, and state().

Here is the call graph for this function:

endVariableDeclaration()

template<typename GUM_SCALAR>

INLINE NodeId gum::BayesNetFactory< GUM_SCALAR >::endVariableDeclaration ( )

finalvirtual

Tells the factory that we're out of a variable declaration.

Returns

The Node id of the created variable.

Exceptions

gum::OperationNotAllowed

Raised if the variable isn't defined (or / not enough defined).

Implements gum::IBayesNetFactory.

Definition at line 324 of file BayesNetFactory_tpl.h.

                                                                      {
    if (state() != factory_state::VARIABLE) {
      _illegalStateError_("endVariableDeclaration");
    } else if (_foo_flag_ && (_stringBag_.size() > 4)) {
      DiscreteVariable* var = nullptr;
 
      // if the current variable is a LabelizedVariable
      if (_stringBag_[2] == "L") {
        const auto l = new LabelizedVariable(_stringBag_[0], (_bar_flag_) ? _stringBag_[1] : "", 0);
 
        for (size_t i = 3; i < _stringBag_.size(); ++i) {
          l->addLabel(_stringBag_[i]);
        }
 
        var = l;
        // if the current variable is a RangeVariable
      } else if (_stringBag_[2] == "I") {
        // try to create the domain of the variable
        std::vector< int > domain;
        for (size_t i = 3; i < _stringBag_.size(); ++i) {
          domain.push_back(std::stoi(_stringBag_[i]));
        }
 
        const auto v
            = new IntegerVariable(_stringBag_[0], _bar_flag_ ? _stringBag_[1] : "", domain);
        var = v;
      } else if (_stringBag_[2] == "R") {
        const auto r = new RangeVariable(_stringBag_[0],
                                         _bar_flag_ ? _stringBag_[1] : "",
                                         std::stol(_stringBag_[3]),
                                         std::stol(_stringBag_[4]));
 
        var = r;
        // if the current variable is a DiscretizedVariable
      } else if (_stringBag_[2] == "D") {
        auto d = new DiscretizedVariable< GUM_SCALAR >(_stringBag_[0],
                                                       _bar_flag_ ? _stringBag_[1] : "");
 
        for (size_t i = 3; i < _stringBag_.size(); ++i) {
          d->addTick(std::stof(_stringBag_[i]));
        }
 
        var = d;
      }
 
      if (var == nullptr) {
        GUM_ERROR(OperationNotAllowed, "Unknown variable type for variable " + _stringBag_[0])
      }
 
      if (_impl_ != 0) {
        _varNameMap_.insert(var->name(), _bn_->add(*var, _impl_));
        _impl_ = 0;
      } else {
        _varNameMap_.insert(var->name(), _bn_->add(*var));
      }
 
      NodeId retVal = _varNameMap_[var->name()];
 
      delete var;
 
      _resetParts_();
      _states_.pop_back();
 
      return retVal;
    } else {
      std::stringstream msg;
      msg << "Not enough modalities (";
 
      if (_stringBag_.size() > 3) {
        msg << _stringBag_.size() - 3;
      } else {
        msg << 0;
      }
 
      msg << ") declared for variable ";
 
      if (_foo_flag_) {
        msg << _stringBag_[0];
      } else {
        msg << "unknown";
      }
 
      _resetParts_();
 
      _states_.pop_back();
      GUM_ERROR(OperationNotAllowed, msg.str())
    }
 
    // For noisy compilers
    return 0;
  }

References _bar_flag_, _bn_, _foo_flag_, _illegalStateError_(), _impl_, _resetParts_(), _states_, _stringBag_, _varNameMap_, GUM_ERROR, gum::Variable::name(), state(), and gum::IBayesNetFactory::VARIABLE.

Here is the call graph for this function:

isVerbose()

bool gum::IBayesNetFactory::isVerbose ( )

inlineinherited

Definition at line 101 of file IBayesNetFactory.h.

{ return _verbose_; };

References _verbose_.

operator=()

template<typename GUM_SCALAR>

BayesNetFactory< GUM_SCALAR > & gum::BayesNetFactory< GUM_SCALAR >::operator= ( const BayesNetFactory< GUM_SCALAR > & source )

privatedelete

Copy operator is illegal, use only copy constructor.

References BayesNetFactory().

Here is the call graph for this function:

rawConditionalTable() [1/2]

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::rawConditionalTable ( const std::vector< float > & rawTable )

finalvirtual

Fills the variable's table with the values in rawTable.

use the canonical ordering for the variables (e.g. see BIF format) ...

Parameters

rawTable

The raw table.

Implements gum::IBayesNetFactory.

Definition at line 537 of file BayesNetFactory_tpl.h.

                                                                                           {
    if (state() != factory_state::RAW_CPT) {
      _illegalStateError_("rawConditionalTable");
    } else {
      _fillProbaWithValuesTable_(rawTable);
    }
  }

References _fillProbaWithValuesTable_(), _illegalStateError_(), gum::IBayesNetFactory::RAW_CPT, and state().

Here is the call graph for this function:

rawConditionalTable() [2/2]

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::rawConditionalTable ( const std::vector< std::string > & variables, const std::vector< float > & rawTable )

finalvirtual

Fills the variable's table with the values in rawTable.

Parse the parents in the same order in variables

Given a sequence [var, p_1, p_2, ...,p_n-1, p_n] of parents, modalities are parsed in the given order (if all p_i are binary):

* [0, 0, ..., 0, 0],
* [0, 0, ..., 0, 1],
* [0, 0, ..., 1, 0],
* [0, 0, ..., 1, 1],
* ...,
* [1, 1, ..., 1, 0],
* [1, 1, ..., 1, 1].
* 

Parameters

variables	the vector giving the order of parents
rawTable	The raw table.

Implements gum::IBayesNetFactory.

Definition at line 492 of file BayesNetFactory_tpl.h.

                                                {
    if (state() != factory_state::RAW_CPT) {
      _illegalStateError_("rawConditionalTable");
    } else {
      _fillProbaWithValuesTable_(variables, rawTable);
    }
  }

References _fillProbaWithValuesTable_(), _illegalStateError_(), gum::IBayesNetFactory::RAW_CPT, and state().

Here is the call graph for this function:

resetVerbose()

void gum::IBayesNetFactory::resetVerbose ( )

inlineinherited

Definition at line 99 of file IBayesNetFactory.h.

{ _verbose_ = false; };

References _verbose_.

Referenced by gum::BayesNetFactory< GUM_SCALAR >::BayesNetFactory().

Here is the caller graph for this function:

setParentModality()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::setParentModality ( const std::string & parent, const std::string & modality )

finalvirtual

Tells the factory on which modality we want to instantiate one of variable's parent.

Implements gum::IBayesNetFactory.

Definition at line 653 of file BayesNetFactory_tpl.h.

                                                                                          {
    if (state() != factory_state::FACT_ENTRY) {
      _illegalStateError_("string");
    } else {
      _checkVariableName_(parent);
      Idx id = _checkVariableModality_(parent, modality);
      (*_parents_) << _bn_->variable(_varNameMap_[parent]);
      _parents_->chgVal(_bn_->variable(_varNameMap_[parent]), id);
    }
  }

References _bn_, _checkVariableModality_(), _checkVariableName_(), _illegalStateError_(), _parents_, _varNameMap_, gum::IBayesNetFactory::FACT_ENTRY, and state().

Here is the call graph for this function:

setVariable()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::setVariable ( const DiscreteVariable & var )

finalvirtual

Define a variable.

You can only call this method is the factory is in the NONE or NETWORK state.

The variable is added by copy.

Parameters

var	The pointer over a DiscreteVariable used to define a new variable in the built BayesNet.

Exceptions

DuplicateElement	Raised if a variable with the same name already exists.
OperationNotAllowed	Raised if redefineParents == false and if table is not a valid CPT for var in the current state of the BayesNet.

Implements gum::IBayesNetFactory.

Definition at line 780 of file BayesNetFactory_tpl.h.

                                                                                    {
    if (state() != factory_state::NONE) {
      _illegalStateError_("setVariable");
    } else {
      try {
        _checkVariableName_(var.name());
        GUM_ERROR(DuplicateElement, "Name already used: " << var.name())
      } catch (NotFound const&) {
        // The var name is unused
        _varNameMap_.insert(var.name(), _bn_->add(var));
      }
    }
  }

References _bn_, _checkVariableName_(), _illegalStateError_(), _varNameMap_, GUM_ERROR, gum::Variable::name(), gum::IBayesNetFactory::NONE, and state().

Here is the call graph for this function:

setVariableCPT()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::setVariableCPT ( const std::string & varName, MultiDimAdressable * table, bool redefineParents )

finalvirtual

Define a variable's CPT.

You can only call this method if the factory is in the NONE or NETWORK state.

Be careful that table is given to the built BayesNet, so it will be deleted with it, and you should not directly access it after you call this method.

When the redefineParents flag is set to true the constructed BayesNet's DAG is changed to fit with table's definition.

Parameters

varName	The name of the concerned variable.
table	A pointer over the CPT used for var.
redefineParents	If true redefine var's parents to match table's variables set.

Exceptions

NotFound	Raised if no variable matches var.
OperationNotAllowed	Raised if redefineParents == false and if table is not a valid CPT for var in the current state of the BayesNet.

Implements gum::IBayesNetFactory.

Definition at line 813 of file BayesNetFactory_tpl.h.

                                                                                                 {
    auto pot = dynamic_cast< Tensor< GUM_SCALAR >* >(table);
 
    if (state() != factory_state::NONE) {
      _illegalStateError_("setVariableCPT");
    } else {
      _checkVariableName_(varName);
      const DiscreteVariable& var   = _bn_->variable(_varNameMap_[varName]);
      NodeId                  varId = _varNameMap_[varName];
      // If we have to change the structure of the BayesNet, then we call a sub
      // method.
 
      if (redefineParents) {
        _setCPTAndParents_(var, pot);
      } else if (pot->contains(var)) {
        for (auto node: _bn_->parents(varId)) {
          if (!pot->contains(_bn_->variable(node))) {
            GUM_ERROR(OperationNotAllowed, "The CPT is not valid in the current BayesNet.")
          }
        }
 
        // CPT are created when a variable is added.
        _bn_->_unsafeChangeTensor_(varId, pot);
      }
    }
  }

References _bn_, _checkVariableName_(), _illegalStateError_(), _setCPTAndParents_(), _varNameMap_, GUM_ERROR, gum::IBayesNetFactory::NONE, and state().

Here is the call graph for this function:

setVariableCPTImplementation()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::setVariableCPTImplementation ( MultiDimAdressable * adressable )

finalvirtual

Defines the implementation to use for var's Tensor.

Warning

The implementation must be empty.

The pointer is always delegated to var's Tensor! No copy of it is made.

Todo

When copy of a MultiDimImplementation is available use a copy behaviour for this method.

Exceptions

NotFound	Raised if no variable matches var.
OperationNotAllowed	Raised if impl is not empty.
OperationNotAllowed	If an implementation is already defined for the current variable.

Implements gum::IBayesNetFactory.

Definition at line 304 of file BayesNetFactory_tpl.h.

                                                                                                {
    auto impl = dynamic_cast< MultiDimImplementation< GUM_SCALAR >* >(adressable);
 
    if (state() != factory_state::VARIABLE) {
      _illegalStateError_("setVariableCPTImplementation");
    } else {
      if (impl == nullptr) {
        GUM_ERROR(OperationNotAllowed,
                  "An implementation for this variable is already "
                  "defined.")
      } else if (impl->nbrDim() > 0) {
        GUM_ERROR(OperationNotAllowed, "This implementation is not empty.")
      }
 
      _impl_ = impl;
    }
  }

References _illegalStateError_(), _impl_, GUM_ERROR, state(), and gum::IBayesNetFactory::VARIABLE.

Referenced by gum::prm::PRMSystem< double >::begin().

Here is the call graph for this function:

Here is the caller graph for this function:

setVariableValues()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::setVariableValues ( const std::vector< float > & values )

finalvirtual

same than below with gum::OperationNotAllowed exception if value's size not OK.

Implements gum::IBayesNetFactory.

Definition at line 740 of file BayesNetFactory_tpl.h.

                                                                                               {
    if (state() != factory_state::FACT_ENTRY) {
      _illegalStateError_("setVariableValues");
    } else {
      //     Checking consistency between values and var.
      if (const DiscreteVariable& var = _bn_->variable(_varNameMap_[_stringBag_[0]]);
          values.size() != var.domainSize()) {
        GUM_ERROR(OperationNotAllowed,
                  var.name() << " : invalid number of modalities: found " << values.size()
                             << " while needed " << var.domainSize())
      }
 
      setVariableValuesUnchecked(values);
    }
  }

References _bn_, _illegalStateError_(), _stringBag_, _varNameMap_, gum::IBayesNetFactory::FACT_ENTRY, GUM_ERROR, setVariableValuesUnchecked(), and state().

Here is the call graph for this function:

setVariableValuesUnchecked()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::setVariableValuesUnchecked ( const std::vector< float > & values )

finalvirtual

Gives the values of the variable with respect to precedent parents modality.

If some parents have no modality set, then we apply values for all instantiations of that parent.

This means you can declare a default value for the table by doing

BayesNetFactory factory;
// Do stuff
factory.startVariableDeclaration();
factory.variableName("foo");
factory.endVariableDeclaration();
factory.startParentsDeclaration("foo");
// add parents
factory.endParentsDeclaration();
factory.startFactorizedProbabilityDeclaration("foo");
std::vector<double> seq;
seq.insert(0.4); // if foo true
seq.insert(O.6); // if foo false
factory.setVariableValues(seq); // fills the table with a default value
// finish your stuff
factory.endFactorizedProbabilityDeclaration();

as for rawProba, if value's size is different than the number of modalities of the current variable, we don't use the supplementary values and we fill by 0 the missing values.

Implements gum::IBayesNetFactory.

Definition at line 692 of file BayesNetFactory_tpl.h.

                                        {
    if (state() != factory_state::FACT_ENTRY) {
      _illegalStateError_("setVariableValues");
    } else {
      const DiscreteVariable& var   = _bn_->variable(_varNameMap_[_stringBag_[0]]);
      NodeId                  varId = _varNameMap_[_stringBag_[0]];
 
      if (_parents_->domainSize() > 0) {
        Instantiation inst(_bn_->cpt(_varNameMap_[var.name()]));
        inst.setVals(*_parents_);
        // Creating an instantiation containing all the variables not ins
        //  _parents_.
        Instantiation inst_default;
        inst_default << var;
 
        for (auto node: _bn_->parents(varId)) {
          if (!_parents_->contains(_bn_->variable(node))) { inst_default << _bn_->variable(node); }
        }
 
        // Filling the variable's table.
        for (inst.setFirstIn(inst_default); !inst.end(); inst.incIn(inst_default)) {
          (_bn_->cpt(varId))
              .set(inst,
                   inst.val(var) < values.size() ? static_cast< GUM_SCALAR >(values[inst.val(var)])
                                                 : static_cast< GUM_SCALAR >(0));
        }
      } else {
        Instantiation inst(_bn_->cpt(_varNameMap_[var.name()]));
        Instantiation var_inst;
        var_inst << var;
 
        for (var_inst.setFirst(); !var_inst.end(); ++var_inst) {
          inst.setVals(var_inst);
 
          for (inst.setFirstOut(var_inst); !inst.end(); inst.incOut(var_inst)) {
            (_bn_->cpt(varId))
                .set(inst,
                     inst.val(var) < values.size()
                         ? static_cast< GUM_SCALAR >(values[inst.val(var)])
                         : static_cast< GUM_SCALAR >(0));
          }
        }
      }
    }
  }

References _bn_, _illegalStateError_(), _parents_, _stringBag_, _varNameMap_, gum::Instantiation::end(), gum::IBayesNetFactory::FACT_ENTRY, gum::Instantiation::incIn(), gum::Instantiation::incOut(), gum::Variable::name(), gum::Instantiation::setFirst(), gum::Instantiation::setFirstIn(), gum::Instantiation::setFirstOut(), gum::Instantiation::setVals(), state(), and gum::Instantiation::val().

Referenced by setVariableValues().

Here is the call graph for this function:

Here is the caller graph for this function:

setVerbose()

void gum::IBayesNetFactory::setVerbose ( )

inlineinherited

Definition at line 97 of file IBayesNetFactory.h.

{ _verbose_ = true; };

References _verbose_.

startFactorizedEntry()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::startFactorizedEntry ( )

finalvirtual

Tells the factory that we start an entry of a factorized conditional probability table.

Implements gum::IBayesNetFactory.

Definition at line 628 of file BayesNetFactory_tpl.h.

                                                                  {
    if (state() != factory_state::FACT_CPT) {
      _illegalStateError_("startFactorizedEntry");
    } else {
      _parents_ = new Instantiation();
      _states_.push_back(factory_state::FACT_ENTRY);
    }
  }

References _illegalStateError_(), _parents_, _states_, gum::IBayesNetFactory::FACT_CPT, gum::IBayesNetFactory::FACT_ENTRY, and state().

Here is the call graph for this function:

startFactorizedProbabilityDeclaration()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::startFactorizedProbabilityDeclaration ( const std::string & var )

finalvirtual

Tells the factory that we're starting a factorized declaration.

Implements gum::IBayesNetFactory.

Definition at line 615 of file BayesNetFactory_tpl.h.

                                                                                               {
    if (state() != factory_state::NONE) {
      _illegalStateError_("startFactorizedProbabilityDeclaration");
    } else {
      _checkVariableName_(var);
      _stringBag_.insert(_stringBag_.begin(), var);
      _states_.push_back(factory_state::FACT_CPT);
    }
  }

References _checkVariableName_(), _illegalStateError_(), _states_, _stringBag_, gum::IBayesNetFactory::FACT_CPT, gum::IBayesNetFactory::NONE, and state().

Here is the call graph for this function:

startNetworkDeclaration()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::startNetworkDeclaration ( )

finalvirtual

Tells the factory that we're in a network declaration.

Implements gum::IBayesNetFactory.

Definition at line 156 of file BayesNetFactory_tpl.h.

                                                                     {
    if (state() != factory_state::NONE) {
      _illegalStateError_("startNetworkDeclaration");
    } else {
      _states_.push_back(factory_state::NETWORK);
    }
  }

References _illegalStateError_(), _states_, gum::IBayesNetFactory::NETWORK, gum::IBayesNetFactory::NONE, and state().

Referenced by gum::prm::PRMSystem< GUM_SCALAR >::groundedBN().

Here is the call graph for this function:

Here is the caller graph for this function:

startParentsDeclaration()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::startParentsDeclaration ( const std::string & var )

finalvirtual

Tells the factory that we're declaring parents for some variable.

Parameters

var	The concerned variable's name.

Exceptions

NotFound

Raised if var does not exists.

Implements gum::IBayesNetFactory.

Definition at line 419 of file BayesNetFactory_tpl.h.

                                                                                         {
    if (state() != factory_state::NONE) {
      _illegalStateError_("startParentsDeclaration");
    } else {
      _checkVariableName_(var);
      _stringBag_.insert(_stringBag_.begin(), var);
      _states_.push_back(factory_state::PARENTS);
    }
  }

References _checkVariableName_(), _illegalStateError_(), _states_, _stringBag_, gum::IBayesNetFactory::NONE, gum::IBayesNetFactory::PARENTS, and state().

Referenced by gum::prm::PRMSystem< GUM_SCALAR >::_groundRef_().

Here is the call graph for this function:

Here is the caller graph for this function:

startRawProbabilityDeclaration()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::startRawProbabilityDeclaration ( const std::string & var )

finalvirtual

Tells the factory that we're declaring a conditional probability table for some variable.

Parameters

var	The concerned variable's name.

Implements gum::IBayesNetFactory.

Definition at line 470 of file BayesNetFactory_tpl.h.

                                                                                        {
    if (state() != factory_state::NONE) {
      _illegalStateError_("startRawProbabilityDeclaration");
    } else {
      _checkVariableName_(var);
      _stringBag_.push_back(var);
      _states_.push_back(factory_state::RAW_CPT);
    }
  }

References _checkVariableName_(), _illegalStateError_(), _states_, _stringBag_, gum::IBayesNetFactory::NONE, gum::IBayesNetFactory::RAW_CPT, and state().

Here is the call graph for this function:

startVariableDeclaration()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::startVariableDeclaration ( )

finalvirtual

Tells the factory that we're in a variable declaration.

Implements gum::IBayesNetFactory.

Definition at line 184 of file BayesNetFactory_tpl.h.

                                                                      {
    if (state() != factory_state::NONE) {
      _illegalStateError_("startVariableDeclaration");
    } else {
      _states_.push_back(factory_state::VARIABLE);
      _stringBag_.emplace_back("name");
      _stringBag_.emplace_back("desc");
      _stringBag_.emplace_back("L");
    }
  }

References _illegalStateError_(), _states_, _stringBag_, gum::IBayesNetFactory::NONE, state(), and gum::IBayesNetFactory::VARIABLE.

Referenced by gum::prm::PRMSystem< GUM_SCALAR >::_groundAgg_().

Here is the call graph for this function:

Here is the caller graph for this function:

state()

template<typename GUM_SCALAR>

INLINE IBayesNetFactory::factory_state gum::BayesNetFactory< GUM_SCALAR >::state ( ) const

finalvirtual

Returns the current state of the factory.

Implements gum::IBayesNetFactory.

Definition at line 122 of file BayesNetFactory_tpl.h.

                                                                                  {
    // This is ok because there is always at least the state NONE in the stack.
    return _states_.back();
  }

References _states_.

Referenced by BayesNetFactory(), _illegalStateError_(), addMax(), addMin(), addModality(), addParent(), addTick(), endFactorizedEntry(), endFactorizedProbabilityDeclaration(), endNetworkDeclaration(), endParentsDeclaration(), endRawProbabilityDeclaration(), endVariableDeclaration(), rawConditionalTable(), rawConditionalTable(), setParentModality(), setVariable(), setVariableCPT(), setVariableCPTImplementation(), setVariableValues(), setVariableValuesUnchecked(), startFactorizedEntry(), startFactorizedProbabilityDeclaration(), startNetworkDeclaration(), startParentsDeclaration(), startRawProbabilityDeclaration(), startVariableDeclaration(), variableDescription(), variableName(), and variableType().

variable()

template<typename GUM_SCALAR>

INLINE const DiscreteVariable & gum::BayesNetFactory< GUM_SCALAR >::variable

(

const std::string &

name

)

const

Returns a constant reference on a variable given it's name.

Exceptions

NotFound

Raised if no variable matches the name.

Definition at line 140 of file BayesNetFactory_tpl.h.

                                                                         {
    try {
      return _bn_->variable(variableId(name));
    } catch (NotFound const&) { GUM_ERROR(NotFound, name) }
  }

References _bn_, GUM_ERROR, and variableId().

Referenced by gum::prm::PRMSystem< double >::_groundAgg_(), and gum::prm::PRMSystem< double >::_groundTensor_().

Here is the call graph for this function:

Here is the caller graph for this function:

variableDescription()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::variableDescription ( const std::string & desc )

finalvirtual

Tells the factory the current variable's description.

Implements gum::IBayesNetFactory.

Definition at line 210 of file BayesNetFactory_tpl.h.

                                                                                      {
    if (state() != factory_state::VARIABLE) {
      _illegalStateError_("variableDescription");
    } else {
      _bar_flag_     = true;
      _stringBag_[1] = desc;
    }
  }

References _bar_flag_, _illegalStateError_(), _stringBag_, state(), and gum::IBayesNetFactory::VARIABLE.

Here is the call graph for this function:

variableId()

template<typename GUM_SCALAR>

INLINE NodeId gum::BayesNetFactory< GUM_SCALAR >::variableId ( const std::string & name ) const

finalvirtual

Returns the NodeId of a variable given it's name.

Exceptions

NotFound

Raised if no variable matches the name.

Implements gum::IBayesNetFactory.

Definition at line 130 of file BayesNetFactory_tpl.h.

                                                                                     {
    try {
      return _varNameMap_[name];
    } catch (NotFound const&) { GUM_ERROR(NotFound, name) }
  }

References _varNameMap_, and GUM_ERROR.

Referenced by variable().

Here is the caller graph for this function:

variableName()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::variableName ( const std::string & name )

finalvirtual

Tells the factory the current variable's name.

Exceptions

DuplicateElement

Raised if a variable with the same name already exist.

Implements gum::IBayesNetFactory.

Definition at line 197 of file BayesNetFactory_tpl.h.

                                                                               {
    if (state() != factory_state::VARIABLE) {
      _illegalStateError_("variableName");
    } else {
      if (_varNameMap_.exists(name)) { GUM_ERROR(DuplicateElement, "Name already used: " << name) }
 
      _foo_flag_     = true;
      _stringBag_[0] = name;
    }
  }

References _foo_flag_, _illegalStateError_(), _stringBag_, _varNameMap_, GUM_ERROR, state(), and gum::IBayesNetFactory::VARIABLE.

Referenced by gum::prm::PRMSystem< GUM_SCALAR >::_groundAgg_().

Here is the call graph for this function:

Here is the caller graph for this function:

variableType()

template<typename GUM_SCALAR>

INLINE void gum::BayesNetFactory< GUM_SCALAR >::variableType ( const VarType & type )

virtual

Tells the factory the current variable's type.

Implements gum::IBayesNetFactory.

Definition at line 225 of file BayesNetFactory_tpl.h.

                                                                                {
    if (state() != factory_state::VARIABLE) {
      _illegalStateError_("variableType");
    } else {
      switch (type) {
        case VarType::DISCRETIZED : _stringBag_[2] = "D"; break;
        case VarType::RANGE : _stringBag_[2] = "R"; break;
        case VarType::INTEGER : _stringBag_[2] = "I"; break;
        case VarType::LABELIZED : _stringBag_[2] = "L"; break;
        case VarType::CONTINUOUS :
          GUM_ERROR(OperationNotAllowed,
                    "Continuous variable (" + _stringBag_[0]
                        + ") are not supported in Bayesian networks.")
        default : GUM_ERROR(OperationNotAllowed, "Unknown type for (" + _stringBag_[0] + ")")
      }
    }
  }

References _illegalStateError_(), _stringBag_, gum::CONTINUOUS, gum::DISCRETIZED, GUM_ERROR, gum::INTEGER, gum::LABELIZED, gum::RANGE, state(), and gum::IBayesNetFactory::VARIABLE.

Here is the call graph for this function:

varInBN()

template<typename GUM_SCALAR>

INLINE const DiscreteVariable & gum::BayesNetFactory< GUM_SCALAR >::varInBN ( NodeId id )

finalvirtual

short-cut accessor for a DiscreveVariable in the BN

Implements gum::IBayesNetFactory.

Definition at line 116 of file BayesNetFactory_tpl.h.

                                                                                 {
    return _bn_->variable(id);
  }

References _bn_.

Member Data Documentation

_bar_flag_

template<typename GUM_SCALAR>

bool gum::BayesNetFactory< GUM_SCALAR >::_bar_flag_

private

Depending on the context this flag is used for some VERY important reasons.

Definition at line 424 of file BayesNetFactory.h.

Referenced by _resetParts_(), endVariableDeclaration(), and variableDescription().

_bn_

template<typename GUM_SCALAR>

BayesNet< GUM_SCALAR >* gum::BayesNetFactory< GUM_SCALAR >::_bn_

private

The constructed BayesNet.

Definition at line 442 of file BayesNetFactory.h.

Referenced by BayesNetFactory(), BayesNetFactory(), _checkVariableModality_(), _fillProbaWithValuesTable_(), _fillProbaWithValuesTable_(), _setCPTAndParents_(), addNetworkProperty(), bayesNet(), cptDomainSize(), endParentsDeclaration(), endVariableDeclaration(), setParentModality(), setVariable(), setVariableCPT(), setVariableValues(), setVariableValuesUnchecked(), variable(), and varInBN().

_foo_flag_

template<typename GUM_SCALAR>

bool gum::BayesNetFactory< GUM_SCALAR >::_foo_flag_

private

Depending on the context this flag is used for some VERY important reasons.

Definition at line 420 of file BayesNetFactory.h.

Referenced by _resetParts_(), endVariableDeclaration(), and variableName().

_impl_

template<typename GUM_SCALAR>

MultiDimImplementation< GUM_SCALAR >* gum::BayesNetFactory< GUM_SCALAR >::_impl_

private

Implementation of variable between two startVariableDeclaration/endVariableDeclaration calls.

Definition at line 434 of file BayesNetFactory.h.

Referenced by BayesNetFactory(), BayesNetFactory(), ~BayesNetFactory(), endVariableDeclaration(), and setVariableCPTImplementation().

_parents_

template<typename GUM_SCALAR>

Instantiation* gum::BayesNetFactory< GUM_SCALAR >::_parents_

private

Used when a factorized CPT is built.

Definition at line 430 of file BayesNetFactory.h.

Referenced by BayesNetFactory(), BayesNetFactory(), ~BayesNetFactory(), endFactorizedEntry(), setParentModality(), setVariableValuesUnchecked(), and startFactorizedEntry().

_states_

template<typename GUM_SCALAR>

std::vector< factory_state > gum::BayesNetFactory< GUM_SCALAR >::_states_

private

State stack.

Definition at line 439 of file BayesNetFactory.h.

Referenced by BayesNetFactory(), BayesNetFactory(), endFactorizedEntry(), endFactorizedProbabilityDeclaration(), endNetworkDeclaration(), endParentsDeclaration(), endRawProbabilityDeclaration(), endVariableDeclaration(), startFactorizedEntry(), startFactorizedProbabilityDeclaration(), startNetworkDeclaration(), startParentsDeclaration(), startRawProbabilityDeclaration(), startVariableDeclaration(), and state().

_stringBag_

template<typename GUM_SCALAR>

std::vector< std::string > gum::BayesNetFactory< GUM_SCALAR >::_stringBag_

private

Just to keep track of strings between two start/end calls.

Definition at line 427 of file BayesNetFactory.h.

Referenced by _checkModalityInBag_(), _fillProbaWithValuesTable_(), _fillProbaWithValuesTable_(), _resetParts_(), addMax(), addMin(), addModality(), addParent(), addTick(), endParentsDeclaration(), endVariableDeclaration(), setVariableValues(), setVariableValuesUnchecked(), startFactorizedProbabilityDeclaration(), startParentsDeclaration(), startRawProbabilityDeclaration(), startVariableDeclaration(), variableDescription(), variableName(), and variableType().

_varNameMap_

template<typename GUM_SCALAR>

HashTable< std::string, NodeId > gum::BayesNetFactory< GUM_SCALAR >::_varNameMap_

private

Mapping between a declared variable's name and it's node id.

Definition at line 445 of file BayesNetFactory.h.

Referenced by BayesNetFactory(), _checkVariableModality_(), _checkVariableName_(), _fillProbaWithValuesTable_(), _fillProbaWithValuesTable_(), _setCPTAndParents_(), endParentsDeclaration(), endVariableDeclaration(), setParentModality(), setVariable(), setVariableCPT(), setVariableValues(), setVariableValuesUnchecked(), variableId(), and variableName().

_verbose_

bool gum::IBayesNetFactory::_verbose_

privateinherited

Definition at line 149 of file IBayesNetFactory.h.

Referenced by IBayesNetFactory(), isVerbose(), resetVerbose(), and setVerbose().

---

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

• agrum/BN/BayesNet.h
• agrum/BN/BayesNetFactory.h
• agrum/BN/BayesNetFactory_tpl.h