Loading...
Searching...
No Matches
expression.h
Go to the documentation of this file.
1
7#ifndef SYMENGINE_EXPRESSION_H
8#define SYMENGINE_EXPRESSION_H
9
10#include <symengine/add.h>
11#include <symengine/pow.h>
12#include <symengine/symbol.h>
13#include <symengine/complex_double.h>
15#include <symengine/printers.h>
16
17namespace SymEngine
18{
19
20// Forward declare these here to avoid including derivative.h and break the
21// cycle
22RCP<const Basic> diff(const RCP<const Basic> &arg, const RCP<const Symbol> &x,
23 bool cache);
24
25RCP<const Basic> sdiff(const RCP<const Basic> &arg, const RCP<const Basic> &x,
26 bool cache);
27
29{
30private:
31 RCP<const Basic> m_basic;
32
33public:
35 Expression() : m_basic(integer(0)) {}
37 template <class T>
39 T n,
40 typename std::enable_if<std::is_integral<T>::value>::type * = nullptr)
41 : m_basic(integer(n))
42 {
43 }
45 template <class T>
48 * = nullptr)
49 : m_basic(real_double(n))
50 {
51 }
53 template <class T>
56 * = nullptr)
57 : m_basic(complex_double(n))
58 {
59 }
60
61 Expression(const integer_class &n) : m_basic(integer(n)) {}
62
63 Expression(const rational_class &n) : m_basic(Rational::from_mpq(n)) {}
64
65 Expression(RCP<const Basic> &&o) : m_basic(o) {}
66
67 Expression(const RCP<const Basic> &o) : m_basic(o) {}
68
69 Expression(const std::string &s);
70
72 Expression(const Expression &) = default;
74 Expression(Expression &&other) SYMENGINE_NOEXCEPT
75 : m_basic(std::move(other.m_basic))
76 {
77 }
79 Expression &operator=(const Expression &) = default;
81 Expression &operator=(Expression &&other) SYMENGINE_NOEXCEPT
82 {
83 if (this != &other) {
84 this->m_basic = std::move(other.m_basic);
85 }
86 return *this;
87 }
89 virtual ~Expression() SYMENGINE_NOEXCEPT {}
92 {
93 os << expr.m_basic->__str__();
94 return os;
95 }
97 friend Expression operator+(const Expression &a, const Expression &b)
98 {
99 return Expression(add(a.m_basic, b.m_basic));
100 }
101 friend Expression operator+(const RCP<const Basic> &a, const Expression &b)
102 {
103 return Expression(add(a, b.m_basic));
104 }
105 friend Expression operator+(const Expression &a, const RCP<const Basic> &b)
106 {
107 return Expression(add(a.m_basic, b));
108 }
111 {
112 m_basic = add(m_basic, other.m_basic);
113 return *this;
114 }
115 Expression &operator+=(const RCP<const Basic> &other)
116 {
117 m_basic = add(m_basic, other);
118 return *this;
119 }
121 friend Expression operator-(const Expression &a, const Expression &b)
122 {
123 return Expression(sub(a.m_basic, b.m_basic));
124 }
125 friend Expression operator-(const RCP<const Basic> &a, const Expression &b)
126 {
127 return Expression(sub(a, b.m_basic));
128 }
129 friend Expression operator-(const Expression &a, const RCP<const Basic> &b)
130 {
131 return Expression(sub(a.m_basic, b));
132 }
133 operator const RCP<const Basic> &() const
134 {
135 return m_basic;
136 }
138 Expression diff(const RCP<const Symbol> &x, bool cache = true) const
139 {
140 return Expression(SymEngine::diff(m_basic, x, cache));
141 }
143 Expression diff(const RCP<const Basic> &x, bool cache = true) const
144 {
145 return Expression(sdiff(m_basic, x, cache));
146 }
148 Expression subs(const map_basic_basic &subs_map) const
149 {
150 return Expression(m_basic->subs(subs_map));
151 }
153 template <typename T,
154 typename
156 explicit operator T() const
157 {
158 return T(eval_double(*get_basic()));
159 }
161 template <typename T,
162 typename
164 explicit operator std::complex<T>() const
165 {
166 return std::complex<T>(eval_complex_double(*get_basic()));
167 }
168 operator const Basic &() const
169 {
170 return *m_basic;
171 }
174 {
175 Expression retval(*this);
176 retval *= -1;
177 return retval;
178 }
181 {
182 m_basic = sub(m_basic, other.m_basic);
183 return *this;
184 }
185 Expression &operator-=(const RCP<const Basic> &other)
186 {
187 m_basic = sub(m_basic, other);
188 return *this;
189 }
191 friend Expression operator*(const Expression &a, const Expression &b)
192 {
193 return Expression(mul(a.m_basic, b.m_basic));
194 }
195 friend Expression operator*(const RCP<const Basic> &a, const Expression &b)
196 {
197 return Expression(mul(a, b.m_basic));
198 }
199 friend Expression operator*(const Expression &a, const RCP<const Basic> &b)
200 {
201 return Expression(mul(a.m_basic, b));
202 }
205 {
206 m_basic = mul(m_basic, other.m_basic);
207 return *this;
208 }
209 Expression &operator*=(const RCP<const Basic> &other)
210 {
211 m_basic = mul(m_basic, other);
212 return *this;
213 }
215 friend Expression operator/(const Expression &a, const Expression &b)
216 {
217 return Expression(div(a.m_basic, b.m_basic));
218 }
219 friend Expression operator/(const RCP<const Basic> &a, const Expression &b)
220 {
221 return Expression(div(a, b.m_basic));
222 }
223 friend Expression operator/(const Expression &a, const RCP<const Basic> &b)
224 {
225 return Expression(div(a.m_basic, b));
226 }
229 {
230 m_basic = div(m_basic, other.m_basic);
231 return *this;
232 }
233 Expression &operator/=(const RCP<const Basic> &other)
234 {
235 m_basic = div(m_basic, other);
236 return *this;
237 }
239 bool operator==(const Expression &other) const
240 {
241 return eq(*m_basic, *other.m_basic);
242 }
243 bool operator==(const RCP<const Basic> &other) const
244 {
245 return eq(*m_basic, *other);
246 }
247
249 bool operator!=(const Expression &other) const
250 {
251 return not(*this == other);
252 }
253 bool operator!=(const RCP<const Basic> &other) const
254 {
255 return not(*this == other);
256 }
257
259 const RCP<const Basic> &get_basic() const
260 {
261 return m_basic;
262 }
263};
264
265inline Expression pow(const Expression &base, const Expression &exp)
266{
267 return pow(base.get_basic(), exp.get_basic());
268}
269
270inline Expression expand(const Expression &arg)
271{
272 return expand(arg.get_basic());
273}
274
275inline bool unified_eq(const Expression &a, const Expression &b)
276{
277 return a == b;
278}
279
280inline int unified_compare(const Expression &a, const Expression &b)
281{
282 return unified_compare(a.get_basic(), b.get_basic());
283}
284
285// Utility functions for piranha
286
287namespace detail
288{
289// This function must have external linkage
290std::string poly_print(const Expression &x);
291} // namespace detail
292
293} // namespace SymEngine
294
295#ifdef HAVE_SYMENGINE_PIRANHA
296
297#include <piranha/math.hpp>
298#include <piranha/pow.hpp>
299#include <piranha/print_coefficient.hpp>
300namespace piranha
301{
302namespace math
303{
304
305template <typename T>
306struct partial_impl<T, typename std::enable_if<std::is_same<
307 T, SymEngine::Expression>::value>::type> {
309
313 const std::string &) const
314 {
315 return SymEngine::Expression(0);
316 }
317};
318
319template <typename T, typename U>
320struct pow_impl<
321 T, U,
322 typename std::enable_if<std::is_same<T, SymEngine::Expression>::value
323 && std::is_integral<U>::value>::type> {
325 const U &y) const
326 {
327 return SymEngine::pow(SymEngine::Expression(x).get_basic(),
329 }
330};
331} // namespace math
332
333template <typename U>
334struct print_coefficient_impl<U, typename std::enable_if<std::is_same<
335 U, SymEngine::Expression>::value>::type> {
336 auto operator()(std::ostream &os, const U &cf) const -> decltype(os << cf)
337 {
338 return os << SymEngine::detail::poly_print(cf);
339 }
340};
341} // namespace piranha
342#endif // HAVE_SYMENGINE_PIRANHA
343
344// Utility functions for xeus-cling
345namespace SymEngine
346{
347
348#ifdef __CLING__
349// clang-format off
350#if defined(__has_include) && __has_include(<nlohmann/json.hpp>)
351// clang-format on
352#include <nlohmann/json.hpp>
353
354inline nlohmann::json mime_bundle_repr(const Expression &i)
355{
356 auto bundle = nlohmann::json::object();
357 bundle["text/plain"] = str(i);
358 bundle["text/latex"] = "$" + latex(i) + "$";
359 return bundle;
360}
361#endif
362#endif
363
364} // namespace SymEngine
365
366#endif // SYMENGINE_EXPRESSION_H
Classes and functions relating to the binary operation of addition.
The lowest unit of symbolic representation.
Definition: basic.h:97
Expression(T n, typename std::enable_if< std::is_floating_point< T >::value >::type *=nullptr)
Construct Expression from floating point types.
Definition: expression.h:46
Expression(const Expression &)=default
Construct Expression from Expression.
Expression & operator=(Expression &&other) SYMENGINE_NOEXCEPT
Overload assignment operator for reference.
Definition: expression.h:81
Expression(T n, typename std::enable_if< std::is_integral< T >::value >::type *=nullptr)
Construct Expression from integral types.
Definition: expression.h:38
friend Expression operator+(const Expression &a, const Expression &b)
Overload addition.
Definition: expression.h:97
Expression diff(const RCP< const Symbol > &x, bool cache=true) const
Differentiation.
Definition: expression.h:138
Expression subs(const map_basic_basic &subs_map) const
Substitution.
Definition: expression.h:148
friend Expression operator/(const Expression &a, const Expression &b)
Overload Division.
Definition: expression.h:215
friend Expression operator-(const Expression &a, const Expression &b)
Overload subtraction.
Definition: expression.h:121
Expression & operator/=(const Expression &other)
Overload Division and assignment (/=)
Definition: expression.h:228
Expression & operator+=(const Expression &other)
Overload addition and assignment(+=)
Definition: expression.h:110
Expression diff(const RCP< const Basic > &x, bool cache=true) const
Differentiation.
Definition: expression.h:143
friend Expression operator*(const Expression &a, const Expression &b)
Overload multiplication.
Definition: expression.h:191
virtual ~Expression() SYMENGINE_NOEXCEPT
Destructor of Expression.
Definition: expression.h:89
friend std::ostream & operator<<(std::ostream &os, const Expression &expr)
Overload stream operator.
Definition: expression.h:91
bool operator==(const Expression &other) const
Overload check equality (==)
Definition: expression.h:239
Expression & operator=(const Expression &)=default
Overload assignment operator.
Expression & operator-=(const Expression &other)
Overload subtraction and assignment(-=)
Definition: expression.h:180
const RCP< const Basic > & get_basic() const
Method to get Basic from Expression.
Definition: expression.h:259
Expression operator-() const
Overload unary negative.
Definition: expression.h:173
Expression(Expression &&other) SYMENGINE_NOEXCEPT
Construct Expression from reference to Expression.
Definition: expression.h:74
Expression()
Plain constructor of Expression.
Definition: expression.h:35
Expression & operator*=(const Expression &other)
Overload multiplication and assignment (*=)
Definition: expression.h:204
Expression(std::complex< T > n, typename std::enable_if< std::is_floating_point< T >::value >::type *=nullptr)
Construct Expression from std::complex<> types.
Definition: expression.h:54
bool operator!=(const Expression &other) const
Overload check not equal (!=)
Definition: expression.h:249
T move(T... args)
Main namespace for SymEngine package.
Definition: add.cpp:19
RCP< const Basic > div(const RCP< const Basic > &a, const RCP< const Basic > &b)
Division.
Definition: mul.cpp:431
bool eq(const Basic &a, const Basic &b)
Checks equality for a and b
Definition: basic-inl.h:21
RCP< const Basic > sub(const RCP< const Basic > &a, const RCP< const Basic > &b)
Substracts b from a.
Definition: add.cpp:495
RCP< const Basic > exp(const RCP< const Basic > &x)
Returns the natural exponential function E**x = pow(E, x)
Definition: pow.cpp:271
RCP< const Basic > mul(const RCP< const Basic > &a, const RCP< const Basic > &b)
Multiplication.
Definition: mul.cpp:352
RCP< const Basic > add(const RCP< const Basic > &a, const RCP< const Basic > &b)
Adds two objects (safely).
Definition: add.cpp:425
int unified_compare(const T &a, const T &b)
Definition: dict.h:205
RCP< const Basic > expand(const RCP< const Basic > &self, bool deep=true)
Expands self
Definition: expand.cpp:369
std::enable_if< std::is_integral< T >::value, RCP< constInteger > >::type integer(T i)
Definition: integer.h:200
STL namespace.