pow.hpp

/* Copyright 2009-2017 Francesco Biscani (bluescarni@gmail.com)

This file is part of the Piranha library.

The Piranha library is free software; you can redistribute it and/or modify
it under the terms of either:

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any later version.

or

  * the GNU General Public License as published by the Free Software
    Foundation; either version 3 of the License, or (at your option) any
    later version.

or both in parallel, as here.

The Piranha library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the Piranha library.  If not,
see https://www.gnu.org/licenses/. */

#ifndef PIRANHA_POW_HPP
#define PIRANHA_POW_HPP

#include <cmath>
#include <cstddef>
#include <type_traits>
#include <utility>

#include <piranha/mp_integer.hpp>
#include <piranha/type_traits.hpp>

namespace piranha
{

namespace math
{


template <typename T, typename U, typename = void>
struct pow_impl {
};
}

inline namespace impl
{

// Enabler for the pow overload for arithmetic and floating-point types.
template <typename T, typename U>
using pow_fp_arith_enabler
    = enable_if_t<conjunction<std::is_arithmetic<T>, std::is_arithmetic<U>,
                              disjunction<std::is_floating_point<T>, std::is_floating_point<U>>>::value>;
}

namespace math
{


template <typename T, typename U>
struct pow_impl<T, U, pow_fp_arith_enabler<T, U>> {

    auto operator()(const T &x, const U &y) const -> decltype(std::pow(x, y))
    {
        return std::pow(x, y);
    }
};
}

inline namespace impl
{

// Enabler for math::pow().
template <typename T, typename U>
using math_pow_t_ = decltype(math::pow_impl<T, U>{}(std::declval<const T &>(), std::declval<const U &>()));

template <typename T, typename U>
using math_pow_t = enable_if_t<is_returnable<math_pow_t_<T, U>>::value, math_pow_t_<T, U>>;
}

namespace math
{


template <typename T, typename U>
inline math_pow_t<T, U> pow(const T &x, const U &y)
{
    return pow_impl<T, U>{}(x, y);
}
}

inline namespace impl
{

// Enabler for integral power.
template <typename T, typename U>
using integer_pow_enabler
    = enable_if_t<disjunction<conjunction<is_mp_integer<T>, mppp::mppp_impl::is_supported_interop<U>>,
                              conjunction<is_mp_integer<U>, mppp::mppp_impl::is_supported_interop<T>>,
                              conjunction<std::is_integral<T>, std::is_integral<U>>, is_same_mp_integer<T, U>>::value>;

// Wrapper for ADL.
template <typename T, typename U>
inline auto mp_integer_pow_wrapper(const T &base, const U &exp) -> decltype(pow(base, exp))
{
    return pow(base, exp);
}
}

namespace math
{

// NOTE: this specialisation must be here as in the integral-integral overload we use mp_integer inside,
// so the declaration of mp_integer must be avaiable. On the other hand, we cannot put this in mp_integer.hpp
// as the integral-integral overload is supposed to work without including mp_integer.hpp.

template <typename T, typename U>
struct pow_impl<T, U, integer_pow_enabler<T, U>> {
private:
    // C++ integral -- C++ integral.
    template <typename T2, typename U2,
              enable_if_t<conjunction<std::is_integral<T2>, std::is_integral<U2>>::value, int> = 0>
    static integer impl(const T2 &b, const U2 &e)
    {
        return mp_integer_pow_wrapper(integer{b}, e);
    }
    // The other cases.
    template <typename T2, typename U2,
              enable_if_t<negation<conjunction<std::is_integral<T2>, std::is_integral<U2>>>::value, int> = 0>
    static auto impl(const T2 &b, const U2 &e) -> decltype(mp_integer_pow_wrapper(b, e))
    {
        return mp_integer_pow_wrapper(b, e);
    }
    using ret_type = decltype(impl(std::declval<const T &>(), std::declval<const U &>()));

public:

    ret_type operator()(const T &b, const U &e) const
    {
        return impl(b, e);
    }
};
}

inline namespace impl
{

// Type resulting from the application of math::pow().
template <typename Base, typename Expo>
using pow_t = decltype(math::pow(std::declval<const Base &>(), std::declval<const Expo &>()));
}


template <typename T, typename U>
class is_exponentiable
{
    static const bool implementation_defined = is_detected<pow_t, T, U>::value;

public:
    static const bool value = implementation_defined;
};

// Static init.
template <typename T, typename U>
const bool is_exponentiable<T, U>::value;
}

#endif