kronecker_monomial.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_KRONECKER_MONOMIAL_HPP
#define PIRANHA_KRONECKER_MONOMIAL_HPP

#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <limits>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

#include <piranha/config.hpp>
#include <piranha/detail/cf_mult_impl.hpp>
#include <piranha/detail/km_commons.hpp>
#include <piranha/detail/monomial_common.hpp>
#include <piranha/detail/prepare_for_print.hpp>
#include <piranha/detail/safe_integral_adder.hpp>
#include <piranha/exceptions.hpp>
#include <piranha/is_cf.hpp>
#include <piranha/is_key.hpp>
#include <piranha/kronecker_array.hpp>
#include <piranha/math.hpp>
#include <piranha/mp_integer.hpp>
#include <piranha/mp_rational.hpp>
#include <piranha/pow.hpp>
#include <piranha/s11n.hpp>
#include <piranha/safe_cast.hpp>
#include <piranha/static_vector.hpp>
#include <piranha/symbol_utils.hpp>
#include <piranha/term.hpp>
#include <piranha/type_traits.hpp>

namespace piranha
{

inline namespace impl
{

// Check the size of a k_monomial after deserialization (s1) against the
// size of the reference symbol set (s2).
template <typename T, typename U>
inline void k_monomial_load_check_sizes(T s1, U s2)
{
    static_assert(
        conjunction<std::is_integral<T>, std::is_unsigned<T>, std::is_integral<U>, std::is_unsigned<U>>::value,
        "Type error: this function requires unsigned integral types as input.");
    if (unlikely(s1 != s2)) {
        piranha_throw(std::invalid_argument, "invalid size detected in the deserialization of a Kronercker "
                                             "monomial: the deserialized size ("
                                                 + std::to_string(s1)
                                                 + ") differs from the size of the reference symbol set ("
                                                 + std::to_string(s2) + ")");
    }
}
}


// NOTE:
// - consider abstracting the km_commons in a class and use it both here and in rtkm.
// - it might be better to rework the machinery for the unpacking. An idea is to just use std::vectors
//   with TLS, and have the unpack function take retval as mutable ref rather than returning a vector.
template <typename T = std::make_signed<std::size_t>::type>
class kronecker_monomial
{
public:
    using value_type = T;

private:
    using ka = kronecker_array<T>;

public:

    using size_type = typename ka::size_type;
    // NOTE: this essentially defines a maximum number of small ints that can be packed in m_value,
    // as we always need to pass through pack/unpack. In practice, it does not matter: in current
    // architectures the bit width limit will result in kronecker array's limits to be smaller than
    // 255 items.
    using v_type = static_vector<T, 255u>;
    static const std::size_t multiply_arity = 1u;

    kronecker_monomial() : m_value(0) {}
    kronecker_monomial(const kronecker_monomial &) = default;
    kronecker_monomial(kronecker_monomial &&) = default;

private:
    // Enablers for the ctor from container.
    template <typename U>
    using container_ctor_enabler
        = enable_if_t<conjunction<has_input_begin_end<const U>,
                                  has_safe_cast<T, typename std::iterator_traits<decltype(
                                                       std::begin(std::declval<const U &>()))>::value_type>>::value,
                      int>;
    // Implementation of the ctor from range.
    template <typename Iterator>
    typename v_type::size_type construct_from_range(Iterator begin, Iterator end)
    {
        v_type tmp;
        std::transform(begin, end, std::back_inserter(tmp),
                       [](const uncvref_t<decltype(*begin)> &v) { return safe_cast<T>(v); });
        m_value = ka::encode(tmp);
        return tmp.size();
    }

public:

    template <typename U, container_ctor_enabler<U> = 0>
    explicit kronecker_monomial(const U &c) : kronecker_monomial(std::begin(c), std::end(c))
    {
    }

private:
    template <typename U>
    using init_list_ctor_enabler = container_ctor_enabler<std::initializer_list<U>>;

public:

    template <typename U, init_list_ctor_enabler<U> = 0>
    explicit kronecker_monomial(std::initializer_list<U> list) : kronecker_monomial(list.begin(), list.end())
    {
    }

private:
    template <typename Iterator>
    using it_ctor_enabler
        = enable_if_t<conjunction<is_input_iterator<Iterator>,
                                  has_safe_cast<T, typename std::iterator_traits<Iterator>::value_type>>::value,
                      int>;

public:

    template <typename Iterator, it_ctor_enabler<Iterator> = 0>
    explicit kronecker_monomial(Iterator begin, Iterator end)
    {
        construct_from_range(begin, end);
    }

    template <typename Iterator, it_ctor_enabler<Iterator> = 0>
    explicit kronecker_monomial(Iterator begin, Iterator end, const symbol_fset &s)
    {
        const auto c_size = construct_from_range(begin, end);
        if (unlikely(c_size != s.size())) {
            piranha_throw(std::invalid_argument, "the Kronecker monomial constructor from range and symbol set "
                                                 "yielded an invalid monomial: the range length ("
                                                     + std::to_string(c_size)
                                                     + ") differs from the size of the symbol set ("
                                                     + std::to_string(s.size()) + ")");
        }
    }

    explicit kronecker_monomial(const symbol_fset &) : kronecker_monomial() {}

    explicit kronecker_monomial(const kronecker_monomial &other, const symbol_fset &) : kronecker_monomial(other) {}

    explicit kronecker_monomial(const T &n) : m_value(n) {}
    ~kronecker_monomial()
    {
        PIRANHA_TT_CHECK(is_key, kronecker_monomial);
        PIRANHA_TT_CHECK(key_has_degree, kronecker_monomial);
        PIRANHA_TT_CHECK(key_has_ldegree, kronecker_monomial);
        PIRANHA_TT_CHECK(key_is_differentiable, kronecker_monomial);
    }

    kronecker_monomial &operator=(const kronecker_monomial &other) = default;

    kronecker_monomial &operator=(kronecker_monomial &&other) = default;

    void set_int(const T &n)
    {
        m_value = n;
    }

    T get_int() const
    {
        return m_value;
    }

    bool is_compatible(const symbol_fset &args) const noexcept
    {
        // NOTE: the idea here is to avoid unpack()ing for performance reasons: these checks
        // are already part of unpack(), and that's why unpack() is used instead of is_compatible()
        // in other methods.
        const auto s = args.size();
        // No args means the value must also be zero.
        if (!s) {
            return !m_value;
        }
        const auto &limits = ka::get_limits();
        // If we overflow the maximum size available, we cannot use this object as key in series.
        if (s >= limits.size()) {
            return false;
        }
        const auto &l = limits[static_cast<decltype(limits.size())>(s)];
        // Value is compatible if it is within the bounds for the given size.
        return (m_value >= std::get<1u>(l) && m_value <= std::get<2u>(l));
    }

    bool is_zero(const symbol_fset &) const noexcept
    {
        return false;
    }

    kronecker_monomial merge_symbols(const symbol_idx_fmap<symbol_fset> &ins_map, const symbol_fset &args) const
    {
        return kronecker_monomial(detail::km_merge_symbols<v_type, ka>(ins_map, args, m_value));
    }

    bool is_unitary(const symbol_fset &) const
    {
        // A kronecker code will be zero if all components are zero.
        return !m_value;
    }

private:
    // Degree utils.
    using degree_type = add_t<T, T>;

public:

    degree_type degree(const symbol_fset &args) const
    {
        const auto tmp = unpack(args);
        // NOTE: this should be guaranteed by the unpack function.
        piranha_assert(tmp.size() == args.size());
        degree_type retval(0);
        for (const auto &x : tmp) {
            // NOTE: here it might be possible to demonstrate that overflow can
            // never occur, and that we can use a normal integral addition.
            detail::safe_integral_adder(retval, static_cast<degree_type>(x));
        }
        return retval;
    }

    degree_type ldegree(const symbol_fset &args) const
    {
        return degree(args);
    }

    degree_type degree(const symbol_idx_fset &p, const symbol_fset &args) const
    {
        const auto tmp = unpack(args);
        piranha_assert(tmp.size() == args.size());
        if (unlikely(p.size() && *p.rbegin() >= tmp.size())) {
            piranha_throw(std::invalid_argument, "the largest value in the positions set for the computation of the "
                                                 "partial degree of a Kronecker monomial is "
                                                     + std::to_string(*p.rbegin())
                                                     + ", but the monomial has a size of only "
                                                     + std::to_string(tmp.size()));
        }
        degree_type retval(0);
        for (auto idx : p) {
            detail::safe_integral_adder(retval, static_cast<degree_type>(tmp[static_cast<decltype(tmp.size())>(idx)]));
        }
        return retval;
    }

    degree_type ldegree(const symbol_idx_fset &p, const symbol_fset &args) const
    {
        return degree(p, args);
    }

private:
    // Enabler for multiply().
    template <typename Cf>
    using multiply_enabler = enable_if_t<has_mul3<Cf>::value, int>;

public:

    template <typename Cf, multiply_enabler<Cf> = 0>
    static void multiply(std::array<term<Cf, kronecker_monomial>, multiply_arity> &res,
                         const term<Cf, kronecker_monomial> &t1, const term<Cf, kronecker_monomial> &t2,
                         const symbol_fset &)
    {
        // Coefficient first.
        cf_mult_impl(res[0u].m_cf, t1.m_cf, t2.m_cf);
        // Now the key.
        math::add3(res[0u].m_key.m_value, t1.m_key.get_int(), t2.m_key.get_int());
    }

    std::size_t hash() const
    {
        return static_cast<std::size_t>(m_value);
    }

    bool operator==(const kronecker_monomial &other) const
    {
        return m_value == other.m_value;
    }

    bool operator!=(const kronecker_monomial &other) const
    {
        return !operator==(other);
    }

    std::pair<bool, symbol_idx> is_linear(const symbol_fset &args) const
    {
        const auto v = unpack(args);
        const auto size = v.size();
        decltype(v.size()) n_linear = 0, candidate = 0;
        for (decltype(v.size()) i = 0; i < size; ++i) {
            if (!v[i]) {
                continue;
            }
            if (v[i] != T(1)) {
                return std::make_pair(false, symbol_idx{0});
            }
            candidate = i;
            ++n_linear;
        }
        if (n_linear != 1u) {
            return std::make_pair(false, symbol_idx{0});
        }
        return std::make_pair(true, symbol_idx{candidate});
    }

private:
    // Enabler for pow.
    template <typename U>
    using pow_enabler = monomial_pow_enabler<T, U>;

public:

    template <typename U, pow_enabler<U> = 0>
    kronecker_monomial pow(const U &x, const symbol_fset &args) const
    {
        auto v = unpack(args);
        for (auto &n : v) {
            monomial_pow_mult_exp(n, n, x, monomial_pow_dispatcher<T, U>{});
        }
        return kronecker_monomial(ka::encode(v));
    }

    v_type unpack(const symbol_fset &args) const
    {
        return detail::km_unpack<v_type, ka>(args, m_value);
    }

    void print(std::ostream &os, const symbol_fset &args) const
    {
        const auto tmp = unpack(args);
        piranha_assert(tmp.size() == args.size());
        bool empty_output = true;
        auto it_args = args.begin();
        for (decltype(tmp.size()) i = 0u; i < tmp.size(); ++i, ++it_args) {
            if (tmp[i] != T(0)) {
                if (!empty_output) {
                    os << '*';
                }
                os << *it_args;
                empty_output = false;
                if (tmp[i] != T(1)) {
                    os << "**" << detail::prepare_for_print(tmp[i]);
                }
            }
        }
    }

    void print_tex(std::ostream &os, const symbol_fset &args) const
    {
        const auto tmp = unpack(args);
        std::ostringstream oss_num, oss_den, *cur_oss;
        T cur_value;
        auto it_args = args.begin();
        for (decltype(tmp.size()) i = 0u; i < tmp.size(); ++i, ++it_args) {
            cur_value = tmp[i];
            if (cur_value != T(0)) {
                // NOTE: here negate() is safe because of the symmetry in kronecker_array.
                cur_oss = (cur_value > T(0)) ? &oss_num : (math::negate(cur_value), &oss_den);
                *cur_oss << "{" << *it_args << "}";
                if (cur_value != T(1)) {
                    *cur_oss << "^{" << static_cast<long long>(cur_value) << "}";
                }
            }
        }
        const std::string num_str = oss_num.str(), den_str = oss_den.str();
        if (!num_str.empty() && !den_str.empty()) {
            os << "\\frac{" << num_str << "}{" << den_str << "}";
        } else if (!num_str.empty() && den_str.empty()) {
            os << num_str;
        } else if (num_str.empty() && !den_str.empty()) {
            os << "\\frac{1}{" << den_str << "}";
        }
    }

    std::pair<T, kronecker_monomial> partial(const symbol_idx &p, const symbol_fset &args) const
    {
        auto v = unpack(args);
        if (p >= args.size() || v[static_cast<decltype(v.size())>(p)] == T(0)) {
            // Derivative wrt a variable not in the monomial: the position is outside the bounds, or it refers to a
            // variable with zero exponent.
            return std::make_pair(T(0), kronecker_monomial{args});
        }
        auto v_b = v.begin();
        // The original exponent.
        const T n(v_b[p]);
        // Decrement the exponent in the monomial.
        // NOTE: maybe replace with the safe integral subber, eventually.
        if (unlikely(n == std::numeric_limits<T>::min())) {
            piranha_throw(std::overflow_error, "negative overflow error in the calculation of the "
                                               "partial derivative of a Kronecker monomial");
        }
        v_b[p] = static_cast<T>(n - T(1));
        return std::make_pair(n, kronecker_monomial(ka::encode(v)));
    }

    std::pair<T, kronecker_monomial> integrate(const std::string &s, const symbol_fset &args) const
    {
        const v_type v = unpack(args);
        v_type retval;
        T expo(0);
        auto it_args = args.begin();
        for (decltype(v.size()) i = 0; i < v.size(); ++i, ++it_args) {
            const auto &cur_sym = *it_args;
            if (expo == T(0) && s < cur_sym) {
                // If we went past the position of s in args and still we
                // have not performed the integration, it means that we need to add
                // a new exponent.
                retval.push_back(T(1));
                expo = T(1);
            }
            retval.push_back(v[i]);
            if (cur_sym == s) {
                // NOTE: here using i is safe: if retval gained an extra exponent in the condition above,
                // we are never going to land here as cur_sym is at this point never going to be s.
                if (unlikely(retval[i] == std::numeric_limits<T>::max())) {
                    piranha_throw(
                        std::overflow_error,
                        "positive overflow error in the calculation of the antiderivative of a Kronecker monomial");
                }
                // Do the addition and check for zero later, to detect -1 expo.
                retval[i] = static_cast<T>(retval[i] + T(1));
                if (unlikely(math::is_zero(retval[i]))) {
                    piranha_throw(std::invalid_argument,
                                  "unable to perform Kronecker monomial integration: a negative "
                                  "unitary exponent was encountered in correspondence of the variable '"
                                      + cur_sym + "'");
                }
                expo = retval[i];
            }
        }
        // If expo is still zero, it means we need to add a new exponent at the end.
        if (expo == T(0)) {
            retval.push_back(T(1));
            expo = T(1);
        }
        return std::make_pair(expo, kronecker_monomial(ka::encode(retval)));
    }

private:
    // Determination of the eval type.
    template <typename U>
    using e_type = decltype(math::pow(std::declval<const U &>(), std::declval<const T &>()));
    template <typename U>
    using eval_type = enable_if_t<conjunction<is_multipliable_in_place<e_type<U>>,
                                              std::is_constructible<e_type<U>, int>, is_returnable<e_type<U>>>::value,
                                  e_type<U>>;

public:

    template <typename U>
    eval_type<U> evaluate(const std::vector<U> &values, const symbol_fset &args) const
    {
        // NOTE: here we can check the values size only against args.
        if (unlikely(values.size() != args.size())) {
            piranha_throw(
                std::invalid_argument,
                "invalid vector of values for Kronecker monomial evaluation: the size of the vector of values ("
                    + std::to_string(values.size()) + ") differs from the size of the reference set of symbols ("
                    + std::to_string(args.size()) + ")");
        }
        if (args.size()) {
            const auto v = unpack(args);
            eval_type<U> retval(math::pow(values[0], v[0]));
            for (decltype(v.size()) i = 1; i < v.size(); ++i) {
                // NOTE: here maybe we could use mul3() and pow3() (to be implemented?).
                // NOTE: math::pow() for C++ integrals produces an integer result, no need
                // to worry about overflows.
                retval *= math::pow(values[static_cast<decltype(values.size())>(i)], v[i]);
            }
            return retval;
        }
        return eval_type<U>(1);
    }

private:
    // Subs type is same as eval_type.
    template <typename U>
    using subs_type = eval_type<U>;

public:

    template <typename U>
    std::vector<std::pair<subs_type<U>, kronecker_monomial>> subs(const symbol_idx_fmap<U> &smap,
                                                                  const symbol_fset &args) const
    {
        if (unlikely(smap.size() && smap.rbegin()->first >= args.size())) {
            // The last element of the substitution map must be a valid index into args.
            piranha_throw(
                std::invalid_argument,
                "invalid argument(s) for substitution in a Kronecker monomial: the last index of the substitution map ("
                    + std::to_string(smap.rbegin()->first) + ") must be smaller than the monomial's size ("
                    + std::to_string(args.size()) + ")");
        }
        std::vector<std::pair<subs_type<U>, kronecker_monomial>> retval;
        if (smap.size()) {
            // The substitution map contains something, proceed to the substitution.
            auto v = unpack(args);
            // Init the return value from the exponentiation of the first value in the map.
            auto it = smap.begin();
            auto ret(math::pow(it->second, v[static_cast<decltype(v.size())>(it->first)]));
            // Zero out the corresponding exponent.
            v[static_cast<decltype(v.size())>(it->first)] = T(0);
            // NOTE: move to the next element in the init statement of the for loop.
            for (++it; it != smap.end(); ++it) {
                ret *= math::pow(it->second, v[static_cast<decltype(v.size())>(it->first)]);
                v[static_cast<decltype(v.size())>(it->first)] = T(0);
            }
            // NOTE: the is_returnable requirement ensures we can emplace back a pair
            // containing the subs type.
            retval.emplace_back(std::move(ret), kronecker_monomial(ka::encode(v)));
        } else {
            // Otherwise, the substitution yields 1 and the monomial is the original one.
            retval.emplace_back(subs_type<U>(1), *this);
        }
        return retval;
    }

private:
    // ipow subs utilities.
    template <typename U>
    using ips_type = decltype(math::pow(std::declval<const U &>(), std::declval<const integer &>()));
    template <typename U>
    using ipow_subs_type
        = enable_if_t<conjunction<std::is_constructible<ips_type<U>, int>, is_returnable<ips_type<U>>>::value,
                      ips_type<U>>;

public:

    template <typename U>
    std::vector<std::pair<ipow_subs_type<U>, kronecker_monomial>> ipow_subs(const symbol_idx &p, const integer &n,
                                                                            const U &x, const symbol_fset &args) const
    {
        if (unlikely(!n.sgn())) {
            piranha_throw(std::invalid_argument,
                          "invalid integral power for ipow_subs() in a Kronecker monomial: the power must be nonzero");
        }
        std::vector<std::pair<ipow_subs_type<U>, kronecker_monomial>> retval;
        if (p < args.size()) {
            PIRANHA_MAYBE_TLS integer q, r, d;
            auto v = unpack(args);
            d = v[static_cast<decltype(v.size())>(p)];
            // NOTE: regarding the sign of r: tdiv_qr() sets the sign of r to the sign of q.
            // The only two cases we are interested in here are where d and n have the same sign
            // (otherwise q will have negative sign and we never enter the 'if' below). With
            // d and n positive, everything is straightforward (r's sign will be positive).
            // If d and n are both negative, r will have negative sign, and it will satisfy:
            // q*n + r == d (with d < 0 and d < q*n)
            // This is the result we want: r is the number of steps towards -inf that q*n
            // must take to reach d.
            tdiv_qr(q, r, d, n);
            if (q.sgn() > 0) {
                v[static_cast<decltype(v.size())>(p)] = static_cast<T>(r);
                retval.emplace_back(math::pow(x, q), kronecker_monomial(ka::encode(v)));
                return retval;
            }
        }
        // Otherwise, the substitution yields 1 and the monomial is the original one.
        retval.emplace_back(ipow_subs_type<U>(1), *this);
        return retval;
    }

    void trim_identify(std::vector<char> &trim_mask, const symbol_fset &args) const
    {
        detail::km_trim_identify<v_type, ka>(trim_mask, args, m_value);
    }

    kronecker_monomial trim(const std::vector<char> &trim_mask, const symbol_fset &args) const
    {
        return kronecker_monomial(detail::km_trim<v_type, ka>(trim_mask, args, m_value));
    }

    bool operator<(const kronecker_monomial &other) const
    {
        return m_value < other.m_value;
    }

#if defined(PIRANHA_WITH_MSGPACK)
private:
    // Enablers for msgpack serialization.
    template <typename Stream>
    using msgpack_pack_enabler = enable_if_t<
        conjunction<is_msgpack_stream<Stream>, has_msgpack_pack<Stream, T>, has_msgpack_pack<Stream, v_type>>::value,
        int>;
    template <typename U>
    using msgpack_convert_enabler = enable_if_t<
        conjunction<has_msgpack_convert<typename U::value_type>, has_msgpack_convert<typename U::v_type>>::value, int>;

public:

    template <typename Stream, msgpack_pack_enabler<Stream> = 0>
    void msgpack_pack(msgpack::packer<Stream> &packer, msgpack_format f, const symbol_fset &s) const
    {
        if (f == msgpack_format::binary) {
            piranha::msgpack_pack(packer, m_value, f);
        } else {
            auto tmp = unpack(s);
            piranha::msgpack_pack(packer, tmp, f);
        }
    }

    template <typename U = kronecker_monomial, msgpack_convert_enabler<U> = 0>
    void msgpack_convert(const msgpack::object &o, msgpack_format f, const symbol_fset &s)
    {
        if (f == msgpack_format::binary) {
            piranha::msgpack_convert(m_value, o, f);
        } else {
            v_type tmp;
            piranha::msgpack_convert(tmp, o, f);
            k_monomial_load_check_sizes(tmp.size(), s.size());
            *this = kronecker_monomial(tmp);
        }
    }
#endif

private:
    T m_value;
};

using k_monomial = kronecker_monomial<>;
}

// Implementation of the Boost s11n api.
namespace boost
{
namespace serialization
{

template <typename Archive, typename T>
inline void save(Archive &ar, const piranha::boost_s11n_key_wrapper<piranha::kronecker_monomial<T>> &k, unsigned)
{
    if (std::is_same<Archive, boost::archive::binary_oarchive>::value) {
        piranha::boost_save(ar, k.key().get_int());
    } else {
        auto tmp = k.key().unpack(k.ss());
        piranha::boost_save(ar, tmp);
    }
}

template <typename Archive, typename T>
inline void load(Archive &ar, piranha::boost_s11n_key_wrapper<piranha::kronecker_monomial<T>> &k, unsigned)
{
    if (std::is_same<Archive, boost::archive::binary_iarchive>::value) {
        T value;
        piranha::boost_load(ar, value);
        k.key().set_int(value);
    } else {
        typename piranha::kronecker_monomial<T>::v_type tmp;
        piranha::boost_load(ar, tmp);
        piranha::k_monomial_load_check_sizes(tmp.size(), k.ss().size());
        k.key() = piranha::kronecker_monomial<T>(tmp);
    }
}

template <typename Archive, typename T>
inline void serialize(Archive &ar, piranha::boost_s11n_key_wrapper<piranha::kronecker_monomial<T>> &k, unsigned version)
{
    split_free(ar, k, version);
}
}
}

namespace piranha
{

inline namespace impl
{

template <typename Archive, typename T>
using k_monomial_boost_save_enabler = enable_if_t<
    conjunction<has_boost_save<Archive, T>, has_boost_save<Archive, typename kronecker_monomial<T>::v_type>>::value>;

template <typename Archive, typename T>
using k_monomial_boost_load_enabler = enable_if_t<
    conjunction<has_boost_load<Archive, T>, has_boost_load<Archive, typename kronecker_monomial<T>::v_type>>::value>;
}


template <typename Archive, typename T>
struct boost_save_impl<Archive, boost_s11n_key_wrapper<kronecker_monomial<T>>,
                       k_monomial_boost_save_enabler<Archive, T>>
    : boost_save_via_boost_api<Archive, boost_s11n_key_wrapper<kronecker_monomial<T>>> {
};


template <typename Archive, typename T>
struct boost_load_impl<Archive, boost_s11n_key_wrapper<kronecker_monomial<T>>,
                       k_monomial_boost_load_enabler<Archive, T>>
    : boost_load_via_boost_api<Archive, boost_s11n_key_wrapper<kronecker_monomial<T>>> {
};
}

namespace std
{

template <typename T>
struct hash<piranha::kronecker_monomial<T>> {
    using result_type = size_t;
    using argument_type = piranha::kronecker_monomial<T>;

    result_type operator()(const argument_type &a) const
    {
        return a.hash();
    }
};
}

#endif