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

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

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 44 of file BayesNet.h.

Member Enumeration Documentation

factory_state

enum 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 59 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 45 of file BayesNetFactory_tpl.h.

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

                                                                              :
      parents__(0),
      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();
  }

Here is the call 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 65 of file BayesNetFactory_tpl.h.

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

                                                  :
      parents__(0),
      impl__(0), bn__(0) {
    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__));
    }
  }

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 81 of file BayesNetFactory_tpl.h.

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

                                                         {
    GUM_DESTRUCTOR(BayesNetFactory);

    if (parents__ != 0) delete parents__;

    if (impl__ != 0) {
      //@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(1000);
    }
  }

Here is the call graph for this function:

Member Function Documentation

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 281 of file BayesNetFactory_tpl.h.

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

                                                                   {
    if (state() != factory_state::VARIABLE) {
      illegalStateError__("addMin");
    } else {
      stringBag__.push_back(std::to_string(max));
    }
  }

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 269 of file BayesNetFactory_tpl.h.

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

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

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 256 of file BayesNetFactory_tpl.h.

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

                                                                              {
    if (state() != factory_state::VARIABLE) {
      illegalStateError__("addModality");
    } else {
      checkModalityInBag__(name);
      stringBag__.push_back(name);
    }
  }

Here is the call 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 160 of file BayesNetFactory_tpl.h.

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

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

Here is the call 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 439 of file BayesNetFactory_tpl.h.

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

                                                                           {
    if (state() != factory_state::PARENTS) {
      illegalStateError__("addParent");
    } else {
      checkVariableName__(var);
      stringBag__.push_back(var);
    }
  }

Here is the call 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 293 of file BayesNetFactory_tpl.h.

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

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

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 100 of file BayesNetFactory_tpl.h.

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

                                                                         {
    return bn__;
  }

Here is the call graph for this function:

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 964 of file BayesNetFactory_tpl.h.

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

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

Here is the call 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 948 of file BayesNetFactory_tpl.h.

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

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

Here is the call graph for this function:

checkVariableName__()

template<typename GUM_SCALAR >

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

private

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

Definition at line 941 of file BayesNetFactory_tpl.h.

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

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

Here is the call graph for this function:

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 142 of file BayesNetFactory_tpl.h.

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

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

Here is the call graph for this function:

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 663 of file BayesNetFactory_tpl.h.

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

                                                                {
    if (state() != factory_state::FACT_ENTRY) {
      illegalStateError__("endFactorizedEntry");
    } else {
      delete parents__;
      parents__ = 0;
      states__.pop_back();
    }
  }

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 791 of file BayesNetFactory_tpl.h.

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

                                                                        {
    if (state() != factory_state::FACT_CPT) {
      illegalStateError__("endFactorizedProbabilityDeclaration");
    } else {
      resetParts__();
      states__.pop_back();
    }
  }

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 168 of file BayesNetFactory_tpl.h.

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

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

    VERBOSITY("network OK");
  }

Here is the call 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 453 of file BayesNetFactory_tpl.h.

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

                                                                   {
    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);
        VERBOSITY("  adding parent " << stringBag__[i] << " for "
                                     << stringBag__[0]);
      }

      resetParts__();

      states__.pop_back();
    }

    VERBOSITY("end of parents for " << stringBag__[0]);
  }

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 623 of file BayesNetFactory_tpl.h.

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

                                                                          {
    if (state() != factory_state::RAW_CPT) {
      illegalStateError__("endRawProbabilityDeclaration");
    } else {
      resetParts__();
      states__.pop_back();
    }

    VERBOSITY("  cpt ending for " << stringBag__[0]);
  }

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 334 of file BayesNetFactory_tpl.h.

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

                                                                      {
    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") {
        LabelizedVariable* 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] == "R") {
        RangeVariable* 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") {
        DiscretizedVariable< GUM_SCALAR >* 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 (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();

      VERBOSITY("  variable " << var->name() << " OK");
      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;
  }

Here is the call graph for this function:

fillProbaWithValuesTable__() [1/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 potential from a raw CPT.

Definition at line 515 of file BayesNetFactory_tpl.h.

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

                                               {
    const Potential< GUM_SCALAR >& table = bn__->cpt(varNameMap__[stringBag__[0]]);
    Instantiation                  cptInst(table);

    List< const DiscreteVariable* > varList;

    for (size_t i = 0; i < variables.size(); ++i) {
      varList.pushBack(&(bn__->variable(varNameMap__[variables[i]])));
    }

    // varList.pushFront(&(bn__->variable(varNameMap__[stringBag__[0]])));

    Idx nbrVar = varList.size();

    std::vector< Idx > modCounter;

    // initializing the array
    for (NodeId i = 0; i < nbrVar; i++) {
      modCounter.push_back(Idx(0));
    }

    Idx j = 0;

    do {
      for (NodeId i = 0; i < nbrVar; i++) {
        cptInst.chgVal(*(varList[i]), modCounter[i]);
      }

      if (j < rawTable.size()) {
        table.set(cptInst, (GUM_SCALAR)rawTable[j]);
      } else {
        table.set(cptInst, (GUM_SCALAR)0);
      }

      j++;
    } while (increment__(modCounter, varList));
  }

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< float > &  rawTable )

private

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

Definition at line 566 of file BayesNetFactory_tpl.h.

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

                                         {
    const Potential< 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()) ? (GUM_SCALAR)rawTable[j++]
                                        : (GUM_SCALAR)0);

      cptInst.unsetEnd();
    }
  }

Here is the call 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 888 of file BayesNetFactory_tpl.h.

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

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

Here is the call 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  )

private

Increment a modality counter for the fillProbaWithValuesTable__ method.

Definition at line 588 of file BayesNetFactory_tpl.h.

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

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

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

Here is the call graph for this function:

isVerbose()

bool gum::IBayesNetFactory::isVerbose ( )

inlineinherited

Definition at line 82 of file IBayesNetFactory.h.

References gum::IBayesNetFactory::verbose__.

{ return verbose__; };

operator=()

template<typename GUM_SCALAR >

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

private

Copy operator is illegal, use only copy constructor.

Definition at line 878 of file BayesNetFactory_tpl.h.

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

                                                  {
    GUM_ERROR(OperationNotAllowed, "Illegal!");
    // For noisy compilers
    return *this;
  }

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< 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 504 of file BayesNetFactory_tpl.h.

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

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

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< 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 556 of file BayesNetFactory_tpl.h.

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

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

Here is the call 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 994 of file BayesNetFactory_tpl.h.

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

                                                          {
    foo_flag__ = false;
    bar_flag__ = false;
    stringBag__.clear();
  }

Here is the call graph for this function:

resetVerbose()

void gum::IBayesNetFactory::resetVerbose ( )

inlineinherited

Definition at line 80 of file IBayesNetFactory.h.

References gum::IBayesNetFactory::verbose__.

{ verbose__ = false; };

setCPTAndParents__()

template<typename GUM_SCALAR >

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

private

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

Definition at line 975 of file BayesNetFactory_tpl.h.

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

                                     {
    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__->unsafeChangePotential_(varId, table);
  }

Here is the call 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 676 of file BayesNetFactory_tpl.h.

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

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

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 813 of file BayesNetFactory_tpl.h.

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

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

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 846 of file BayesNetFactory_tpl.h.

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

                                                                         {
    auto pot = dynamic_cast< Potential< 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__->unsafeChangePotential_(varId, pot);
      }
    }
  }

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 Potential.

Warning

The implementation must be empty.

The pointer is always delegated to var's Potential! 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 312 of file BayesNetFactory_tpl.h.

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

                                     {
    MultiDimImplementation< GUM_SCALAR >* impl
       = dynamic_cast< MultiDimImplementation< GUM_SCALAR >* >(adressable);

    if (state() != factory_state::VARIABLE) {
      illegalStateError__("setVariableCPTImplementation");
    } else {
      if (impl == 0) {
        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;
    }
  }

Here is the call 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 768 of file BayesNetFactory_tpl.h.

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

                                       {
    if (state() != factory_state::FACT_ENTRY) {
      illegalStateError__("setVariableValues");
    } else {
      const DiscreteVariable& var = bn__->variable(varNameMap__[stringBag__[0]]);
      //     Checking consistency between values and var.

      if (values.size() != var.domainSize()) {
        GUM_ERROR(OperationNotAllowed,
                  var.name()
                     << " : invalid number of modalities: found " << values.size()
                     << " while needed " << var.domainSize());
      }

      setVariableValuesUnchecked(values);
    }
  }

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 717 of file BayesNetFactory_tpl.h.

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

                                       {
    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() ? (GUM_SCALAR)values[inst.val(var)]
                                                : (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()
                       ? (GUM_SCALAR)values[inst.val(var)]
                       : (GUM_SCALAR)0);
          }
        }
      }
    }
  }

Here is the call graph for this function:

setVerbose()

void gum::IBayesNetFactory::setVerbose ( )

inlineinherited

Definition at line 78 of file IBayesNetFactory.h.

References gum::IBayesNetFactory::verbose__.

{ verbose__ = true; };

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 651 of file BayesNetFactory_tpl.h.

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

                                                                  {
    if (state() != factory_state::FACT_CPT) {
      illegalStateError__("startFactorizedEntry");
    } else {
      parents__ = new Instantiation();
      states__.push_back(factory_state::FACT_ENTRY);
    }
  }

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 636 of file BayesNetFactory_tpl.h.

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

                           {
    if (state() != factory_state::NONE) {
      illegalStateError__("startFactorizedProbabilityDeclaration");
    } else {
      checkVariableName__(var);
      std::vector< std::string >::iterator iter = stringBag__.begin();
      stringBag__.insert(iter, var);
      states__.push_back(factory_state::FACT_CPT);
    }
  }

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 148 of file BayesNetFactory_tpl.h.

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

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

    VERBOSITY("starting network");
  }

Here is the call 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 421 of file BayesNetFactory_tpl.h.

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

                           {
    if (state() != factory_state::NONE) {
      illegalStateError__("startParentsDeclaration");
    } else {
      checkVariableName__(var);
      std::vector< std::string >::iterator iter = stringBag__.begin();
      stringBag__.insert(iter, var);
      states__.push_back(factory_state::PARENTS);
    }

    VERBOSITY("starting parents for " << var);
  }

Here is the call 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 479 of file BayesNetFactory_tpl.h.

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

                           {
    if (state() != factory_state::NONE) {
      illegalStateError__("startRawProbabilityDeclaration");
    } else {
      checkVariableName__(var);
      stringBag__.push_back(var);
      states__.push_back(factory_state::RAW_CPT);
    }

    VERBOSITY("  cpt starting for " << var);
  }

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 181 of file BayesNetFactory_tpl.h.

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

                                                                      {
    if (state() != factory_state::NONE) {
      illegalStateError__("startVariableDeclaration");
    } else {
      states__.push_back(factory_state::VARIABLE);
      stringBag__.push_back("name");
      stringBag__.push_back("desc");
      stringBag__.push_back("L");
    }

    VERBOSITY("  starting variable");
  }

Here is the call 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 113 of file BayesNetFactory_tpl.h.

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

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

Here is the call graph for this function:

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 132 of file BayesNetFactory_tpl.h.

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

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

Here is the call 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 214 of file BayesNetFactory_tpl.h.

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

                                                                             {
    if (state() != factory_state::VARIABLE) {
      illegalStateError__("variableDescription");
    } else {
      bar_flag__     = true;
      stringBag__[1] = desc;
    }
  }

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 122 of file BayesNetFactory_tpl.h.

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

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

Here is the call 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.

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

                                                                      {
    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;
      VERBOSITY("  -- variable " << name);
    }
  }

Here is the call 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 230 of file BayesNetFactory_tpl.h.

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

                                                                       {
    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::Continuous:
          GUM_ERROR(OperationNotAllowed,
                    "Continuous variable (" + stringBag__[0]
                       + ") are not supported in Bayesian networks.");
        case VarType::Labelized:
          stringBag__[2] = "L";
          break;
      }
    }
  }

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 106 of file BayesNetFactory_tpl.h.

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

                                                               {
    return bn__->variable(id);
  }

Here is the call graph for this function:

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 406 of file BayesNetFactory.h.

bn__

template<typename GUM_SCALAR >

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

private

The constructed BayesNet.

Definition at line 424 of file BayesNetFactory.h.

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 402 of file BayesNetFactory.h.

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 416 of file BayesNetFactory.h.

parents__

template<typename GUM_SCALAR >

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

private

Used when a factorized CPT is built.

Definition at line 412 of file BayesNetFactory.h.

states__

template<typename GUM_SCALAR >

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

private

State stack.

Definition at line 421 of file BayesNetFactory.h.

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 409 of file BayesNetFactory.h.

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 427 of file BayesNetFactory.h.

---

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

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