ipow_substitutable_series.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_IPOW_SUBSTITUTABLE_SERIES_HPP
#define PIRANHA_IPOW_SUBSTITUTABLE_SERIES_HPP

#include <string>
#include <type_traits>
#include <utility>

#include <piranha/forwarding.hpp>
#include <piranha/mp_integer.hpp>
#include <piranha/series.hpp>
#include <piranha/symbol_utils.hpp>
#include <piranha/type_traits.hpp>

namespace piranha
{

inline namespace impl
{

struct ipow_substitutable_series_tag {
};
}


template <typename Series, typename Derived>
class ipow_substitutable_series : public Series, ipow_substitutable_series_tag
{
    typedef Series base;
    // Detect subs term.
    template <typename Term, typename T>
    struct subs_term_score {
        static const unsigned value
            = static_cast<unsigned>(has_ipow_subs<typename Term::cf_type, T>::value)
              + (static_cast<unsigned>(key_has_ipow_subs<typename Term::key_type, T>::value) << 1u);
    };
    // Case 1: subs only on cf.
    template <typename T, typename Term>
    using cf_subs_type
        = decltype(math::ipow_subs(std::declval<typename Term::cf_type const &>(), std::declval<std::string const &>(),
                                   std::declval<const integer &>(), std::declval<T const &>()));
    template <typename T, typename Term>
    using ret_type_1 = decltype(std::declval<const cf_subs_type<T, Term> &>() * std::declval<Derived const &>());
    template <typename T, typename Term, typename std::enable_if<subs_term_score<Term, T>::value == 1u, int>::type = 0>
    static ret_type_1<T, Term> subs_term_impl(const Term &t, const symbol_idx &idx, const std::string &name,
                                              const integer &n, const T &x, const symbol_fset &s_set)
    {
        piranha_assert(ss_index_of(s_set, name) == idx);
        (void)idx;
        Derived tmp;
        tmp.set_symbol_set(s_set);
        tmp.insert(Term(typename Term::cf_type(1), t.m_key));
        // NOTE: use moves here in case the multiplication can take advantage.
        return math::ipow_subs(t.m_cf, name, n, x) * std::move(tmp);
    }
    // Case 2: subs only on key.
    template <typename T, typename Term>
    using k_subs_type = typename decltype(std::declval<const typename Term::key_type &>().ipow_subs(
        std::declval<const symbol_idx &>(), std::declval<const integer &>(), std::declval<const T &>(),
        std::declval<const symbol_fset &>()))::value_type::first_type;
    template <typename T, typename Term>
    using ret_type_2_ = decltype(std::declval<Derived const &>() * std::declval<const k_subs_type<T, Term> &>());
    template <typename T, typename Term>
    using ret_type_2 = typename std::enable_if<is_addable_in_place<ret_type_2_<T, Term>>::value
                                                   && std::is_constructible<ret_type_2_<T, Term>, const int &>::value,
                                               ret_type_2_<T, Term>>::type;
    template <typename T, typename Term, typename std::enable_if<subs_term_score<Term, T>::value == 2u, int>::type = 0>
    static ret_type_2<T, Term> subs_term_impl(const Term &t, const symbol_idx &idx, const std::string &name,
                                              const integer &n, const T &x, const symbol_fset &s_set)
    {
        piranha_assert(ss_index_of(s_set, name) == idx);
        (void)name;
        ret_type_2<T, Term> retval(0);
        auto ksubs = t.m_key.ipow_subs(idx, n, x, s_set);
        for (auto &p : ksubs) {
            Derived tmp;
            tmp.set_symbol_set(s_set);
            tmp.insert(Term{t.m_cf, std::move(p.second)});
            // NOTE: possible use of multadd here in the future.
            retval += std::move(tmp) * std::move(p.first);
        }
        return retval;
    }
    // Case 3: subs on cf and key.
    // NOTE: the checks on type 2 are already present in the alias above.
    template <typename T, typename Term>
    using ret_type_3
        = decltype(std::declval<const cf_subs_type<T, Term> &>() * std::declval<const ret_type_2<T, Term> &>());
    template <typename T, typename Term, typename std::enable_if<subs_term_score<Term, T>::value == 3u, int>::type = 0>
    static ret_type_3<T, Term> subs_term_impl(const Term &t, const symbol_idx &idx, const std::string &name,
                                              const integer &n, const T &x, const symbol_fset &s_set)
    {
        piranha_assert(ss_index_of(s_set, name) == idx);
        // Accumulator for the sum below. This is the same type resulting from case 2.
        ret_type_2<T, Term> acc(0);
        auto ksubs = t.m_key.ipow_subs(idx, n, x, s_set);
        auto cf_subs = math::ipow_subs(t.m_cf, name, n, x);
        for (auto &p : ksubs) {
            Derived tmp;
            tmp.set_symbol_set(s_set);
            tmp.insert(Term(typename Term::cf_type(1), std::move(p.second)));
            // NOTE: multadd chance.
            acc += std::move(tmp) * std::move(p.first);
        }
        return std::move(cf_subs) * std::move(acc);
    }
    // Initial definition of the subs type.
    template <typename T>
    using subs_type_ = decltype(subs_term_impl(std::declval<typename Series::term_type const &>(),
                                               std::declval<const symbol_idx &>(), std::declval<const std::string &>(),
                                               std::declval<const integer &>(), std::declval<const T &>(),
                                               std::declval<symbol_fset const &>()));
    // Enable conditionally based on the common requirements in the ipow_subs() method.
    template <typename T>
    using ipow_subs_type = enable_if_t<
        conjunction<std::is_constructible<subs_type_<T>, const int &>, is_addable_in_place<subs_type_<T>>>::value,
        subs_type_<T>>;
    // Enabler for the alternate overload.
    template <typename Int>
    using ipow_subs_int_enabler = enable_if_t<std::is_integral<Int>::value, int>;

public:
    ipow_substitutable_series() = default;
    ipow_substitutable_series(const ipow_substitutable_series &) = default;
    ipow_substitutable_series(ipow_substitutable_series &&) = default;
    PIRANHA_FORWARDING_CTOR(ipow_substitutable_series, base)

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

    ipow_substitutable_series &operator=(ipow_substitutable_series &&other) = default;
    ~ipow_substitutable_series()
    {
        PIRANHA_TT_CHECK(is_series, ipow_substitutable_series);
        PIRANHA_TT_CHECK(is_series, Derived);
        PIRANHA_TT_CHECK(std::is_base_of, ipow_substitutable_series, Derived);
    }
    PIRANHA_FORWARDING_ASSIGNMENT(ipow_substitutable_series, base)

    template <typename T>
    ipow_subs_type<T> ipow_subs(const std::string &name, const integer &n, const T &x) const
    {
        const auto idx = ss_index_of(this->m_symbol_set, name);
        ipow_subs_type<T> retval(0);
        for (const auto &t : this->m_container) {
            retval += subs_term_impl(t, idx, name, n, x, this->m_symbol_set);
        }
        return retval;
    }

    template <typename T, typename Int, ipow_subs_int_enabler<Int> = 0>
    ipow_subs_type<T> ipow_subs(const std::string &name, const Int &n, const T &x) const
    {
        return this->ipow_subs(name, integer(n), x);
    }
};

inline namespace impl
{

// Enabler for the specialisation of ipow_subs functor for ipow_subs series.
template <typename Series, typename T>
using ipow_subs_mem_t = decltype(std::declval<const Series &>().ipow_subs(
    std::declval<const std::string &>(), std::declval<const integer &>(), std::declval<const T &>()));

template <typename Series, typename T>
using ipow_subs_impl_ipow_subs_series_enabler
    = enable_if_t<conjunction<std::is_base_of<ipow_substitutable_series_tag, Series>,
                              is_detected<ipow_subs_mem_t, Series, T>>::value>;
}

namespace math
{


template <typename Series, typename T>
struct ipow_subs_impl<Series, T, ipow_subs_impl_ipow_subs_series_enabler<Series, T>> {

    auto operator()(const Series &s, const std::string &name, const integer &n, const T &x) const
        -> decltype(s.ipow_subs(name, n, x))
    {
        return s.ipow_subs(name, n, x);
    }
};
}
}

#endif