lambdify.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_LAMBDIFY_HPP
#define PIRANHA_LAMBDIFY_HPP

#include <algorithm>
#include <functional>
#include <initializer_list>
#include <iterator>
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>

#include <piranha/detail/sfinae_types.hpp>
#include <piranha/exceptions.hpp>
#include <piranha/math.hpp>
#include <piranha/symbol_utils.hpp>
#include <piranha/type_traits.hpp>

namespace piranha
{

namespace detail
{

// Requirements for the lambdified template parameters (after decay).
template <typename T, typename U>
using math_lambdified_reqs = std::integral_constant<
    bool, conjunction<is_evaluable<T, U>, std::is_copy_constructible<T>, std::is_move_constructible<T>>::value>;
}

namespace math
{


template <typename T, typename U>
class lambdified
{
    static_assert(std::is_same<T, typename std::decay<T>::type>::value, "Invalid type.");
    static_assert(std::is_same<U, typename std::decay<U>::type>::value, "Invalid type.");
    static_assert(detail::math_lambdified_reqs<T, U>::value, "Invalid types.");
    // Constructor implementation.
    void construct()
    {
        // Check if there are duplicates.
        auto names_copy(m_names);
        std::sort(names_copy.begin(), names_copy.end());
        if (std::unique(names_copy.begin(), names_copy.end()) != names_copy.end()) {
            piranha_throw(std::invalid_argument, "the list of evaluation symbols contains duplicates");
        }
        // Fill in the eval dict and the vector of pointers, and make sure
        // that m_extra_map does not contain anything that is already in m_names.
        for (const auto &s : m_names) {
            if (m_extra_map.find(s) != m_extra_map.end()) {
                piranha_throw(std::invalid_argument,
                              "the extra symbols map contains symbol '" + s
                                  + "', which is already in the symbol list used for the construction "
                                    "of the lambdified object");
            }
            const auto ret = m_eval_dict.emplace(std::make_pair(s, U{}));
            piranha_assert(ret.second);
            m_ptrs.push_back(std::addressof(ret.first->second));
        }
        // Fill in the extra symbols.
        for (const auto &p : m_extra_map) {
            const auto ret = m_eval_dict.emplace(std::make_pair(p.first, U{}));
            piranha_assert(ret.second);
            m_ptrs.push_back(std::addressof(ret.first->second));
        }
    }
    // Reconstruct the vector of pointers following copy or move construction.
    void reconstruct_ptrs()
    {
        // m_ptrs must be empty because we assume this method is called only as part of
        // the copy/move ctors.
        piranha_assert(m_ptrs.empty());
        piranha_assert(m_eval_dict.size() >= m_extra_map.size()
                       && m_names.size() == m_eval_dict.size() - m_extra_map.size());
        // Take care first of the positional argument.
        for (const auto &s : m_names) {
            piranha_assert(m_eval_dict.count(s) == 1u);
            m_ptrs.push_back(std::addressof(m_eval_dict.find(s)->second));
        }
        // The extra symbols.
        for (const auto &p : m_extra_map) {
            piranha_assert(m_eval_dict.count(p.first) == 1u);
            m_ptrs.push_back(std::addressof(m_eval_dict.find(p.first)->second));
        }
        // Make sure the sizes are consistent.
        piranha_assert(m_ptrs.size() == static_cast<decltype(m_ptrs.size())>(m_names.size()) + m_extra_map.size());
    }

public:

    using eval_type = decltype(math::evaluate(std::declval<const T &>(), std::declval<const symbol_fmap<U> &>()));

    using extra_map_type = std::unordered_map<std::string, std::function<U(const std::vector<U> &)>>;

    explicit lambdified(const T &x, const std::vector<std::string> &names, extra_map_type extra_map = {})
        : m_x(x), m_names(names), m_extra_map(extra_map)
    {
        construct();
    }

    explicit lambdified(T &&x, const std::vector<std::string> &names, extra_map_type extra_map = {})
        : m_x(std::move(x)), m_names(names), m_extra_map(extra_map)
    {
        construct();
    }

    lambdified(const lambdified &other)
        : m_x(other.m_x), m_names(other.m_names), m_eval_dict(other.m_eval_dict), m_extra_map(other.m_extra_map)
    {
        reconstruct_ptrs();
    }

    lambdified(lambdified &&other)
        : m_x(std::move(other.m_x)), m_names(std::move(other.m_names)), m_eval_dict(std::move(other.m_eval_dict)),
          m_extra_map(std::move(other.m_extra_map))
    {
        // NOTE: it looks like we cannot be sure the moved-in pointers are still valid.
        // Let's just make sure.
        reconstruct_ptrs();
    }

private:
    lambdified &operator=(const lambdified &) = delete;
    lambdified &operator=(lambdified &&) = delete;

public:

    eval_type operator()(const std::vector<U> &values)
    {
        if (unlikely(values.size() != m_eval_dict.size() - m_extra_map.size())) {
            piranha_throw(std::invalid_argument, "the size of the vector of evaluation values does not "
                                                 "match the size of the symbol list used during construction");
        }
        piranha_assert(values.size() == m_names.size());
        decltype(values.size()) i = 0u;
        for (; i < values.size(); ++i) {
            auto ptr = m_ptrs[static_cast<decltype(m_ptrs.size())>(i)];
            piranha_assert(
                ptr == std::addressof(m_eval_dict.find(m_names[static_cast<decltype(m_names.size())>(i)])->second));
            *ptr = values[i];
        }
        // NOTE: here it is crucial that the iteration order on m_extra_map is the same
        // as it was during the construction of the m_ptrs vector, otherwise we are associating
        // values to the wrong symbols. Luckily, it seems like iterating on a const unordered_map
        // multiple times yields the same order:
        // http://stackoverflow.com/questions/18301302/is-forauto-i-unordered-map-guaranteed-to-have-the-same-order-every-time
        // https://groups.google.com/a/isocpp.org/forum/#!topic/std-discussion/kHYFUhsauhU
        for (const auto &p : m_extra_map) {
            piranha_assert(i < m_ptrs.size());
            auto ptr = m_ptrs[static_cast<decltype(m_ptrs.size())>(i)];
            piranha_assert(ptr == std::addressof(m_eval_dict.find(p.first)->second));
            *ptr = p.second(values);
            ++i;
        }
        // NOTE: of course, this will have to be fixed in the rewrite.
        return math::evaluate(m_x, symbol_fmap<U>{m_eval_dict.begin(), m_eval_dict.end()});
    }

    const T &get_evaluable() const
    {
        return m_x;
    }

    const std::vector<std::string> &get_names() const
    {
        return m_names;
    }

    std::vector<std::string> get_extra_names() const
    {
        std::vector<std::string> retval;
        std::transform(m_extra_map.begin(), m_extra_map.end(), std::back_inserter(retval),
                       [](const typename extra_map_type::value_type &p) { return p.first; });
        return retval;
    }

private:
    T m_x;
    std::vector<std::string> m_names;
    std::unordered_map<std::string, U> m_eval_dict;
    std::vector<U *> m_ptrs;
    extra_map_type m_extra_map;
};
}

namespace detail
{

// Enabler for lambdify().
template <typename T, typename U>
using math_lambdify_type =
    typename std::enable_if<math_lambdified_reqs<typename std::decay<T>::type, typename std::decay<U>::type>::value,
                            math::lambdified<typename std::decay<T>::type, typename std::decay<U>::type>>::type;

// Shortcut for the extra symbols map type.
template <typename T, typename U>
using math_lambdify_extra_map_type = typename math_lambdify_type<T, U>::extra_map_type;
}

namespace math
{


template <typename U, typename T>
inline detail::math_lambdify_type<T, U> lambdify(T &&x, const std::vector<std::string> &names,
                                                 detail::math_lambdify_extra_map_type<T, U> extra_map = {})
{
    return lambdified<typename std::decay<T>::type, typename std::decay<U>::type>(std::forward<T>(x), names, extra_map);
}
}


template <typename T, typename U>
class has_lambdify : detail::sfinae_types
{
    using Td = typename std::decay<T>::type;
    using Ud = typename std::decay<U>::type;
    template <typename T1, typename U1>
    static auto test(const T1 &x, const U1 &) -> decltype(math::lambdify<U1>(x, {}), void(), yes());
    static no test(...);
    static const bool implementation_defined
        = std::is_same<yes, decltype(test(std::declval<const Td &>(), std::declval<const Ud &>()))>::value;

public:
    static const bool value = implementation_defined;
};

template <typename T, typename U>
const bool has_lambdify<T, U>::value;
}

#endif