forwardDifferenceMethod.hpp

Go to the documentation of this file.

// Copyright (c) 2020-2025 Cody R. Drisko. All rights reserved.
// Licensed under the MIT License. See the LICENSE file in the project root for more information.
//
// Name: forwardDifferenceMethod.hpp
// Author: crdrisko
// Date: 11/13/2020-10:53:58
// Description: Approximating the derivative of a function using the forward difference method
 
#ifndef DRYCHEM_COMMON_UTILITIES_INCLUDE_COMMON_UTILS_MATH_CALCULUS_DIFFERENTIATION_FORWARDDIFFERENCEMETHOD_HPP
#define DRYCHEM_COMMON_UTILITIES_INCLUDE_COMMON_UTILS_MATH_CALCULUS_DIFFERENTIATION_FORWARDDIFFERENCEMETHOD_HPP
 
#include <cstddef>
#include <iterator>
#include <type_traits>
#include <vector>
 
#include "common-utils/math/utils/mathExceptions.hpp"
 
namespace CppUtils::Math
{
    template<typename IteratorX, typename IteratorY = IteratorX,
             typename Tx = typename std::iterator_traits<IteratorX>::value_type,
             typename Ty = typename std::iterator_traits<IteratorY>::value_type,
             typename = std::enable_if_t<std::conjunction_v<std::is_default_constructible<Tx>, std::is_default_constructible<Ty>>>>
    constexpr auto forwardDifferenceMethod(IteratorX x_begin, IteratorX x_end, IteratorY y_begin, IteratorY y_end)
    {
        using Ty_x = decltype(*y_begin / *x_begin);
 
        std::ptrdiff_t x_size {x_end - x_begin}, y_size {y_end - y_begin};
 
        if (x_size != y_size)
            throw InputSizeMismatch {"Common-Utilities", __FILE__, __LINE__};
 
        std::vector<Ty_x> dy_dx;
 
        IteratorX x_iter {x_begin};
        IteratorY y_iter {y_begin};
 
        while (x_iter != x_end - 1)
        {
            dy_dx.push_back((*(y_iter + 1) - *y_iter) / (*(x_iter + 1) - *x_iter));
 
            ++x_iter;
            ++y_iter;
        }
 
        return dy_dx;
    }

    template<typename ContainerX, typename ContainerY = ContainerX,
             typename = std::enable_if_t<std::conjunction_v<std::is_default_constructible<typename ContainerX::value_type>,
                                                            std::is_default_constructible<typename ContainerY::value_type>>>>
    constexpr auto forwardDifferenceMethod(const ContainerX& x, const ContainerY& y)
    {
        return forwardDifferenceMethod(x.begin(), x.end(), y.begin(), y.end());
    }
}   // namespace CppUtils::Math
 
#endif