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_SUBSTITUTABLE_SERIES_HPP
#define PIRANHA_SUBSTITUTABLE_SERIES_HPP

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

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

namespace piranha
{

namespace detail
{

// Tag for the subs toolbox.
struct substitutable_series_tag {
};
}


template <typename Series, typename Derived>
class substitutable_series : public Series, detail::substitutable_series_tag
{
    typedef Series base;
    // Detect subs term.
    template <typename Term, typename T>
    using subs_term_score
        = std::integral_constant<unsigned,
                                 static_cast<unsigned>(has_subs<typename Term::cf_type, T>::value)
                                     + (static_cast<unsigned>(key_has_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::subs(std::declval<typename Term::cf_type const &>(), std::declval<const symbol_fmap<T> &>()));
    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, enable_if_t<subs_term_score<Term, T>::value == 1u, int> = 0>
    static ret_type_1<T, Term> subs_term_impl(const Term &t, const symbol_fmap<T> &dict, const symbol_idx_fmap<T> &,
                                              const symbol_fset &s_set)
    {
        // NOTE: in these functions we could probably have optimised implementations, like in series'
        // partial, that use term insertion instead of arithmetics if the types allow it.
        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::subs(t.m_cf, dict) * 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 &>().subs(
        std::declval<const symbol_idx_fmap<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 = enable_if_t<conjunction<is_addable_in_place<ret_type_2_<T, Term>>,
                                               std::is_constructible<ret_type_2_<T, Term>, const int &>>::value,
                                   ret_type_2_<T, Term>>;
    template <typename T, typename Term, enable_if_t<subs_term_score<Term, T>::value == 2u, int> = 0>
    static ret_type_2<T, Term> subs_term_impl(const Term &t, const symbol_fmap<T> &, const symbol_idx_fmap<T> &idx,
                                              const symbol_fset &s_set)
    {
        ret_type_2<T, Term> retval(0);
        auto ksubs = t.m_key.subs(idx, 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, enable_if_t<subs_term_score<Term, T>::value == 3u, int> = 0>
    static ret_type_3<T, Term> subs_term_impl(const Term &t, const symbol_fmap<T> &dict, const symbol_idx_fmap<T> &idx,
                                              const symbol_fset &s_set)
    {
        // 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.subs(idx, s_set);
        auto cf_subs = math::subs(t.m_cf, dict);
        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_fmap<T> &>(),
                       std::declval<const symbol_idx_fmap<T> &>(), std::declval<symbol_fset const &>()));
    // Enable conditionally based on the common requirements in the subs() method, plus on the fact that
    // the subs type must be returnable.
    // NOTE: the returnable check here should be enough, as the functions above will not be called if the check
    // here is not passed.
    template <typename T>
    using subs_type
        = enable_if_t<conjunction<std::is_constructible<subs_type_<T>, const int &>, is_addable_in_place<subs_type_<T>>,
                                  is_returnable<subs_type_<T>>, has_sm_intersect_idx<T>>::value,
                      subs_type_<T>>;

public:
    substitutable_series() = default;
    substitutable_series(const substitutable_series &) = default;
    substitutable_series(substitutable_series &&) = default;
    PIRANHA_FORWARDING_CTOR(substitutable_series, base)
    ~substitutable_series()
    {
        PIRANHA_TT_CHECK(is_series, substitutable_series);
        PIRANHA_TT_CHECK(is_series, Derived);
        PIRANHA_TT_CHECK(std::is_base_of, substitutable_series, Derived);
    }

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

    substitutable_series &operator=(substitutable_series &&other) = default;
    PIRANHA_FORWARDING_ASSIGNMENT(substitutable_series, base)

    template <typename T>
    subs_type<T> subs(const symbol_fmap<T> &dict) const
    {
        const auto idx = sm_intersect_idx(this->m_symbol_set, dict);
        subs_type<T> retval(0);
        for (const auto &t : this->m_container) {
            retval += subs_term_impl(t, dict, idx, this->m_symbol_set);
        }
        return retval;
    }
};

namespace detail
{

// Enabler for the specialisation of subs functor for subs series.
template <typename Series, typename T>
using subs_impl_subs_series_enabler = enable_if_t<conjunction<
    std::is_base_of<substitutable_series_tag, Series>,
    is_returnable<decltype(std::declval<const Series &>().subs(std::declval<const symbol_fmap<T> &>()))>>::value>;
}

namespace math
{


template <typename Series, typename T>
struct subs_impl<Series, T, detail::subs_impl_subs_series_enabler<Series, T>> {

    auto operator()(const Series &s, const symbol_fmap<T> &dict) const -> decltype(s.subs(dict))
    {
        return s.subs(dict);
    }
};
}
}

#endif