AbstractOptimizer.h

Go to the documentation of this file.

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

#ifndef BPP_NUMERIC_FUNCTION_ABSTRACTOPTIMIZER_H
#define BPP_NUMERIC_FUNCTION_ABSTRACTOPTIMIZER_H


#include "Optimizer.h"

namespace bpp
{
class AbstractOptimizer :
  public virtual OptimizerInterface
{
protected:
  std::shared_ptr<FunctionInterface> function_;

  ParameterList parameters_;

  std::shared_ptr<OutputStream> messageHandler_;

  std::shared_ptr<OutputStream> profiler_;

  std::string constraintPolicy_;

  std::shared_ptr<OptimizationStopCondition> stopCondition_;

  std::shared_ptr<OptimizationStopCondition> defaultStopCondition_;

  unsigned int verbose_;

  bool isInitialized_;

  time_t startTime_;

  std::vector< std::shared_ptr<OptimizationListener>> listeners_;

  bool updateParameters_;

  std::string stepChar_;

protected:
  unsigned int nbEvalMax_;

  unsigned int nbEval_;

  double currentValue_;

  bool tolIsReached_;

public:
  AbstractOptimizer(std::shared_ptr<FunctionInterface> function = nullptr);

  AbstractOptimizer(const AbstractOptimizer& opt);

  AbstractOptimizer& operator=(const AbstractOptimizer& opt);

  virtual ~AbstractOptimizer() {}

public:
  void init(const ParameterList& params) override;
  double step() override;

  double optimize() override;

  bool isInitialized() const override { return isInitialized_; }

  const ParameterList& getParameters() const override { return parameters_; }

  double getParameterValue(const std::string& name) const override
  {
    return parameters_.getParameterValue(name);
  }

  void setFunction(std::shared_ptr<FunctionInterface> function) override
  {
    function_ = function;
    if (function) stopCondition_->init();
  }

  const FunctionInterface& function() const override
  {
    if (function_)
    {
      return *function_;
    }
    else
    {
      throw NullPointerException("AbstractOptimizer::function() : no function associated to this optimizer.");
    }
  }

  FunctionInterface& function() override
  {
    if (function_)
    {
      return *function_;
    }
    else
    {
      throw NullPointerException("AbstractOptimizer::function() : no function associated to this optimizer.");
    }
  }

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

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

  bool hasFunction() const override { return function_ != 0; }

  double getFunctionValue() const override
  {
    if (!function_) throw NullPointerException("AbstractOptimizer::getFunctionValue. No function associated to this optimizer.");
    return currentValue_;
  }

  void setMessageHandler(std::shared_ptr<OutputStream> mh) override { messageHandler_ = mh; }

  std::shared_ptr<OutputStream> getMessageHandler() const override { return messageHandler_; }

  void setProfiler(std::shared_ptr<OutputStream> profiler) override { profiler_ = profiler; }

  std::shared_ptr<OutputStream> getProfiler() const override { return profiler_; }

  unsigned int getNumberOfEvaluations() const override { return nbEval_; }

  void setStopCondition(std::shared_ptr<OptimizationStopCondition> stopCondition) override
  {
    stopCondition_ = stopCondition;
  }

  std::shared_ptr<OptimizationStopCondition> getStopCondition() override { return stopCondition_; }

  std::shared_ptr<const OptimizationStopCondition> getStopCondition() const override { return stopCondition_; }

  std::shared_ptr<OptimizationStopCondition> getDefaultStopCondition() override { return defaultStopCondition_; }

  std::shared_ptr<const OptimizationStopCondition> getDefaultStopCondition() const override { return defaultStopCondition_; }

  bool isToleranceReached() const override { return tolIsReached_; }

  bool isMaximumNumberOfEvaluationsReached() const override { return nbEval_ >= nbEvalMax_; }

  void setMaximumNumberOfEvaluations(unsigned int max) override { nbEvalMax_ = max; }

  void setVerbose(unsigned int v) override { verbose_ = v; }

  unsigned int getVerbose() const override { return verbose_; }

  void setConstraintPolicy(const std::string& constraintPolicy) override { constraintPolicy_ = constraintPolicy; }

  std::string getConstraintPolicy() const override { return constraintPolicy_; }

  void addOptimizationListener(std::shared_ptr<OptimizationListener> listener) override
  {
    if (listener)
      listeners_.push_back(listener);
  }
  void updateParameters(bool yn) override { updateParameters_ = yn; }

  bool updateParameters() const override { return updateParameters_; }

  void setOptimizationProgressCharacter(const std::string& c) { stepChar_ = c; }
  const std::string& getOptimizationProgressCharacter() const { return stepChar_; }

protected:
  virtual void doInit(const ParameterList& params) = 0;

  virtual double doStep() = 0;

  void autoParameter();

  void ignoreConstraints();

  void profile(double v);

  void profile(unsigned int v);

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

  void profileln(double v);

  void profileln(unsigned int v);

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

  void printPoint(const ParameterList& params, double value);

  void printMessage(const std::string& message);

  void fireOptimizationInitializationPerformed(const OptimizationEvent& event);

  void fireOptimizationStepPerformed(const OptimizationEvent& event);

  bool listenerModifiesParameters() const;
protected:
  ParameterList& getParameters_() { return parameters_; }

  Parameter& getParameter_(size_t i) { return parameters_[i]; }

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

  void setDefaultStopCondition_(std::shared_ptr<OptimizationStopCondition> osc)
  {
    defaultStopCondition_ = osc;
  }
};
} // end of namespace bpp.
#endif // BPP_NUMERIC_FUNCTION_ABSTRACTOPTIMIZER_H