OptimizationStopCondition.h

Go to the documentation of this file.

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

#ifndef BPP_NUMERIC_FUNCTION_OPTIMIZATIONSTOPCONDITION_H
#define BPP_NUMERIC_FUNCTION_OPTIMIZATIONSTOPCONDITION_H


#include "../ParameterList.h"

using namespace std;

namespace bpp
{
class OptimizerInterface;

/******************************************************************************/

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

  OptimizationStopCondition* clone() const = 0;

public:
  virtual const OptimizerInterface* getOptimizer() const = 0;
  virtual void setOptimizer(const OptimizerInterface* optimizer) = 0;

  virtual void init() = 0;

  virtual bool isToleranceReached() const = 0;

  virtual void setTolerance(double tolerance) = 0;

  virtual double getTolerance() const = 0;

  virtual double getCurrentTolerance() const = 0;
};

/******************************************************************************/

class AbstractOptimizationStopCondition :
  public virtual OptimizationStopCondition
{
protected:
  const OptimizerInterface* optimizer_;
  double tolerance_;

  mutable double callCount_;

  int burnin_;

public:
  AbstractOptimizationStopCondition(const OptimizerInterface* optimizer) :
    optimizer_(optimizer),
    tolerance_(0.000001),
    callCount_(0),
    burnin_(0) {}

  AbstractOptimizationStopCondition(const OptimizerInterface* optimizer, double tolerance) :
    optimizer_(optimizer),
    tolerance_(tolerance),
    callCount_(0),
    burnin_(0) {}

  AbstractOptimizationStopCondition(const OptimizerInterface* optimizer, int burnin) :
    optimizer_(optimizer),
    tolerance_(0.000001),
    callCount_(0),
    burnin_(burnin) {}

  AbstractOptimizationStopCondition(const OptimizerInterface* optimizer, double tolerance, int burnin) :
    optimizer_(optimizer),
    tolerance_(tolerance),
    callCount_(0),
    burnin_(burnin) {}

  AbstractOptimizationStopCondition(const AbstractOptimizationStopCondition& aosc) :
    optimizer_(aosc.optimizer_),
    tolerance_(aosc.tolerance_),
    callCount_(aosc.callCount_),
    burnin_(aosc.burnin_) {}

  AbstractOptimizationStopCondition& operator=(const AbstractOptimizationStopCondition& aosc)
  {
    optimizer_ = aosc.optimizer_;
    tolerance_ = aosc.tolerance_;
    callCount_ = aosc.callCount_;
    burnin_    = aosc.burnin_;
    return *this;
  }

  virtual ~AbstractOptimizationStopCondition() {}

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

  void setOptimizer(const OptimizerInterface* optimizer) { optimizer_ = optimizer; }

  void setTolerance(double tolerance) { tolerance_ = tolerance; }

  double getTolerance() const { return tolerance_; }

  void init() { resetCounter(); }

  virtual void resetCounter() { callCount_ = 0; }

  virtual void setBurnin(int burnin) { burnin_ = burnin; }

  virtual int getBurnin() const { return burnin_; }
};

/******************************************************************************/

class ParametersStopCondition :
  public AbstractOptimizationStopCondition
{
private:
  mutable ParameterList lastParametersEstimates_;

  mutable ParameterList newParametersEstimates_;

public:
  ParametersStopCondition(const OptimizerInterface* optimizer);
  ParametersStopCondition(const OptimizerInterface* optimizer, double tolerance);
  ParametersStopCondition(const OptimizerInterface* optimizer, int burnin);
  ParametersStopCondition(const OptimizerInterface* optimizer, double tolerance, int burnin);

  virtual ~ParametersStopCondition() {}

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

public:
  void init();

  bool isToleranceReached() const;

  double getCurrentTolerance() const;
};

/******************************************************************************/

class FunctionStopCondition :
  public AbstractOptimizationStopCondition
{
private:
  mutable double lastFunctionValue_;

  mutable double newFunctionValue_;

public:
  FunctionStopCondition(const OptimizerInterface* optimizer);
  FunctionStopCondition(const OptimizerInterface* optimizer, double tolerance);
  FunctionStopCondition(const OptimizerInterface* optimizer, int burnin);
  FunctionStopCondition(const OptimizerInterface* optimizer, double tolerance, int burnin);

  virtual ~FunctionStopCondition();

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

public:
  void init();
  bool isToleranceReached() const;
  double getCurrentTolerance() const;
};
} // end of namespace bpp.
#endif // BPP_NUMERIC_FUNCTION_OPTIMIZATIONSTOPCONDITION_H