Loading...
Searching...
No Matches
test_visitors.h
1#ifndef SYMENGINE_TEST_VISITORS_H
2#define SYMENGINE_TEST_VISITORS_H
3
4#include <symengine/visitor.h>
5
6namespace SymEngine
7{
8
9class ZeroVisitor : public BaseVisitor<ZeroVisitor>
10{
11private:
12 tribool is_zero_;
13 const Assumptions *assumptions_;
14
15 void error();
16
17public:
18 ZeroVisitor(const Assumptions *assumptions) : assumptions_(assumptions) {}
19
20 void bvisit(const Basic &x);
21 void bvisit(const Symbol &x);
22 void bvisit(const Number &x);
23 void bvisit(const Set &x);
24 void bvisit(const Relational &x);
25 void bvisit(const Boolean &x);
26 void bvisit(const Constant &x);
27 void bvisit(const Abs &x);
28 void bvisit(const Conjugate &x);
29 void bvisit(const Sign &x);
30 void bvisit(const PrimePi &x);
31
32 tribool apply(const Basic &b);
33};
34
35class PositiveVisitor : public BaseVisitor<PositiveVisitor>
36{
37private:
38 tribool is_positive_;
39 const Assumptions *assumptions_;
40
41 void error();
42
43public:
45 : assumptions_(assumptions){};
46 void bvisit(const Symbol &x);
47 void bvisit(const Number &x);
48 void bvisit(const Constant &x);
49 void bvisit(const Add &x);
50 void bvisit(const Basic &x);
51 void bvisit(const Set &x);
52 void bvisit(const Relational &x);
53 void bvisit(const Boolean &x);
54
55 tribool apply(const Basic &b);
56};
57
58class NonPositiveVisitor : public BaseVisitor<NonPositiveVisitor>
59{
60private:
61 tribool is_nonpositive_;
62 const Assumptions *assumptions_;
63
64 void error();
65
66public:
68 : assumptions_(assumptions){};
69 void bvisit(const Symbol &x);
70 void bvisit(const Number &x);
71 void bvisit(const Constant &x);
72 void bvisit(const Basic &x);
73 void bvisit(const Set &x);
74 void bvisit(const Relational &x);
75 void bvisit(const Boolean &x);
76
77 tribool apply(const Basic &b);
78};
79
80class NegativeVisitor : public BaseVisitor<NegativeVisitor>
81{
82private:
83 tribool is_negative_;
84 const Assumptions *assumptions_;
85
86 void error();
87
88public:
90 : assumptions_(assumptions){};
91 void bvisit(const Basic &x);
92 void bvisit(const Symbol &x);
93 void bvisit(const Number &x);
94 void bvisit(const Set &x);
95 void bvisit(const Relational &x);
96 void bvisit(const Boolean &x);
97 void bvisit(const Constant &x);
98
99 tribool apply(const Basic &b);
100};
101
102class NonNegativeVisitor : public BaseVisitor<NonNegativeVisitor>
103{
104private:
105 tribool is_nonnegative_;
106 const Assumptions *assumptions_;
107
108 void error();
109
110public:
112 : assumptions_(assumptions){};
113 void bvisit(const Basic &x);
114 void bvisit(const Symbol &x);
115 void bvisit(const Number &x);
116 void bvisit(const Set &x);
117 void bvisit(const Relational &x);
118 void bvisit(const Boolean &x);
119 void bvisit(const Constant &x);
120
121 tribool apply(const Basic &b);
122};
123
124class IntegerVisitor : public BaseVisitor<IntegerVisitor>
125{
126private:
127 tribool is_integer_;
128 const Assumptions *assumptions_;
129
130public:
132 : assumptions_(assumptions){};
133 void bvisit(const Basic &x)
134 {
135 is_integer_ = tribool::indeterminate;
136 };
137 void bvisit(const Symbol &x);
138 void bvisit(const Integer &x)
139 {
140 is_integer_ = tribool::tritrue;
141 };
142 void bvisit(const Number &x)
143 {
144 is_integer_ = tribool::trifalse;
145 };
146 void bvisit(const Set &x)
147 {
148 is_integer_ = tribool::trifalse;
149 };
150 void bvisit(const Relational &x)
151 {
152 is_integer_ = tribool::trifalse;
153 };
154 void bvisit(const Boolean &x)
155 {
156 is_integer_ = tribool::trifalse;
157 };
158 void bvisit(const Constant &x);
159 void bvisit(const Add &x);
160 void bvisit(const Mul &x);
161 void bvisit(const Conjugate &x)
162 {
163 x.get_arg()->accept(*this);
164 };
165 void bvisit(const KroneckerDelta &x)
166 {
167 is_integer_ = tribool::tritrue;
168 };
169
170 tribool apply(const Basic &b);
171};
172
173class RealVisitor : public BaseVisitor<RealVisitor>
174{
175private:
176 tribool is_real_;
177 const Assumptions *assumptions_;
178
179 void check_power(const RCP<const Basic> &base, const RCP<const Basic> &exp);
180
181public:
182 RealVisitor(const Assumptions *assumptions) : assumptions_(assumptions){};
183 void bvisit(const Basic &x)
184 {
185 is_real_ = tribool::indeterminate;
186 };
187 void bvisit(const Symbol &x);
188 void bvisit(const Number &x);
189 void bvisit(const Set &x)
190 {
191 is_real_ = tribool::trifalse;
192 };
193 void bvisit(const Relational &x)
194 {
195 is_real_ = tribool::trifalse;
196 };
197 void bvisit(const Boolean &x)
198 {
199 is_real_ = tribool::trifalse;
200 };
201 void bvisit(const Constant &x);
202 void bvisit(const Add &x);
203 void bvisit(const Mul &x);
204 void bvisit(const Pow &x);
205
206 tribool apply(const Basic &b);
207};
208
209class ComplexVisitor : public BaseVisitor<ComplexVisitor>
210{
211private:
212 tribool is_complex_;
213 const Assumptions *assumptions_;
214
215 void check_power(const Basic &base, const Basic &exp);
216 void complex_arg_not_zero(const OneArgFunction &x, const Basic &not_zero);
217 void complex_arg_not_pm(const OneArgFunction &x, bool one);
218
219public:
221 : assumptions_(assumptions){};
222 void bvisit(const Basic &x)
223 {
224 is_complex_ = tribool::indeterminate;
225 };
226 void bvisit(const Symbol &x);
227 void bvisit(const Number &x);
228 void bvisit(const Integer &x)
229 {
230 is_complex_ = tribool::tritrue;
231 }
232 void bvisit(const Rational &x)
233 {
234 is_complex_ = tribool::tritrue;
235 }
236 void bvisit(const Set &x)
237 {
238 is_complex_ = tribool::trifalse;
239 };
240 void bvisit(const Relational &x)
241 {
242 is_complex_ = tribool::trifalse;
243 };
244 void bvisit(const Boolean &x)
245 {
246 is_complex_ = tribool::trifalse;
247 };
248 void bvisit(const Constant &x)
249 {
250 is_complex_ = tribool::tritrue;
251 };
252 void bvisit(const Add &x);
253 void bvisit(const Mul &x);
254 void bvisit(const Pow &x);
255 void bvisit(const Cos &x)
256 {
257 x.get_arg()->accept(*this);
258 };
259 void bvisit(const Sin &x)
260 {
261 x.get_arg()->accept(*this);
262 };
263 void bvisit(const ASin &x)
264 {
265 x.get_arg()->accept(*this);
266 };
267 void bvisit(const ACos &x)
268 {
269 x.get_arg()->accept(*this);
270 };
271 void bvisit(const ATan &x);
272 void bvisit(const ATanh &x);
273 void bvisit(const ACot &x);
274 void bvisit(const ACoth &x);
275 void bvisit(const Sinh &x)
276 {
277 x.get_arg()->accept(*this);
278 };
279 void bvisit(const Cosh &x)
280 {
281 x.get_arg()->accept(*this);
282 };
283 void bvisit(const Tan &x);
284 void bvisit(const Cot &x);
285 void bvisit(const Sec &x);
286 void bvisit(const ASec &x);
287 void bvisit(const ASech &x);
288 void bvisit(const Csc &x);
289 void bvisit(const ACsc &x);
290 void bvisit(const ACsch &x);
291 void bvisit(const Log &x);
292 void bvisit(const Sign &x)
293 {
294 x.get_arg()->accept(*this);
295 };
296 void bvisit(const Floor &x)
297 {
298 x.get_arg()->accept(*this);
299 };
300 void bvisit(const Ceiling &x)
301 {
302 x.get_arg()->accept(*this);
303 };
304 void bvisit(const Abs &x)
305 {
306 x.get_arg()->accept(*this);
307 };
308 void bvisit(const Conjugate &x)
309 {
310 x.get_arg()->accept(*this);
311 };
312 void bvisit(const KroneckerDelta &x)
313 {
314 is_complex_ = tribool::tritrue;
315 };
316
317 tribool apply(const Basic &b);
318};
319
320class PolynomialVisitor : public BaseVisitor<PolynomialVisitor>
321{
322private:
323 bool is_polynomial_ = true;
324 bool variables_allowed_ = true;
325 const set_basic &variables_;
326
327 void check_power(const Basic &base, const Basic &exp);
328
329public:
330 PolynomialVisitor(const set_basic &variables) : variables_(variables) {}
331 void bvisit(const Basic &x);
332 void bvisit(const Number &x){};
333 void bvisit(const Constant &x){};
334 void bvisit(const Symbol &x);
335 void bvisit(const Add &x);
336 void bvisit(const Mul &x);
337 void bvisit(const Pow &x);
338 void bvisit(const Set &x)
339 {
340 is_polynomial_ = false;
341 };
342 void bvisit(const Relational &x)
343 {
344 is_polynomial_ = false;
345 };
346
347 bool apply(const Basic &b);
348};
349
360bool is_polynomial(const Basic &b, const set_basic &variables = {});
361
362class RationalVisitor : public BaseVisitor<RationalVisitor>
363{
364private:
365 bool rational_; // are we testing for rational or irrational?
366 tribool is_rational_;
367 bool neither_ = false; // Neither rational or irrational (i.e. not real)
368
369public:
370 RationalVisitor(bool rational) : rational_{rational} {}
371 void bvisit(const Basic &x)
372 {
373 is_rational_ = tribool::indeterminate;
374 };
375 void bvisit(const Symbol &x)
376 {
377 is_rational_ = tribool::indeterminate;
378 };
379 void bvisit(const Integer &x)
380 {
381 is_rational_ = tribool::tritrue;
382 };
383 void bvisit(const Rational &x)
384 {
385 is_rational_ = tribool::tritrue;
386 };
387 void bvisit(const Number &x);
388 void bvisit(const Set &x)
389 {
390 is_rational_ = tribool::trifalse;
391 neither_ = true;
392 };
393 void bvisit(const Relational &x)
394 {
395 is_rational_ = tribool::trifalse;
396 neither_ = true;
397 };
398 void bvisit(const Boolean &x)
399 {
400 is_rational_ = tribool::trifalse;
401 neither_ = true;
402 };
403 void bvisit(const Constant &x);
404 void bvisit(const Add &x);
405
406 tribool apply(const Basic &b);
407};
408
409class FiniteVisitor : public BaseVisitor<FiniteVisitor>
410{
411private:
412 tribool is_finite_;
413 const Assumptions *assumptions_;
414
415 void error();
416
417public:
418 FiniteVisitor(const Assumptions *assumptions) : assumptions_(assumptions){};
419
420 void bvisit(const Basic &x);
421 void bvisit(const Symbol &x);
422 void bvisit(const Infty &x);
423 void bvisit(const NaN &x);
424 void bvisit(const Number &x);
425 void bvisit(const Set &x);
426 void bvisit(const Relational &x);
427 void bvisit(const Boolean &x);
428 void bvisit(const Constant &x);
429
430 tribool apply(const Basic &b);
431};
432
433class AlgebraicVisitor : public BaseVisitor<AlgebraicVisitor>
434{
435private:
436 tribool is_algebraic_;
437 const Assumptions *assumptions_;
438
439 void trans_nonzero_and_algebraic(const Basic &b);
440 void error();
441
442public:
444 {
445 }
446
447 void bvisit(const Basic &x);
448 void bvisit(const Add &x);
449 void bvisit(const Symbol &x);
450 void bvisit(const Integer &x);
451 void bvisit(const Rational &x);
452 void bvisit(const Set &x);
453 void bvisit(const Relational &x);
454 void bvisit(const Boolean &x);
455 void bvisit(const Constant &x);
456 void bvisit(const TrigFunction &x);
457 void bvisit(const HyperbolicFunction &x);
458 void bvisit(const LambertW &x);
459
460 tribool apply(const Basic &b);
461};
462
463} // namespace SymEngine
464
465#endif // SYMENGINE_TEST_VISITORS_H
The base class for representing addition in symbolic expressions.
Definition add.h:27
The lowest unit of symbolic representation.
Definition basic.h:97
Integer Class.
Definition integer.h:19
RCP< const Basic > get_arg() const
Definition functions.h:36
Rational Class.
Definition rational.h:16
Main namespace for SymEngine package.
Definition add.cpp:19
void hash_combine(hash_t &seed, const T &v)
Definition basic-inl.h:95
RCP< const Basic > exp(const RCP< const Basic > &x)
Returns the natural exponential function E**x = pow(E, x)
Definition pow.cpp:271
bool is_polynomial(const Basic &b, const set_basic &variables)
Check if expression is a polynomial.
RCP< const Number > rational(long n, long d)
convenience creator from two longs
Definition rational.h:328