config.hpp

Go to the documentation of this file.

 
#ifndef CONFIG_HPP
#define CONFIG_HPP
 
#include <functional>
#include <libROOT/method.hpp>
 
class ConfigBase {
  public:
    virtual ~ConfigBase() {};
    Method method;                           
    double tolerance;                        
    int max_iterations;                      
    bool aitken;                             
    bool verbose;                            
    std::function<double(double)> function;  
};
 
class BisectionConfig : public ConfigBase {
  public:
    double initial_point;  
    double final_point;    
    BisectionConfig(double tolerance, int max_iterations, bool aitken, std::function<double(double)> function,
                    double initial_point, double final_point, bool verbose) {
        this->tolerance = tolerance;
        this->max_iterations = max_iterations;
        this->aitken = aitken;
        this->function = function;
        this->initial_point = initial_point;
        this->final_point = final_point;
        this->method = Method::BISECTION;
        this->verbose = verbose;
        // validation
        double f_a = function(initial_point);
        double f_b = function(final_point);
        if (f_a * f_b > 0) {
            std::cerr << "033[31Caught error: For Bisection method, function values at initial points must have "
                         "opposite signs.\n";
            std::cerr << "033[31f(" << initial_point << ") = " << f_a << "\n";
            std::cerr << "033[31f(" << final_point << ") = " << f_b << "\n";
            // LLM
            std::exit(EXIT_FAILURE);
        }
    }
};
 
class NewtonConfig : public ConfigBase {
  public:
    double initial_guess;                      
    std::function<double(double)> derivative;  
    NewtonConfig(double tolerance, int max_iterations, bool aitken, std::function<double(double)> function,
                 std::function<double(double)> derivative, double initial_guess, bool verbose) {
        this->tolerance = tolerance;
        this->max_iterations = max_iterations;
        this->aitken = aitken;
        this->function = function;
        this->derivative = derivative;
        this->initial_guess = initial_guess;
        this->method = Method::NEWTON;
        this->verbose = verbose;
    }
};
 
class ChordsConfig : public ConfigBase {
  public:
    double initial_point1;  
    double initial_point2;  
    ChordsConfig(double tolerance, int max_iterations, bool aitken, std::function<double(double)> function,
                 double initial_point, double final_point, bool verbose) {
        this->tolerance = tolerance;
        this->max_iterations = max_iterations;
        this->aitken = aitken;
        this->function = function;
        this->initial_point1 = initial_point;
        this->initial_point2 = final_point;
        this->method = Method::CHORDS;
        this->verbose = verbose;
    }
};
 
class FixedPointConfig : public ConfigBase {
  public:
    double initial_guess;                      
    std::function<double(double)> g_function;  
    FixedPointConfig(double tolerance, int max_iterations, bool aitken, std::function<double(double)> function,
                     double initial_guess, std::function<double(double)> g_function, bool verbose) {
        this->tolerance = tolerance;
        this->max_iterations = max_iterations;
        this->aitken = aitken;
        this->function = function;
        this->initial_guess = initial_guess;
        this->g_function = g_function;
        this->method = Method::FIXED_POINT;
        this->verbose = verbose;
    }
};
 
#endif  // CONFIG_HPP