RescaledHmmLikelihood.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1

#ifndef BPP_NUMERIC_HMM_RESCALEDHMMLIKELIHOOD_H
#define BPP_NUMERIC_HMM_RESCALEDHMMLIKELIHOOD_H


#include "../AbstractParametrizable.h"
#include "../Matrix/Matrix.h"
#include "HmmLikelihood.h"

// From the STL:
#include <vector>
#include <memory>

namespace bpp
{
class RescaledHmmLikelihood :
  public virtual AbstractHmmLikelihood,
  public AbstractParametrizable
{
private:
  std::shared_ptr<HmmStateAlphabet> hiddenAlphabet_;
  std::shared_ptr<HmmTransitionMatrix> transitionMatrix_;
  std::shared_ptr<HmmEmissionProbabilities> emissionProbabilities_;

  std::vector<double> likelihood_;

  mutable std::vector<std::vector<double>> dLikelihood_;
  mutable std::vector<std::vector<double>> d2Likelihood_;

  mutable std::vector<std::vector<double>> backLikelihood_;
  mutable bool backLikelihoodUpToDate_;

  std::vector<double> scales_;

  mutable std::vector<double> dScales_;
  mutable std::vector<double> d2Scales_;
  double logLik_;

  std::vector<size_t> breakPoints_;

  size_t nbStates_, nbSites_;

public:
  RescaledHmmLikelihood(
      std::shared_ptr<HmmStateAlphabet> hiddenAlphabet,
      std::shared_ptr<HmmTransitionMatrix> transitionMatrix,
      std::shared_ptr<HmmEmissionProbabilities> emissionProbabilities,
      const std::string& prefix);

  RescaledHmmLikelihood(const RescaledHmmLikelihood& lik) :
    AbstractHmmLikelihood(lik),
    AbstractParametrizable(lik),
    hiddenAlphabet_(dynamic_cast<HmmStateAlphabet*>(lik.hiddenAlphabet_->clone())),
    transitionMatrix_(dynamic_cast<HmmTransitionMatrix*>(lik.transitionMatrix_->clone())),
    emissionProbabilities_(dynamic_cast<HmmEmissionProbabilities*>(lik.emissionProbabilities_->clone())),
    likelihood_(lik.likelihood_),
    dLikelihood_(lik.dLikelihood_),
    d2Likelihood_(lik.d2Likelihood_),
    backLikelihood_(lik.backLikelihood_),
    backLikelihoodUpToDate_(lik.backLikelihoodUpToDate_),
    scales_(lik.scales_),
    dScales_(lik.dScales_),
    d2Scales_(lik.d2Scales_),
    logLik_(lik.logLik_),
    breakPoints_(lik.breakPoints_),
    nbStates_(lik.nbStates_),
    nbSites_(lik.nbSites_)
  {
    // Now adjust pointers:
    transitionMatrix_->setHmmStateAlphabet(hiddenAlphabet_);
    emissionProbabilities_->setHmmStateAlphabet(hiddenAlphabet_);
  }

  RescaledHmmLikelihood& operator=(const RescaledHmmLikelihood& lik)
  {
    AbstractHmmLikelihood::operator=(lik);
    AbstractParametrizable::operator=(lik);
    hiddenAlphabet_        = std::unique_ptr<HmmStateAlphabet>(dynamic_cast<HmmStateAlphabet*>(lik.hiddenAlphabet_->clone()));
    transitionMatrix_      = std::unique_ptr<HmmTransitionMatrix>(dynamic_cast<HmmTransitionMatrix*>(lik.transitionMatrix_->clone()));
    emissionProbabilities_ = std::unique_ptr<HmmEmissionProbabilities>(dynamic_cast<HmmEmissionProbabilities*>(lik.emissionProbabilities_->clone()));
    likelihood_            = lik.likelihood_;
    dLikelihood_           = lik.dLikelihood_;
    d2Likelihood_          = lik.d2Likelihood_;
    backLikelihood_        = lik.backLikelihood_;
    backLikelihoodUpToDate_ = lik.backLikelihoodUpToDate_;
    scales_                = lik.scales_;
    dScales_               = lik.dScales_;
    d2Scales_              = lik.d2Scales_;
    logLik_                = lik.logLik_;
    breakPoints_           = lik.breakPoints_;
    nbStates_              = lik.nbStates_;
    nbSites_               = lik.nbSites_;

    // Now adjust pointers:
    transitionMatrix_->setHmmStateAlphabet(hiddenAlphabet_);
    emissionProbabilities_->setHmmStateAlphabet(hiddenAlphabet_);
    return *this;
  }

  virtual ~RescaledHmmLikelihood() {}

  RescaledHmmLikelihood* clone() const override { return new RescaledHmmLikelihood(*this); }

public:
  const HmmStateAlphabet& hmmStateAlphabet() const override { return *hiddenAlphabet_; }
  std::shared_ptr<const HmmStateAlphabet> getHmmStateAlphabet() const override { return hiddenAlphabet_; }

  HmmStateAlphabet& hmmStateAlphabet() override { return *hiddenAlphabet_; }
  std::shared_ptr<HmmStateAlphabet> getHmmStateAlphabet() override { return hiddenAlphabet_; }

  const HmmTransitionMatrix& hmmTransitionMatrix() const override { return *transitionMatrix_; }
  std::shared_ptr<const HmmTransitionMatrix> getHmmTransitionMatrix() const override { return transitionMatrix_; }

  HmmTransitionMatrix& hmmTransitionMatrix() override { return *transitionMatrix_; }
  std::shared_ptr<HmmTransitionMatrix> getHmmTransitionMatrix() override { return transitionMatrix_; }

  const HmmEmissionProbabilities& hmmEmissionProbabilities() const override { return *emissionProbabilities_; }
  std::shared_ptr<const HmmEmissionProbabilities> getHmmEmissionProbabilities() const override { return emissionProbabilities_; }

  HmmEmissionProbabilities& hmmEmissionProbabilities() override { return *emissionProbabilities_; }
  std::shared_ptr<HmmEmissionProbabilities> getHmmEmissionProbabilities() override { return emissionProbabilities_; }

  void setBreakPoints(const std::vector<size_t>& breakPoints) override
  {
    breakPoints_ = breakPoints;
    computeForward_();
    backLikelihoodUpToDate_ = false;
  }

  const std::vector<size_t>& getBreakPoints() const override { return breakPoints_; }

  void setParameters(const ParameterList& pl) override
  {
    setParametersValues(pl);
  }

  double getValue() const override { return -logLik_; }

  double getLogLikelihood() const override { return logLik_; }

  double getLikelihoodForASite(size_t site) const override;

  double getDLogLikelihoodForASite(size_t site) const override;

  double getD2LogLikelihoodForASite(size_t site) const override;

  Vdouble getLikelihoodForEachSite() const override;

  void setNamespace(const std::string& nameSpace) override;

  void fireParameterChanged(const ParameterList& pl) override;

  Vdouble getHiddenStatesPosteriorProbabilitiesForASite(size_t site) const override;

  void getHiddenStatesPosteriorProbabilities(std::vector< std::vector<double>>& probs, bool append = false) const override;

protected:
  void computeForward_();
  void computeBackward_() const;


  void computeDLikelihood_() const override
  {
    computeDForward_();
  }

  void computeD2Likelihood_() const override
  {
    computeD2Forward_();
  }

  void computeDForward_() const;

  void computeD2Forward_() const;
};
}
#endif // BPP_NUMERIC_HMM_RESCALEDHMMLIKELIHOOD_H