exp.h

#pragma once

#include <funcy/concepts.h>
#include <funcy/util/chainer.h>

#include <cmath>

namespace funcy
{
    struct Exp : Chainer< Exp >
    {
        explicit Exp( double x = 0. ) noexcept
        {
            update( x );
        }

        void update( double x ) noexcept
        {
            e_x = ::exp( x );
        }

        [[nodiscard]] double d0() const noexcept
        {
            return e_x;
        }

        [[nodiscard]] double d1( double dx = 1. ) const noexcept
        {
            return e_x * dx;
        }

        [[nodiscard]] double d2( double dx = 1., double dy = 1. ) const noexcept
        {
            return e_x * dx * dy;
        }

        [[nodiscard]] double d3( double dx = 1., double dy = 1., double dz = 1. ) const noexcept
        {
            return e_x * dx * dy * dz;
        }

    private:
        double e_x = 1.;
    };

    struct Exp2 : Chainer< Exp2 >
    {
        explicit Exp2( double x = 0. ) noexcept
        {
            update( x );
        }

        void update( double x ) noexcept
        {
            value = exp2( x );
        }

        [[nodiscard]] double d0() const noexcept
        {
            return value;
        }

        [[nodiscard]] double d1( double dx = 1. ) const noexcept
        {
            return value * ln2 * dx;
        }

        [[nodiscard]] double d2( double dx = 1., double dy = 1. ) const noexcept
        {
            return value * ln2 * ln2 * dx * dy;
        }

        [[nodiscard]] double d3( double dx = 1., double dy = 1., double dz = 1. ) const noexcept
        {
            return value * ln2 * ln2 * ln2 * dx * dy * dz;
        }

    private:
        double value = 1., ln2 = log( 2. );
    };

    template < Function F >
    [[nodiscard]] auto exp( const F& f )
    {
        return Exp()( f );
    }

    template < Function F >
    [[nodiscard]] auto exp2( const F& f )
    {
        return Exp2()( f );
    }
} // namespace funcy