ContextTree.hpp

/*
 *       ContextTree.hpp
 *
 *       Copyright 2011 Andre Yoshiaki Kashiwabara <akashiwabara@usp.br>
 *                      Ígor Bonádio <ibonadio@ime.usp.br>
 *                      Vitor Onuchic <vitoronuchic@gmail.com>
 *                      Alan Mitchell Durham <aland@usp.br>
 *
 *       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 3 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., 51 Franklin Street, Fifth Floor, Boston,
 *       MA 02110-1301, USA.
 */

#ifndef CONTEXT_TREE_HPP
#define CONTEXT_TREE_HPP

#include "crossplatform.hpp"

#include "DiscreteIIDModel.hpp"
#include "ProbabilisticModelParameter.hpp"
#include <boost/shared_ptr.hpp>
#include <set>
namespace tops {
  class DLLEXPORT ContextTreeNode;
  typedef boost::shared_ptr <ContextTreeNode> ContextTreeNodePtr;
  typedef std::vector< boost::shared_ptr<tops::ContextTreeNode> > ContextTreeNodeVector;
    class DLLEXPORT ContextTree;
   typedef boost::shared_ptr<ContextTree> ContextTreePtr;
  class DLLEXPORT ContextTreeNode {
  private:
    DiscreteIIDModelPtr _distribution;
    ContextTreeNodeVector _child;
    int _alphabet_size;
    int _symbol;
    bool _leaf;
    std::vector<double> _counter;
    int _id;
    int _parent_id;
  public:
    ~ContextTreeNode(){ }

    ContextTreeNode(int alphabet_size);

    ContextTreeNode() ;

    void addCount (int s);

    void addCount (int s, double w);


    void setCount (int s, double v);

    std::vector<double> & getCounter ();

    int alphabet_size();


    void setParent(int parent) ;

    int getParent() ;

    int id ();
    void setId(int id);

    void setChild(ContextTreeNodePtr child, int symbol);

    int symbol();

    void setSymbol(int symbol);


    void setDistribution(DiscreteIIDModelPtr distribution);

    ContextTreeNodePtr getChild(int symbol);

    DiscreteIIDModelPtr getDistribution();

      void deleteChildren() ;

    ContextTreeNodeVector getChildren() ;

    bool isLeaf();


    std::string str() const ;


  };


  class DLLEXPORT ContextTree {
  public:
    ~ContextTree() {
    }
    ContextTree(){}
    ContextTree(AlphabetPtr alphabet);

    ContextTreeNodeVector & all_context() {
      return _all_context;
    }

    ContextTreeNodePtr getRoot() const ;


    ContextTreeNodePtr createContext() ;


    ContextTreeNodePtr getContext (int id) ;

    ContextTreeNodePtr getContext(const Sequence & s, int i);

    std::set <int> getLevelOneNodes();

    void removeContextNotUsed();

    void normalize();

      void normalize(ProbabilisticModelPtr old, double pseudocount, int i);

      void normalize(ProbabilisticModelPtr old, double pseudocount){
          normalize(old,pseudocount,0);
      }

    std::string str() const;

    void initializeCounter(const SequenceEntryList & sequences, int order, const std::map<std::string, double> & weights);

    void initializeCounter(const SequenceEntryList & sequences, int order, double pseudocounts, const std::map<std::string, double> & weights);

    void pruneTree(double delta) ;


    void pruneTreeSmallSampleSize(int small_) ;

    void initializeContextTreeRissanen(const SequenceEntryList & sequences);

    DoubleMapParameterValuePtr getParameterValue () const;

    int getNumberOfNodes() const
    {
      return _all_context.size();
    }

  private:
    void printTree(ContextTreeNodePtr node, std::stringstream & out) const;
    void buildParameters(ContextTreeNodePtr node, std::map<std::string, double> & parameters) const;
    ContextTreeNodeVector _all_context;
    AlphabetPtr _alphabet;

  };
  typedef boost::shared_ptr<ContextTree> ContextTreePtr;


}

#endif