Added all interface files for PhylLib.

src/mappings/swig/python/AbstractAgglomerativeDistanceMethod.i

@@ -0,0 +1,30 @@
+%module bpptest
+%{
+#include "AbstractAgglomerativeDistanceMethod.h"
+using namespace bpp;
+%}
+%include "AgglomerativeDistanceMethod.i"
+%include "Node.i"
+%include "TreeTemplate.i"
+%include "std_map.i"
+using namespace std;
+
+%rename(__assign__) AbstractAgglomerativeDistanceMethod::operator=;
+
+class AbstractAgglomerativeDistanceMethod:public virtual AgglomerativeDistanceMethod
+{
+  public:
+    AbstractAgglomerativeDistanceMethod();
+    AbstractAgglomerativeDistanceMethod(bool verbose);
+    AbstractAgglomerativeDistanceMethod(const DistanceMatrix & matrix, bool verbose = true);
+    virtual ~AbstractAgglomerativeDistanceMethod();
+    AbstractAgglomerativeDistanceMethod(const AbstractAgglomerativeDistanceMethod & a);
+    AbstractAgglomerativeDistanceMethod & operator=(const AbstractAgglomerativeDistanceMethod & a);
+
+    virtual void setDistanceMatrix(const DistanceMatrix & matrix);
+    virtual
+    TreeTemplate<Node> * getTree() const;
+    virtual void computeTree(bool rooted) throw (Exception);
+    void setVerbose(bool yn);
+    bool isVerbose() const;
+};

src/mappings/swig/python/AbstractDiscreteRatesAcrossSitesTreeLikelihood.i

@@ -0,0 +1,35 @@
+%module bpptest
+%{
+#include "AbstractDiscreteRatesAcrossSitesTreeLikelihood.h"
+using namespace bpp;
+%}
+%include "AbstractTreeLikelihood.i"
+%include "DiscreteRatesAcrossSitesTreeLikelihood.i"
+%include "SubstitutionModel.i"
+
+class AbstractDiscreteRatesAcrossSitesTreeLikelihood:public AbstractTreeLikelihood,public virtual DiscreteRatesAcrossSitesTreeLikelihood
+{
+  public:
+    AbstractDiscreteRatesAcrossSitesTreeLikelihood(DiscreteDistribution * rDist, bool verbose = true) throw (Exception);
+    virtual ~AbstractDiscreteRatesAcrossSitesTreeLikelihood();
+
+    double getLikelihoodForASiteForAState (unsigned int site, int state) const;
+    double getLogLikelihoodForASiteForAState(unsigned int site, int state) const;
+    ParameterList getDerivableParameters() const;
+    ParameterList getNonDerivableParameters() const;
+
+    const DiscreteDistribution * getRateDistribution() const;
+    DiscreteDistribution * getRateDistribution();
+    unsigned int getNumberOfClasses() const; 
+    ParameterList getRateDistributionParameters() const;
+    VVdouble getLikelihoodForEachSiteForEachRateClass() const;
+    VVdouble getLogLikelihoodForEachSiteForEachRateClass() const;
+    VVVdouble getLikelihoodForEachSiteForEachRateClassForEachState() const;
+    VVVdouble getLogLikelihoodForEachSiteForEachRateClassForEachState() const;
+    VVdouble getPosteriorProbabilitiesOfEachRate() const;
+    Vdouble getRateWithMaxPostProbOfEachSite() const;
+    vector<unsigned int> getRateClassWithMaxPostProbOfEachSite() const;
+    Vdouble getPosteriorRateOfEachSite() const;
+    static void resetLikelihoodArray(VVVdouble & likelihoodArray);
+    static void displayLikelihoodArray(const VVVdouble & likelihoodArray);
+};

src/mappings/swig/python/AbstractHomogeneousTreeLikelihood.i

@@ -0,0 +1,36 @@
+%module bpptest
+%{
+#include "AbstractHomogeneousTreeLikelihood.h"
+using namespace bpp;
+%}
+%include "AbstractDiscreteRatesAcrossSitesTreeLikelihood.i"
+%include "HomogeneousTreeLikelihood.i"
+
+%rename(__assign__) AbstractHomogeneousTreeLikelihood::operator=;
+
+class AbstractHomogeneousTreeLikelihood:public virtual HomogeneousTreeLikelihood,public AbstractDiscreteRatesAcrossSitesTreeLikelihood
+{
+  public:
+    AbstractHomogeneousTreeLikelihood(const Tree & tree, SubstitutionModel * model, DiscreteDistribution * rDist, bool checkRooted = true, bool verbose = true) throw (Exception);
+    AbstractHomogeneousTreeLikelihood(const AbstractHomogeneousTreeLikelihood & lik);
+    AbstractHomogeneousTreeLikelihood & operator=(const AbstractHomogeneousTreeLikelihood & lik);
+    virtual ~AbstractHomogeneousTreeLikelihood();
+
+    void initialize() throw(Exception);
+    ParameterList getBranchLengthsParameters() const;
+    ParameterList getSubstitutionModelParameters() const;
+    ParameterList getRateDistributionParameters() const;
+    const SubstitutionModel * getSubstitutionModelForNode(int nodeId) const throw (NodeNotFoundException);
+    SubstitutionModel * getSubstitutionModelForNode(int nodeId) throw (NodeNotFoundException);
+    vector<double> getRootFrequencies() const;
+    const VVVdouble & getTransitionProbabilitiesForNode(const Node* node) const;
+    const SubstitutionModel * getSubstitutionModel() const;
+    SubstitutionModel * getSubstitutionModel();
+    void setSubstitutionModel(SubstitutionModel * model) throw (Exception);
+
+    virtual void initParameters();
+    virtual void applyParameters() throw (Exception);  
+    virtual void initBranchLengthsParameters();
+    virtual void setMinimumBranchLength(double minimum);
+    virtual double getMinimumBranchLength() const;
+};

src/mappings/swig/python/AbstractNonHomogeneousTreeLikelihood.i

@@ -0,0 +1,37 @@
+%module bpptest
+%{
+#include "AbstractNonHomogeneousTreeLikelihood.h"
+using namespace bpp;
+%}
+%include "NonHomogeneousTreeLikelihood.i"
+%include "AbstractDiscreteRatesAcrossSitesTreeLikelihood.i"
+
+%rename(__assign__) AbstractNonHomogeneousTreeLikelihood::operator=;
+
+class AbstractNonHomogeneousTreeLikelihood:public virtual NonHomogeneousTreeLikelihood,public AbstractDiscreteRatesAcrossSitesTreeLikelihood
+{
+  public:
+    AbstractNonHomogeneousTreeLikelihood(const Tree & tree, SubstitutionModelSet * modelSet, DiscreteDistribution * rDist, bool verbose = true) throw (Exception);
+    AbstractNonHomogeneousTreeLikelihood(const AbstractNonHomogeneousTreeLikelihood & lik);
+    AbstractNonHomogeneousTreeLikelihood & operator=(const AbstractNonHomogeneousTreeLikelihood & lik);
+    virtual ~AbstractNonHomogeneousTreeLikelihood();
+
+    void initialize() throw(Exception);
+    ParameterList getBranchLengthsParameters() const;
+    ParameterList getSubstitutionModelParameters() const;
+    ParameterList getRateDistributionParameters() const;
+    const SubstitutionModel * getSubstitutionModelForNode(int nodeId) const throw (NodeNotFoundException);
+    SubstitutionModel * getSubstitutionModelForNode(int nodeId) throw (NodeNotFoundException);
+    vector<double> getRootFrequencies() const;
+    const VVVdouble & getTransitionProbabilitiesForNode(const Node* node) const;
+    const SubstitutionModelSet * getSubstitutionModelSet() const;
+    SubstitutionModelSet * getSubstitutionModelSet();
+    void setSubstitutionModelSet(SubstitutionModelSet * modelSet) throw (Exception);
+    ParameterList getRootFrequenciesParameters() const;
+
+    virtual void initParameters();
+    virtual void applyParameters() throw (Exception);  
+    virtual void initBranchLengthsParameters();
+    virtual void setMinimumBranchLength(double minimum);
+    virtual double getMinimumBranchLength() const;
+};

src/mappings/swig/python/AbstractSubstitutionModel.i

@@ -0,0 +1,46 @@
+%module bpptest
+%{
+#include "AbstractSubstitutionModel.h"
+using namespace bpp;
+%}
+%include "SubstitutionModel.i"
+%include "AbstractParameterAliasable.i"
+
+class AbstractSubstitutionModel :public virtual SubstitutionModel,public AbstractParameterAliasable
+{
+  public:
+    AbstractSubstitutionModel(const Alphabet * alpha, const string& prefix);
+    virtual ~AbstractSubstitutionModel();
+    virtual AbstractSubstitutionModel * clone() const = 0;
+
+    const Alphabet * getAlphabet() const;
+    const Vdouble & getFrequencies() const;
+    const Matrix<double> & getGenerator() const;
+    const Matrix<double> & getPij_t(double t) const;
+    const Matrix<double> & getdPij_dt(double t) const;
+    const Matrix<double> & getd2Pij_dt2(double t) const;
+    const Vdouble & getEigenValues() const;
+    const Matrix<double> & getRowLeftEigenVectors() const;
+    const Matrix<double> & getColumnRightEigenVectors() const;
+    double freq(int i) const;
+    double Qij(int i, int j) const;
+    double Pij_t (int i, int j, double t) const;
+    double dPij_dt (int i, int j, double t) const;
+    double d2Pij_dt2(int i, int j, double t) const;
+    double getInitValue(int i, int state) const throw (BadIntException);
+    void setFreqFromData(const SequenceContainer & data, unsigned int pseudoCount = 0);
+    int getState(int i) const;
+    void fireParameterChanged(const ParameterList & parameters);
+};
+
+class AbstractReversibleSubstitutionModel:public AbstractSubstitutionModel,public ReversibleSubstitutionModel
+{
+  public:
+    AbstractReversibleSubstitutionModel(const Alphabet * alpha, const string& prefix);
+    virtual ~AbstractReversibleSubstitutionModel();
+    virtual AbstractReversibleSubstitutionModel * clone() const = 0;
+
+    const Matrix<double> & getExchangeabilityMatrix() const;
+    double Sij(int i, int j) const;
+    virtual void updateMatrices();
+};

src/mappings/swig/python/AbstractTreeLikelihood.i

@@ -0,0 +1,44 @@
+%module bpptest
+%{
+#include "AbstractTreeLikelihood.h"
+using namespace bpp;
+%}
+%include "TreeLikelihood.i"
+%include "Tree.i"
+%include "TreeTemplate.i"
+%include "AbstractParametrizable.i"
+%include "SiteContainer.i"
+
+%rename(__assign__) AbstractTreeLikelihood::operator=;
+
+class AbstractTreeLikelihood :public virtual TreeLikelihood,public AbstractParametrizable
+{
+  protected:
+    const SiteContainer * _data;
+    mutable TreeTemplate<Node> * _tree;
+    bool _computeFirstOrderDerivatives;
+    bool _computeSecondOrderDerivatives;
+    bool _initialized;
+
+    AbstractTreeLikelihood();
+    AbstractTreeLikelihood(const AbstractTreeLikelihood & lik);
+    AbstractTreeLikelihood & operator=(const AbstractTreeLikelihood & lik);
+    virtual ~AbstractTreeLikelihood();
+
+    const SiteContainer * getData() const;
+    const Alphabet * getAlphabet() const;  
+    Vdouble getLikelihoodForEachSite() const;
+    Vdouble getLogLikelihoodForEachSite() const;
+    VVdouble getLikelihoodForEachSiteForEachState() const;
+    VVdouble getLogLikelihoodForEachSiteForEachState() const;
+    unsigned int getNumberOfSites() const;
+    unsigned int getNumberOfStates() const;
+    const Tree * getTree() const;
+    void enableDerivatives(bool yn);
+    void enableFirstOrderDerivatives(bool yn);
+    void enableSecondOrderDerivatives(bool yn);
+    bool enableFirstOrderDerivatives() const;
+    bool enableSecondOrderDerivatives() const;
+    bool isInitialized() const;
+    void initialize() throw (Exception);
+};

src/mappings/swig/python/AbstractTreeLikelihoodData.i

@@ -0,0 +1,25 @@
+%module bpptest
+%{
+#include "AbstractTreeLikelihoodData.h"
+using namespace bpp;
+%}
+%include "TreeLikelihoodData.i"
+%include "std_vector.i"
+%include "std_map.i"
+using namespace std;
+
+class AbstractTreeLikelihoodData :public TreeLikelihoodData
+{
+  public:
+    AbstractTreeLikelihoodData();
+    virtual ~AbstractTreeLikelihoodData();
+
+    vector<unsigned int> & getRootArrayPositions();
+    const vector<unsigned int> & getRootArrayPositions() const;
+    unsigned int getRootArrayPosition(const unsigned int site) const;
+    unsigned int getWeight(unsigned int pos) const;
+    const vector<unsigned int> & getWeights() const;
+    const Alphabet * getAlphabet() const;
+    const TreeTemplate<Node> * getTree() const;  
+    TreeTemplate<Node> * getTree();
+};

src/mappings/swig/python/AbstractTreeParsimonyData.i

@@ -0,0 +1,18 @@
+%module bpptest
+%{
+#include "AbstractTreeParsimonyData.h"
+using namespace bpp;
+%}
+%include "TreeParsimonyData.i"
+
+class AbstractTreeParsimonyData:public TreeParsimonyData
+{
+  public:
+    AbstractTreeParsimonyData();
+    virtual ~AbstractTreeParsimonyData();
+
+    unsigned int getRootArrayPosition(const unsigned int site) const;
+    unsigned int getWeight(unsigned int pos) const;
+    const TreeTemplate<Node> * getTree() const;  
+    TreeTemplate<Node> * getTree();
+};

src/mappings/swig/python/AbstractTreeParsimonyScore.i

@@ -0,0 +1,21 @@
+%module bpptest
+%{
+#include "AbstractTreeParsimonyScore.h"
+using namespace bpp;
+%}
+%include "TreeParsimonyScore.i"
+%include "Node.i"
+%include "SiteContainer.i"
+
+%rename(__assign__) AbstractTreeParsimonyScore::operator=;
+
+class AbstractTreeParsimonyScore :public virtual TreeParsimonyScore
+{
+    AbstractTreeParsimonyScore(const Tree & tree, const SiteContainer & data, bool verbose) throw (Exception);
+    AbstractTreeParsimonyScore(const AbstractTreeParsimonyScore & tp);
+    AbstractTreeParsimonyScore & operator=(const AbstractTreeParsimonyScore & tp);
+    virtual ~AbstractTreeParsimonyScore();
+
+    virtual const Tree * getTree() const;
+    virtual vector<unsigned int> getScoreForEachSite() const;
+};

src/mappings/swig/python/AgglomerativeDistanceMethod.i

@@ -0,0 +1,19 @@
+%module bpptest
+%{
+#include "AgglomerativeDistanceMethod.h"
+using namespace bpp;
+%}
+
+class DistanceMatrix;
+class Node;
+class Tree;
+class AgglomerativeDistanceMethod
+{
+  public:
+    AgglomerativeDistanceMethod();
+    virtual ~AgglomerativeDistanceMethod();
+
+    virtual void setDistanceMatrix(const DistanceMatrix & matrix) = 0;
+    virtual void computeTree(bool rooted) = 0;
+    virtual Tree * getTree() const = 0;
+};

src/mappings/swig/python/AnalyticalSubstitutionCount.i

@@ -0,0 +1,18 @@
+%module bpptest
+%{
+#include "AnalyticalSubstitutionCount.h"
+using namespace bpp;
+%}
+%include "SubstitutionCount.i"
+%include "SubstitutionModel.i"
+
+class AnalyticalSubstitutionCount:public SubstitutionCount
+{
+  public:
+    AnalyticalSubstitutionCount(const SubstitutionModel * model, int cutOff);
+    virtual ~AnalyticalSubstitutionCount();
+
+    double getNumberOfSubstitutions(int initialState, int finalState, double length) const;
+    Matrix<double> * getAllNumbersOfSubstitutions(double length) const;
+    void setSubstitutionModel(const SubstitutionModel* model);
+};

src/mappings/swig/python/AncestralStateReconstruction.i

@@ -0,0 +1,23 @@
+%module bpptest
+%{
+#include "AncestralStateReconstruction.h"
+using namespace bpp;
+%}
+%include "Sequence.i"
+%include "SequenceContainer.i"
+%include "std_vector.i"
+%include "std_map.i"
+using namespace std;
+
+class Node;
+class AncestralStateReconstruction
+{
+  public:
+    AncestralStateReconstruction();
+    virtual ~AncestralStateReconstruction();
+
+    virtual vector<int> getAncestralStatesForNode(int nodeId) const = 0;
+    virtual map<int, vector<int> > getAllAncestralStates() const = 0;
+    virtual Sequence * getAncestralSequenceForNode(int nodeId) const = 0;
+    virtual SequenceContainer * getAncestralSequences() const = 0;
+};

src/mappings/swig/python/BioNJ.i

@@ -0,0 +1,22 @@
+%module bpptest
+%{
+#include "BioNJ.h"
+using namespace bpp;
+%}
+%include "NeighborJoining.i"
+
+%rename(__assign__) BioNJ::operator=;
+
+class BioNJ:public NeighborJoining
+{
+  public:
+    BioNJ();
+    BioNJ(const DistanceMatrix & matrix, bool rooted = false, bool positiveLengths = false) throw (Exception);
+    BioNJ(const BioNJ & bionj);
+    BioNJ & operator=(const BioNJ & bionj);
+    virtual ~BioNJ();
+
+    virtual void setDistanceMatrix(const DistanceMatrix & matrix);
+    virtual void computeTree(bool rooted) throw (Exception);
+    virtual double computeDistancesFromPair(const vector<unsigned int> & pair, const vector<double> & branchLengths, unsigned int pos);
+};