Optimizer.h

Go to the documentation of this file.

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

#ifndef BPP_NUMERIC_FUNCTION_OPTIMIZER_H
#define BPP_NUMERIC_FUNCTION_OPTIMIZER_H


#include "../../Clonable.h"
#include "../../Io/OutputStream.h"
#include "../ParameterList.h"
#include "Functions.h"
#include "OptimizationStopCondition.h"

namespace bpp
{
class OptimizerInterface;

class OptimizationEvent
{
private:
  OptimizerInterface* optimizer_;

public:
  OptimizationEvent(OptimizerInterface* optimizer) : optimizer_(optimizer) {}
  OptimizationEvent(const OptimizationEvent& oe) : optimizer_(oe.optimizer_) {}
  OptimizationEvent& operator=(const OptimizationEvent& oe)
  {
    optimizer_ = oe.optimizer_;
    return *this;
  }
  virtual ~OptimizationEvent() {}

public:
  OptimizerInterface* getOptimizer() { return optimizer_; }

  const OptimizerInterface* getOptimizer() const { return optimizer_; }
};


class OptimizationListener
{
public:
  OptimizationListener() {}
  virtual ~OptimizationListener() {}

public:
  virtual void optimizationInitializationPerformed(const OptimizationEvent& event) = 0;
  virtual void optimizationStepPerformed(const OptimizationEvent& event) = 0;
  virtual bool listenerModifiesParameters() const = 0;
};


class OptimizerInterface :
  public virtual Clonable
{
public:
  OptimizerInterface() {}
  virtual ~OptimizerInterface() {}

  OptimizerInterface* clone() const = 0;

public:
  virtual void init(const ParameterList& params) = 0;

  virtual bool isInitialized() const = 0;

  virtual double step() = 0;

  virtual const ParameterList& getParameters() const = 0;

  virtual double getParameterValue(const std::string& name) const = 0;
  virtual double getFunctionValue() const = 0;

  virtual double optimize() = 0;

  virtual void setFunction(std::shared_ptr<FunctionInterface> function) = 0;

  virtual const FunctionInterface& function() const = 0;

  virtual FunctionInterface& function() = 0;

  virtual std::shared_ptr<const FunctionInterface> getFunction() const = 0;

  virtual std::shared_ptr<FunctionInterface> getFunction() = 0;

  virtual bool hasFunction() const = 0;

  virtual void setMessageHandler(std::shared_ptr<OutputStream> mh) = 0;

  virtual std::shared_ptr<OutputStream> getMessageHandler() const = 0;

  virtual void setProfiler(std::shared_ptr<OutputStream> profiler) = 0;

  virtual std::shared_ptr<OutputStream> getProfiler() const = 0;

  virtual unsigned int getNumberOfEvaluations() const = 0;

  virtual void setStopCondition(std::shared_ptr<OptimizationStopCondition> stopCondition) = 0;

  virtual std::shared_ptr<OptimizationStopCondition> getStopCondition() = 0;

  virtual std::shared_ptr<const OptimizationStopCondition> getStopCondition() const = 0;

  virtual std::shared_ptr<OptimizationStopCondition> getDefaultStopCondition() = 0;

  virtual std::shared_ptr<const OptimizationStopCondition> getDefaultStopCondition() const = 0;

  virtual bool isToleranceReached() const = 0;

  virtual bool isMaximumNumberOfEvaluationsReached() const = 0;

  virtual void setMaximumNumberOfEvaluations(unsigned int max) = 0;

  virtual void setVerbose(unsigned int v) = 0;

  virtual unsigned int getVerbose() const = 0;

  virtual void setConstraintPolicy(const std::string& constraintPolicy) = 0;

  virtual std::string getConstraintPolicy() const = 0;

  virtual void addOptimizationListener(std::shared_ptr<OptimizationListener> listener) = 0;

  virtual void updateParameters(bool yn) = 0;

  virtual bool updateParameters() const = 0;
};


class BackupListener :
  public OptimizationListener
{
private:
  std::string backupFile_;

public:
  BackupListener(const string& backupFile) :
    backupFile_(backupFile) {}

  virtual ~BackupListener() {}

public:
  void optimizationInitializationPerformed(const OptimizationEvent& event) {}

  void optimizationStepPerformed(const OptimizationEvent& event)
  {
    std::ofstream bck(backupFile_.c_str(), std::ios::out);
    bck << "f(x)=" << setprecision(20) << event.getOptimizer()->getFunction()->getValue() << endl;
    ParameterList pl = event.getOptimizer()->getFunction()->getParameters();
    for (unsigned int i = 0; i < pl.size(); ++i)
    {
      bck << pl[i].getName() << "=" <<  setprecision(20) << pl[i].getValue() << std::endl;
    }
    bck.close();
  }

  bool listenerModifiesParameters() const { return false; }
};
} // end of namespace bpp.
#endif // BPP_NUMERIC_FUNCTION_OPTIMIZER_H