BayesNetFactory.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Christophe GONZALES and Pierre-Henri WUILLEMIN  *
 *   {prenom.nom}_at_lip6.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef GUM_BAYESNET_FACTORY_H
#define GUM_BAYESNET_FACTORY_H

#include <string>
#include <vector>

#include <agrum/BN/BayesNet.h>
#include <agrum/BN/IBayesNetFactory.h>

namespace gum {

  template < typename GUM_SCALAR >
  class BayesNetFactory : public IBayesNetFactory {
    public:
    // ==========================================================================
    // ==========================================================================

    explicit BayesNetFactory(BayesNet< GUM_SCALAR >* bn);

    BayesNetFactory(const BayesNetFactory< GUM_SCALAR >& source);

    virtual ~BayesNetFactory();

    // ==========================================================================
    // ==========================================================================

    BayesNet< GUM_SCALAR >* bayesNet();

    const DiscreteVariable& varInBN(NodeId id) final;

    factory_state state() const final;

    NodeId variableId(const std::string& name) const final;

    const DiscreteVariable& variable(const std::string& name) const;

    Size cptDomainSize(NodeId n) const final;

    // ==========================================================================
    // ==========================================================================

    void startNetworkDeclaration() final;

    void addNetworkProperty(const std::string& propName,
                            const std::string& propValue) final;

    void endNetworkDeclaration() final;

    // ==========================================================================
    // ==========================================================================

    void startVariableDeclaration() final;

    void variableName(const std::string& name) final;

    void variableDescription(const std::string& desc) final;

    void addModality(const std::string& name) final;

    void setVariableCPTImplementation(MultiDimAdressable* adressable) final;

    NodeId endVariableDeclaration() final;

    // ==========================================================================
    // ==========================================================================

    void startParentsDeclaration(const std::string& var) final;

    void addParent(const std::string& var) final;

    void endParentsDeclaration() final;

    // ==========================================================================
    // ==========================================================================

    void startRawProbabilityDeclaration(const std::string& var) final;

    void rawConditionalTable(const std::vector< std::string >& variables,
                             const std::vector< float >&       rawTable) final;

    void rawConditionalTable(const std::vector< float >& rawTable) final;

    void endRawProbabilityDeclaration() final;

    // ==========================================================================
    // (NONE -> RAW_CPT)
    // ==========================================================================

    void startFactorizedProbabilityDeclaration(const std::string& var) final;

    void startFactorizedEntry() final;

    void endFactorizedEntry() final;

    void setParentModality(const std::string& parent,
                           const std::string& modality) final;

    void setVariableValuesUnchecked(const std::vector< float >& values) final;

    void setVariableValues(const std::vector< float >& values) final;

    void endFactorizedProbabilityDeclaration() final;

    // ==========================================================================
    // ==========================================================================

    void setVariable(const DiscreteVariable& var) final;

    void setVariableCPT(const std::string&  varName,
                        MultiDimAdressable* table,
                        bool                redefineParents) final;


    private:
    // ==========================================================================
    // ==========================================================================

    bool __foo_flag;

    bool __bar_flag;

    std::vector< std::string > __stringBag;

    Instantiation* __parents;

    MultiDimImplementation< GUM_SCALAR >* __impl;


    std::vector< factory_state > __states;

    BayesNet< GUM_SCALAR >* __bn;

    HashTable< std::string, NodeId > __varNameMap;

    BayesNetFactory< GUM_SCALAR >&
       operator=(const BayesNetFactory< GUM_SCALAR >& source);

    void __illegalStateError(const std::string& s);

    void __checkVariableName(const std::string& name);

    Idx __checkVariableModality(const std::string& name, const std::string& mod);

    void __checkModalityInBag(const std::string& mod);

    void __setCPTAndParents(const DiscreteVariable&  var,
                            Potential< GUM_SCALAR >* table);

    void __resetParts();

    void __fillProbaWithValuesTable(const std::vector< std::string >& variables,
                                    const std::vector< float >&       rawTable);
    void __fillProbaWithValuesTable(const std::vector< float >& rawTable);

    bool __increment(std::vector< gum::Idx >&         modCounter,
                     List< const DiscreteVariable* >& varList);
  };


#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
  extern template class BayesNetFactory< double >;
#endif

} /* namespace gum */

#include <agrum/BN/BayesNetFactory_tpl.h>

#endif   // GUM_BAYESNET_FACTORY_H