ReparametrizationFunctionWrapper.h

Go to the documentation of this file.

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

#ifndef BPP_NUMERIC_FUNCTION_REPARAMETRIZATIONFUNCTIONWRAPPER_H
#define BPP_NUMERIC_FUNCTION_REPARAMETRIZATIONFUNCTIONWRAPPER_H


#include "../AbstractParametrizable.h"
#include "../TransformedParameter.h"
#include "Functions.h"

namespace bpp
{
class ReparametrizationFunctionWrapper :
  public virtual FunctionInterface,
  public AbstractParametrizable
{
protected:
  std::shared_ptr<FunctionInterface> function_;
  ParameterList functionParameters_;

public:
  ReparametrizationFunctionWrapper(std::shared_ptr<FunctionInterface> function, bool verbose = true) :
    AbstractParametrizable(function->getNamespace()),
    function_(function),
    functionParameters_(function->getParameters())
  {
    init_(verbose);
  }

  ReparametrizationFunctionWrapper(std::shared_ptr<FunctionInterface> function, const ParameterList& parameters, bool verbose = true) :
    AbstractParametrizable(function->getNamespace()),
    function_(function),
    functionParameters_(function->getParameters().getCommonParametersWith(parameters))
  {
    init_(verbose);
  }

  ReparametrizationFunctionWrapper(const ReparametrizationFunctionWrapper& rfw) :
    AbstractParametrizable(rfw),
    function_(rfw.function_),
    functionParameters_(rfw.functionParameters_) {}

  ReparametrizationFunctionWrapper& operator=(const ReparametrizationFunctionWrapper& rfw)
  {
    AbstractParametrizable::operator=(rfw),
    function_ = rfw.function_;
    functionParameters_ = rfw.functionParameters_;
    return *this;
  }

  virtual ~ReparametrizationFunctionWrapper() {}

  ReparametrizationFunctionWrapper* clone() const { return new ReparametrizationFunctionWrapper(*this); }

private:
  void init_(bool verbose);

public:
  virtual const FunctionInterface& function() const { return *function_; }

  virtual FunctionInterface& function() { return *function_; }

  virtual std::shared_ptr<const FunctionInterface> getFunction() const { return function_; }

  virtual std::shared_ptr<FunctionInterface> getFunction() { return function_; }

  void setParameters(const ParameterList& parameters)
  {
//      parameters.printParameters(std::cout);
    matchParametersValues(parameters);
    // We only set parameters that have been changed:
//      functionParameters_.printParameters(std::cout);
    function_->setParameters(functionParameters_.createSubList(parameters.getParameterNames()));
  }

  double getValue() const
  {
    return function_->getValue();
  }

  void fireParameterChanged (const ParameterList& parameters);
};

class ReparametrizationDerivableFirstOrderWrapper :
  public virtual FirstOrderDerivable,
  public ReparametrizationFunctionWrapper
{
public:
  ReparametrizationDerivableFirstOrderWrapper(std::shared_ptr<FirstOrderDerivable> function, bool verbose = true) :
    ReparametrizationFunctionWrapper(function, verbose)
  {}

  ReparametrizationDerivableFirstOrderWrapper(std::shared_ptr<FirstOrderDerivable> function, const ParameterList& parameters, bool verbose = true) :
    ReparametrizationFunctionWrapper(function, parameters, verbose)
  {}

  virtual ~ReparametrizationDerivableFirstOrderWrapper() {}

  ReparametrizationDerivableFirstOrderWrapper* clone() const { return new ReparametrizationDerivableFirstOrderWrapper(*this); }

private:
  void init_(bool verbose);

public:
  void enableFirstOrderDerivatives(bool yn) { std::dynamic_pointer_cast<FirstOrderDerivable>(function_)->enableFirstOrderDerivatives(yn); }

  bool enableFirstOrderDerivatives() const { return std::dynamic_pointer_cast<const FirstOrderDerivable>(function_)->enableFirstOrderDerivatives(); }

  double getFirstOrderDerivative(const std::string& variable) const
  {
    return std::dynamic_pointer_cast<const FirstOrderDerivable>(function_)->getFirstOrderDerivative(variable)
           * dynamic_cast<const TransformedParameter&>(parameter(variable)).getFirstOrderDerivative();
  }
};


class ReparametrizationDerivableSecondOrderWrapper :
  public virtual SecondOrderDerivable,
  public ReparametrizationDerivableFirstOrderWrapper
{
public:
  ReparametrizationDerivableSecondOrderWrapper(std::shared_ptr<SecondOrderDerivable> function, bool verbose = true) :
    ReparametrizationDerivableFirstOrderWrapper(function, verbose)
  {}

  ReparametrizationDerivableSecondOrderWrapper(std::shared_ptr<SecondOrderDerivable> function, const ParameterList& parameters, bool verbose = true) :
    ReparametrizationDerivableFirstOrderWrapper(function, parameters, verbose)
  {}

  virtual ~ReparametrizationDerivableSecondOrderWrapper() {}

  ReparametrizationDerivableSecondOrderWrapper* clone() const { return new ReparametrizationDerivableSecondOrderWrapper(*this); }

private:
  void init_(bool verbose);

public:
  void enableSecondOrderDerivatives(bool yn) { std::dynamic_pointer_cast<SecondOrderDerivable>(function_)->enableSecondOrderDerivatives(yn); }

  bool enableSecondOrderDerivatives() const { return std::dynamic_pointer_cast<const SecondOrderDerivable>(function_)->enableSecondOrderDerivatives(); }

  double getSecondOrderDerivative(const std::string& variable) const
  {
    return std::dynamic_pointer_cast<const SecondOrderDerivable>(function_)->getSecondOrderDerivative(variable)
           * std::pow(dynamic_cast<const TransformedParameter&>(parameter(variable)).getFirstOrderDerivative(), 2)
           + std::dynamic_pointer_cast<const SecondOrderDerivable>(function_)->getFirstOrderDerivative(variable)
           * dynamic_cast<const TransformedParameter&>(parameter(variable)).getSecondOrderDerivative();
  }

  double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const
  {
    return std::dynamic_pointer_cast<const SecondOrderDerivable>(function_)->getSecondOrderDerivative(variable1, variable2)
           * dynamic_cast<const TransformedParameter&>(parameter(variable1)).getFirstOrderDerivative()
           * dynamic_cast<const TransformedParameter&>(parameter(variable2)).getFirstOrderDerivative();
  }
};
} // end of namespace bpp.
#endif // BPP_NUMERIC_FUNCTION_REPARAMETRIZATIONFUNCTIONWRAPPER_H