Constexpr sine, C++ (clang)

Language: Layout:

#include <type_traits>
#include <cstdlib>
#include <cmath>
#include <cstdint>

namespace math{

template<class T,class dcy = std::decay_t<T>>
    constexpr inline std::enable_if_t<std::is_floating_point<T>::value,dcy> inverse(T value){
        return (value == 0) ? 0.0 : 1.0 / value;
    }
    template <class T>
    constexpr inline std::decay_t<T> sign(T value) {
        return value < 0 ? -1 : 1;
    }
    template <typename T>
    constexpr inline std::decay_t<T> abs(T value) {
        return value * sign(value);
    }
    template<class T>
    constexpr inline std::decay_t<T> power(T const& base, std::size_t const& pow){
        if(pow==0){return 1;}
        else if(pow == 1){return base;}
        else{
            T result = base;
            for(std::size_t i=1;i<pow;++i){
                result*=base;
            }
            return result;
        }
    }
    constexpr std::intmax_t factorial(std::intmax_t const& n){
        if(n==0){return 1;}
        std::intmax_t result = n;
        for(std::intmax_t i=n-1;i>0;--i){
            result *=i;
        }
        return result;
    }
    constexpr static std::size_t max_factorial = 10;//replace with calculated version later
}

#include<array>
#include<type_traits>

namespace math{
    namespace detail{

template<std::size_t... Is> struct seq{};

template<std::size_t N, std::size_t... Is>
        struct gen_seq: gen_seq<N-1, N, Is...> {};

template<std::size_t... Is>
        struct gen_seq<0, Is...> : seq<Is...>{};

template<class T,std::size_t N>
        struct sin_coeffs{
            using array_type = std::array<T,N>;
            constexpr static inline T coeff(std::size_t n){
                return (n%2 ? 1 : -1) * inverse((T)factorial((2 * n)-1));
            }
            template<std::size_t...NS>
            constexpr static array_type _coeffs(seq<NS...>){
                return {{coeff(NS)...}};
            }
            constexpr static array_type coeffs=_coeffs(gen_seq<N>{});
        };
    }

template<class T,std::size_t N = max_factorial, class dcy = std::decay_t<T>>
    constexpr std::enable_if_t<std::is_floating_point<dcy>::value,dcy> sin(T x) noexcept{
        constexpr const std::array<dcy,N>& coeffs = detail::sin_coeffs<dcy,N>::coeffs;
        const dcy x_2 = x*x;
        dcy pow = x;
        dcy result = 0;
        for(std::size_t i=0;i<N;++i){
            result += coeffs[i] * pow;
            pow*=x_2;
        }
        return result;
    }
}

#include <iostream>
#include <iomanip>

int main()
{
    constexpr double d0 = math::sin(0.0);
  	constexpr double d1 = math::sin(1.0);
    constexpr double d2 = math::sin(2.0);
    constexpr double d3 = math::sin(M_PI / 2.0);
    std::cout << std::setprecision(8) << d0 << ", " << d1 << ", " << d2 << ", " << d3 << std::endl;
  	auto arr = math::detail::sin_coeffs<double, 10>::coeffs;
  	for (auto x: arr) {
  		std::cout << x << " ";
  	}
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.62 sec, absolute running time: 0.14 sec, cpu time: 0 sec, memory peak: 3 Mb, absolute service time: 0,77 sec