RootFind1dBase.h

// Base class for all 1-D Root finding classes
#pragma once
 
#include <functional>
#include <optional>
 
#include <isce3/core/Poly1d.h>
#include <isce3/except/Error.h>
 
namespace isce3 { namespace math { namespace detail {

class RootFind1dBase {
 
public:
    // constructors
    RootFind1dBase(double f_tol = 1e-5, int max_iter = 20,
            std::optional<double> x_tol = {})
        : f_tol {f_tol}, max_iter {max_iter}, x_tol {x_tol}
    {
        if (max_iter < 1)
            throw isce3::except::InvalidArgument(
                    ISCE_SRCINFO(), "Max number of iterations must be >=1!");
        if (!(f_tol > 0.0))
            throw isce3::except::InvalidArgument(ISCE_SRCINFO(),
                    "Tolerance for function value must be positive!");
        if (x_tol)
            if (!(*x_tol > 0.0))
                throw isce3::except::InvalidArgument(ISCE_SRCINFO(),
                        "Tolerance for function variable must be positive!");
    }

    RootFind1dBase(int max_iter) : RootFind1dBase(1e-5, max_iter, {}) {}
 
    // Abstract virtual method needed  by all derived class
    // virtual std::tuple<double, double, bool, int> root(arg, ...) const = 0;
 
    // non-virtual public methods

    double func_tol() const { return f_tol; }

    int max_num_iter() const { return max_iter; }

    std::optional<double> var_tol() const
    {
        return x_tol ? *x_tol : std::optional<double> {};
    }

    static std::function<double(double)> poly2func(const isce3::core::Poly1d& f)
    {
        return [=](double x) { return f.eval(x); };
    }
 
    // members
protected:
    double f_tol;
    int max_iter;
    std::optional<double> x_tol;
};
 
}}} // namespace isce3::math::detail