Options.hpp

// Unfit: Data fitting and optimization software
//
// Copyright (C) 2012- Dr Martin Buist & Dr Alberto Corrias
// Contacts: martin.buist _at_ nus.edu.sg; alberto _at_ nus.edu.sg
//
// See the 'Contributors' file for a list of those who have contributed
// to this work.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
#ifndef UNFIT_INCLUDE_OPTIONS_HPP_
#define UNFIT_INCLUDE_OPTIONS_HPP_

namespace Unfit
{
class Options
{
 public:
  Options();

  void ResetOptions();

  double GetCostTolerance() const noexcept;

  void SetCostTolerance(double tolerance);

  double GetDegenerateTolerance() const noexcept;

  void SetDegenerateTolerance(double tolerance);

  double GetGeometricTolerance() const noexcept;

  void SetGeometricTolerance(double tolerance);

  double GetAlpha() const noexcept;

  void SetAlpha(double alpha);

  double GetBeta() const noexcept;

  void SetBeta(double beta);

  double GetDelta() const noexcept;

  void SetDelta(double delta);

  double GetGamma() const noexcept;

  void SetGamma(double gamma);

  double GetEpsilon() const noexcept;

  void SetEpsilon(double epsilon);

  void SetTau(double tau);

  double GetTau() const noexcept;

  unsigned GetMaxFunctionEvaluations() const noexcept;

  void SetMaxFunctionEvaluations(unsigned max_func_evals);

  unsigned GetMaxIterations() const noexcept;

  void SetMaxIterations(unsigned max_iters);

  void GetNelderMeadStepSizes(double &alpha, double &beta, double &delta,
    double &gamma);

  void SetNelderMeadStepSizes(double alpha, double beta, double delta,
    double gamma);

  unsigned GetOutputLevel() const noexcept;

  void SetOutputLevel(unsigned output_level);

  unsigned GetCostNormType() const noexcept;

  void SetCostNormType(unsigned cost_norm_type);

  bool GetUseAdaptiveParameters() const noexcept;

  void SetUseAdaptiveParameters(bool adaptive);

  unsigned GetPopulationSize() const noexcept;

  void SetPopulationSize(unsigned pop_size);

  bool GetUserSetPopulationSize() const noexcept;

  unsigned GetRandomSeed() const noexcept;

  void SetRandomSeed(unsigned seed);

  unsigned GetStrategy() const noexcept;

  void SetStrategy(unsigned strategy);

  double GetCrossOver() const noexcept;

  void SetCrossOver(double cross_over);

  double GetWeightingFactor() const noexcept;

  void SetWeightingFactor(double weighting_factor);

  bool GetAddInitialToPopulation() const noexcept;

  void SetAddInitialToPopulation(bool add_initial);

  bool GetUseBroydenUpdates() const noexcept;

  void SetUseBroydenUpdates(bool use_broyden);

  unsigned GetElitism() const noexcept;

  void SetElitism(unsigned elite);

  double GetSurvivalRate() const noexcept;

  void SetSurvivalRate(double rate);

  bool GetUseHardBounds() const noexcept;

  void SetUseHardBounds(bool use_hard_bounds);

  bool GetUserSetPopulation() const noexcept;

  void SetUserSetPopulation(bool has_set_population);

  bool GetUseMultiThreaded() const noexcept;

  void SetUseMultiThreaded(bool use_multi_threaded);

  double GetTemperature() const noexcept;

  void SetTemperature(double temperature);

  double GetStepReductionFactor() const noexcept;

  void SetStepReductionFactor(double step_factor);

  double GetTemperatureReductionFactor() const noexcept;

  void SetTemperatureReductionFactor(double temperature_factor);

  int GetNumberOfCycles() const noexcept;

  void SetNumberOfCycles(int num_cycles);

  int GetNumberOfTemperatureLoops() const noexcept;

  void SetNumberOfTemperatureLoops(int num_temperature_loops);

 private:
  unsigned max_function_evaluations_;
  unsigned max_iterations_;
  unsigned output_level_;
  unsigned cost_norm_type_;
  double cost_tolerance_;
  double degenerate_tolerance_;
  double geometric_tolerance_;
  double alpha_;
  double beta_;
  double delta_;
  double gamma_;
  double epsilon_;
  double tau_;
  bool use_adaptive_;
  unsigned population_size_;
  unsigned seed_;
  unsigned strategy_;
  double weighting_factor_;
  double cross_over_;
  unsigned elitism_;
  double survival_rate_;
  bool user_has_set_population_size_;
  bool user_has_set_population_;
  bool use_broyden_updates_;
  bool add_initial_to_population_;
  bool use_hard_bounds_;
  bool use_multi_threaded_;
  double temperature_;
  double step_reduction_factor_;
  double temperature_reduction_factor_;
  int num_cycles_;
  int num_temperature_loops_;

  static constexpr unsigned default_max_function_evaluations_ = 100000;
  static constexpr unsigned default_max_iterations_ = 10000;
  static constexpr unsigned default_output_level_ = 0;
  static constexpr unsigned default_cost_norm_type_ = 2;
  static constexpr double default_cost_tolerance_ = 1e-12;
  static constexpr double default_degenerate_tolerance_ = 1e-8;
  static constexpr double default_geometric_tolerance_ = 1e-4;
  static constexpr double default_alpha_ = 1.0;
  static constexpr double default_beta_ = 2.0;
  static constexpr double default_delta_ = 0.5;
  static constexpr double default_epsilon_ = 1e-12;
  static constexpr double default_gamma_ = 0.5;
  static constexpr double default_tau_ = 1e-3;
  static constexpr bool default_use_adaptive_ = false;
  static constexpr unsigned default_population_size_ = 20;
  static constexpr unsigned default_seed_ = 0;
  static constexpr unsigned default_strategy_ = 1;
  static constexpr double default_weighting_factor_ = 0.8;
  static constexpr double default_cross_over_ = 0.9;
  static constexpr unsigned default_elitism_ = 1;
  static constexpr double default_survival_rate_ = 0.5;
  static constexpr bool default_user_has_set_population_size_ = false;
  static constexpr bool default_user_has_set_population_ = false;
  static constexpr bool default_use_broyden_updates_ = true;
  static constexpr bool default_add_initial_to_population_ = false;
  static constexpr bool default_use_hard_bounds_ = false;
  static constexpr bool default_use_multi_threaded_ = false;
  static constexpr double default_temperature_ = 1000.0;
  static constexpr double default_step_reduction_factor_ = 0.9;
  static constexpr double default_temperature_reduction_factor_ = 0.5;
  static constexpr int default_num_cycles_ = 20;
  static constexpr int default_num_temperature_loops_ = 5;
};

}  // namespace Unfit

#endif