expression.h

Go to the documentation of this file.

 
#ifndef SYMENGINE_EXPRESSION_H
#define SYMENGINE_EXPRESSION_H
 
#include <symengine/add.h>
#include <symengine/pow.h>
#include <symengine/symbol.h>
#include <symengine/complex_double.h>
#include <symengine/eval_double.h>
#include <symengine/printers.h>
 
namespace SymEngine
{
 
// Forward declare these here to avoid including derivative.h and break the
// cycle
SYMENGINE_EXPORT
RCP<const Basic> diff(const RCP<const Basic> &arg, const RCP<const Symbol> &x,
                      bool cache);
 
SYMENGINE_EXPORT
RCP<const Basic> sdiff(const RCP<const Basic> &arg, const RCP<const Basic> &x,
                       bool cache);
 
class SYMENGINE_EXPORT Expression
{
private:
    RCP<const Basic> m_basic;
 
public:
    Expression() : m_basic(integer(0)) {}
    template <class T>
    Expression(
        T n,
        typename std::enable_if<std::is_integral<T>::value>::type * = nullptr)
        : m_basic(integer(n))
    {
    }
    template <class T>
    Expression(T n,
               typename std::enable_if<std::is_floating_point<T>::value>::type
                   * = nullptr)
        : m_basic(real_double(n))
    {
    }
    template <class T>
    Expression(std::complex<T> n,
               typename std::enable_if<std::is_floating_point<T>::value>::type
                   * = nullptr)
        : m_basic(complex_double(n))
    {
    }
 
    Expression(const integer_class &n) : m_basic(integer(n)) {}
 
    Expression(const rational_class &n) : m_basic(Rational::from_mpq(n)) {}
 
    Expression(RCP<const Basic> &&o) : m_basic(o) {}
 
    Expression(const RCP<const Basic> &o) : m_basic(o) {}
 
    Expression(const std::string &s);
 
    Expression(const Expression &) = default;
    Expression(Expression &&other) SYMENGINE_NOEXCEPT
        : m_basic(std::move(other.m_basic))
    {
    }
    Expression &operator=(const Expression &) = default;
    Expression &operator=(Expression &&other) SYMENGINE_NOEXCEPT
    {
        if (this != &other) {
            this->m_basic = std::move(other.m_basic);
        }
        return *this;
    }
    virtual ~Expression() SYMENGINE_NOEXCEPT {}
    friend std::ostream &operator<<(std::ostream &os, const Expression &expr)
    {
        os << expr.m_basic->__str__();
        return os;
    }
    friend Expression operator+(const Expression &a, const Expression &b)
    {
        return Expression(add(a.m_basic, b.m_basic));
    }
    friend Expression operator+(const RCP<const Basic> &a, const Expression &b)
    {
        return Expression(add(a, b.m_basic));
    }
    friend Expression operator+(const Expression &a, const RCP<const Basic> &b)
    {
        return Expression(add(a.m_basic, b));
    }
    Expression &operator+=(const Expression &other)
    {
        m_basic = add(m_basic, other.m_basic);
        return *this;
    }
    Expression &operator+=(const RCP<const Basic> &other)
    {
        m_basic = add(m_basic, other);
        return *this;
    }
    friend Expression operator-(const Expression &a, const Expression &b)
    {
        return Expression(sub(a.m_basic, b.m_basic));
    }
    friend Expression operator-(const RCP<const Basic> &a, const Expression &b)
    {
        return Expression(sub(a, b.m_basic));
    }
    friend Expression operator-(const Expression &a, const RCP<const Basic> &b)
    {
        return Expression(sub(a.m_basic, b));
    }
    operator const RCP<const Basic> &() const
    {
        return m_basic;
    }
    Expression diff(const RCP<const Symbol> &x, bool cache = true) const
    {
        return Expression(SymEngine::diff(m_basic, x, cache));
    }
    Expression diff(const RCP<const Basic> &x, bool cache = true) const
    {
        return Expression(sdiff(m_basic, x, cache));
    }
    Expression subs(const map_basic_basic &subs_map) const
    {
        return Expression(m_basic->subs(subs_map));
    }
    template <typename T,
              typename
              = typename std::enable_if<std::is_arithmetic<T>::value>::type>
    explicit operator T() const
    {
        return T(eval_double(*get_basic()));
    }
    template <typename T,
              typename
              = typename std::enable_if<std::is_arithmetic<T>::value>::type>
    explicit operator std::complex<T>() const
    {
        return std::complex<T>(eval_complex_double(*get_basic()));
    }
    operator const Basic &() const
    {
        return *m_basic;
    }
    Expression operator-() const
    {
        Expression retval(*this);
        retval *= -1;
        return retval;
    }
    Expression &operator-=(const Expression &other)
    {
        m_basic = sub(m_basic, other.m_basic);
        return *this;
    }
    Expression &operator-=(const RCP<const Basic> &other)
    {
        m_basic = sub(m_basic, other);
        return *this;
    }
    friend Expression operator*(const Expression &a, const Expression &b)
    {
        return Expression(mul(a.m_basic, b.m_basic));
    }
    friend Expression operator*(const RCP<const Basic> &a, const Expression &b)
    {
        return Expression(mul(a, b.m_basic));
    }
    friend Expression operator*(const Expression &a, const RCP<const Basic> &b)
    {
        return Expression(mul(a.m_basic, b));
    }
    Expression &operator*=(const Expression &other)
    {
        m_basic = mul(m_basic, other.m_basic);
        return *this;
    }
    Expression &operator*=(const RCP<const Basic> &other)
    {
        m_basic = mul(m_basic, other);
        return *this;
    }
    friend Expression operator/(const Expression &a, const Expression &b)
    {
        return Expression(div(a.m_basic, b.m_basic));
    }
    friend Expression operator/(const RCP<const Basic> &a, const Expression &b)
    {
        return Expression(div(a, b.m_basic));
    }
    friend Expression operator/(const Expression &a, const RCP<const Basic> &b)
    {
        return Expression(div(a.m_basic, b));
    }
    Expression &operator/=(const Expression &other)
    {
        m_basic = div(m_basic, other.m_basic);
        return *this;
    }
    Expression &operator/=(const RCP<const Basic> &other)
    {
        m_basic = div(m_basic, other);
        return *this;
    }
    bool operator==(const Expression &other) const
    {
        return eq(*m_basic, *other.m_basic);
    }
    bool operator==(const RCP<const Basic> &other) const
    {
        return eq(*m_basic, *other);
    }
 
    bool operator!=(const Expression &other) const
    {
        return not(*this == other);
    }
    bool operator!=(const RCP<const Basic> &other) const
    {
        return not(*this == other);
    }
 
    const RCP<const Basic> &get_basic() const
    {
        return m_basic;
    }
};
 
inline Expression pow(const Expression &base, const Expression &exp)
{
    return pow(base.get_basic(), exp.get_basic());
}
 
inline void mp_pow_ui(Expression &res, const Expression &base,
                      unsigned long exp)
{
    res = pow(base, Expression(integer(static_cast<signed long>(exp))));
}
 
inline Expression expand(const Expression &arg)
{
    return expand(arg.get_basic());
}
 
inline bool unified_eq(const Expression &a, const Expression &b)
{
    return a == b;
}
 
inline int unified_compare(const Expression &a, const Expression &b)
{
    return unified_compare(a.get_basic(), b.get_basic());
}
 
// Utility functions for piranha
 
namespace detail
{
// This function must have external linkage
SYMENGINE_EXPORT std::string poly_print(const Expression &x);
} // namespace detail
 
} // namespace SymEngine
 
#ifdef HAVE_SYMENGINE_PIRANHA
 
#include <piranha/math.hpp>
#include <piranha/pow.hpp>
#include <piranha/print_coefficient.hpp>
namespace piranha
{
namespace math
{
 
template <typename T>
struct partial_impl<T, typename std::enable_if<std::is_same<
                           T, SymEngine::Expression>::value>::type> {
 
    SymEngine::Expression operator()(const SymEngine::Expression &,
                                     const std::string &) const
    {
        return SymEngine::Expression(0);
    }
};
 
template <typename T, typename U>
struct pow_impl<
    T, U,
    typename std::enable_if<std::is_same<T, SymEngine::Expression>::value
                            && std::is_integral<U>::value>::type> {
    SymEngine::Expression operator()(const SymEngine::Expression &x,
                                     const U &y) const
    {
        return SymEngine::pow(SymEngine::Expression(x).get_basic(),
                              SymEngine::integer(y));
    }
};
} // namespace math
 
template <typename U>
struct print_coefficient_impl<U, typename std::enable_if<std::is_same<
                                     U, SymEngine::Expression>::value>::type> {
    auto operator()(std::ostream &os, const U &cf) const -> decltype(os << cf)
    {
        return os << SymEngine::detail::poly_print(cf);
    }
};
} // namespace piranha
#endif // HAVE_SYMENGINE_PIRANHA
 
// Utility functions for xeus-cling and xeus-cpp-lite
#if defined(__CLING__) || (defined(__CLANG_REPL__) && defined(__EMSCRIPTEN__))
 
// clang-format off
#if defined(__has_include) && __has_include(<nlohmann/json.hpp>)
// clang-format on
#include <nlohmann/json.hpp>
 
namespace SymEngine
{
 
inline nlohmann::json mime_bundle_repr(const Expression &i)
{
    auto bundle = nlohmann::json::object();
    bundle["text/plain"] = str(i);
    bundle["text/latex"] = "$" + latex(i) + "$";
    return bundle;
}
 
} // namespace SymEngine
#endif
#endif
 
#endif // SYMENGINE_EXPRESSION_H