Newton.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <functional>
#include <utility>
 
#include "NumCpp/Core/Types.hpp"
#include "NumCpp/Roots/Iteration.hpp"
 
namespace nc::roots
{
    //================================================================================
    // Class Description:
    class Newton : public Iteration
    {
    public:
        //============================================================================
        // Method Description:
        Newton(const double epsilon, std::function<double(double)> f, std::function<double(double)> fPrime) noexcept :
            Iteration(epsilon),
            f_(std::move(f)),
            fPrime_(std::move(fPrime))
        {
        }
        Newton(const double epsilon, std::function<double(double)> f, std::function<double(double)> fPrime) noexcept : {…}
 
        //============================================================================
        // Method Description:
        Newton(const double                  epsilon,
               const uint32                  maxNumIterations,
               std::function<double(double)> f,
               std::function<double(double)> fPrime) noexcept :
            Iteration(epsilon, maxNumIterations),
            f_(std::move(f)),
            fPrime_(std::move(fPrime))
        {
        }
        Newton(const double                  epsilon, {…}
 
        //============================================================================
        // Method Description:
        ~Newton() noexcept override = default;
 
        //============================================================================
        // Method Description:
        double solve(double x)
        {
            resetNumberOfIterations();
 
            double fx      = f_(x);
            double fxPrime = fPrime_(x);
 
            while (std::fabs(fx) >= epsilon_)
            {
                x = calculateX(x, fx, fxPrime);
 
                fx      = f_(x);
                fxPrime = fPrime_(x);
 
                incrementNumberOfIterations();
            }
 
            return x;
        }
        double solve(double x) {…}
 
    private:
        //============================================================================
        const std::function<double(double)> f_;
        const std::function<double(double)> fPrime_;
 
        //============================================================================
        // Method Description:
        static double calculateX(double x, double fx, double fxPrime) noexcept
        {
            return x - fx / fxPrime;
        }
    };
    class Newton : public Iteration {…};
} // namespace nc::roots