MetaOptimizer.h

Go to the documentation of this file.

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

#ifndef BPP_NUMERIC_FUNCTION_METAOPTIMIZER_H
#define BPP_NUMERIC_FUNCTION_METAOPTIMIZER_H


#include "AbstractOptimizer.h"

// From the STL:
#include <vector>

namespace bpp
{
class MetaOptimizerInfos :
  public virtual Clonable
{
public:
  static std::string IT_TYPE_STEP;
  static std::string IT_TYPE_FULL;

private:
  std::vector<std::string> names_;
  std::vector< std::shared_ptr<OptimizerInterface>> optimizers_;
  std::vector< std::vector<std::string>> parameterNames_;
  std::vector<unsigned short> derivatives_;
  std::vector<std::string> itTypes_;

public:
  MetaOptimizerInfos() : names_(), optimizers_(), parameterNames_(), derivatives_(), itTypes_() {}
  MetaOptimizerInfos(const MetaOptimizerInfos& infos) :
    names_(infos.names_),
    optimizers_(infos.optimizers_),
    parameterNames_(infos.parameterNames_),
    derivatives_(infos.derivatives_),
    itTypes_(infos.itTypes_)
  {
    for (size_t i = 0; i < optimizers_.size(); ++i)
    {
      optimizers_[i] = std::shared_ptr<OptimizerInterface>(infos.optimizers_[i]->clone());
    }
  }

  MetaOptimizerInfos& operator=(const MetaOptimizerInfos& infos)
  {
    names_          = infos.names_;
    optimizers_     = infos.optimizers_;
    parameterNames_ = infos.parameterNames_;
    derivatives_    = infos.derivatives_;
    itTypes_        = infos.itTypes_;
    for (size_t i = 0; i < optimizers_.size(); ++i)
    {
      optimizers_[i] = std::shared_ptr<OptimizerInterface>(infos.optimizers_[i]->clone());
    }
    return *this;
  }

  virtual ~MetaOptimizerInfos() {}

public:
  MetaOptimizerInfos* clone() const override { return new MetaOptimizerInfos(*this); }

public:
  virtual void addOptimizer(const std::string& name, std::shared_ptr<OptimizerInterface> optimizer, const std::vector<std::string>& params, unsigned short derivatives = 0, const std::string& type = IT_TYPE_STEP)
  {
    names_.push_back(name);
    optimizers_.push_back(optimizer);
    parameterNames_.push_back(params);
    derivatives_.push_back(derivatives);
    itTypes_.push_back(type);
  }

  virtual const std::string& getName(size_t i) const { return names_[i]; }

  virtual OptimizerInterface& optimizer(size_t i) { return *optimizers_[i]; }

  virtual const OptimizerInterface& optimizer(size_t i) const { return *optimizers_[i]; }

  virtual std::shared_ptr<OptimizerInterface> getOptimizer(size_t i) { return optimizers_[i]; }

  virtual std::shared_ptr<const OptimizerInterface> getOptimizer(size_t i) const { return optimizers_[i]; }

  virtual std::vector<std::string>& getParameterNames(size_t i) { return parameterNames_[i]; }
  virtual const std::vector<std::string>& getParameterNames(size_t i) const { return parameterNames_[i]; }

  virtual std::string& getIterationType(size_t i) { return itTypes_[i]; }
  virtual const std::string& getIterationType(size_t i) const { return itTypes_[i]; }

  virtual bool requiresFirstOrderDerivatives(size_t i) const { return derivatives_[i] > 0; }
  virtual bool requiresSecondOrderDerivatives(size_t i) const { return derivatives_[i] > 1; }

  virtual size_t getNumberOfOptimizers() const { return optimizers_.size(); }
};

class MetaOptimizer :
  public AbstractOptimizer
{
private:
  std::unique_ptr<MetaOptimizerInfos> optDesc_;
  std::vector<ParameterList> optParameters_;
  std::vector<size_t> nbParameters_;
  unsigned int n_;
  double precisionStep_;
  unsigned int stepCount_;
  double initialValue_;

public:
  MetaOptimizer(std::shared_ptr<FunctionInterface> function, std::unique_ptr<MetaOptimizerInfos> desc, unsigned int n = 1);

  virtual ~MetaOptimizer();

  MetaOptimizer(const MetaOptimizer& opt);

  MetaOptimizer& operator=(const MetaOptimizer& opt);

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

public:
  void setFunction(std::shared_ptr<FunctionInterface> function) override
  {
    AbstractOptimizer::setFunction(function);
    for (unsigned int i = 0; i < optDesc_->getNumberOfOptimizers(); ++i)
    {
      optDesc_->getOptimizer(i)->setFunction(function);
    }
  }

  void doInit(const ParameterList& parameters) override;

  double doStep() override;

  MetaOptimizerInfos& optimizers() { return *optDesc_; }

  const MetaOptimizerInfos optimizers() const { return *optDesc_; }
};
} // end of namespace bpp.
#endif // BPP_NUMERIC_FUNCTION_METAOPTIMIZER_H