test_visitors.h
1 #ifndef SYMENGINE_TEST_VISITORS_H
2 #define SYMENGINE_TEST_VISITORS_H
3 
4 #include <symengine/visitor.h>
5 
6 namespace SymEngine
7 {
8 
9 class ZeroVisitor : public BaseVisitor<ZeroVisitor>
10 {
11 private:
12  tribool is_zero_;
13  const Assumptions *assumptions_;
14 
15  void error();
16 
17 public:
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 
35 class PositiveVisitor : public BaseVisitor<PositiveVisitor>
36 {
37 private:
38  tribool is_positive_;
39  const Assumptions *assumptions_;
40 
41  void error();
42 
43 public:
44  PositiveVisitor(const Assumptions *assumptions)
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 
58 class NonPositiveVisitor : public BaseVisitor<NonPositiveVisitor>
59 {
60 private:
61  tribool is_nonpositive_;
62  const Assumptions *assumptions_;
63 
64  void error();
65 
66 public:
67  NonPositiveVisitor(const Assumptions *assumptions)
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 
80 class NegativeVisitor : public BaseVisitor<NegativeVisitor>
81 {
82 private:
83  tribool is_negative_;
84  const Assumptions *assumptions_;
85 
86  void error();
87 
88 public:
89  NegativeVisitor(const Assumptions *assumptions)
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 
102 class NonNegativeVisitor : public BaseVisitor<NonNegativeVisitor>
103 {
104 private:
105  tribool is_nonnegative_;
106  const Assumptions *assumptions_;
107 
108  void error();
109 
110 public:
111  NonNegativeVisitor(const Assumptions *assumptions)
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 
124 class IntegerVisitor : public BaseVisitor<IntegerVisitor>
125 {
126 private:
127  tribool is_integer_;
128  const Assumptions *assumptions_;
129 
130 public:
131  IntegerVisitor(const Assumptions *assumptions)
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 
173 class RealVisitor : public BaseVisitor<RealVisitor>
174 {
175 private:
176  tribool is_real_;
177  const Assumptions *assumptions_;
178 
179 public:
180  RealVisitor(const Assumptions *assumptions) : assumptions_(assumptions){};
181  void bvisit(const Basic &x)
182  {
183  is_real_ = tribool::indeterminate;
184  };
185  void bvisit(const Symbol &x);
186  void bvisit(const Number &x);
187  void bvisit(const Set &x)
188  {
189  is_real_ = tribool::trifalse;
190  };
191  void bvisit(const Relational &x)
192  {
193  is_real_ = tribool::trifalse;
194  };
195  void bvisit(const Boolean &x)
196  {
197  is_real_ = tribool::trifalse;
198  };
199  void bvisit(const Constant &x);
200  void bvisit(const Add &x);
201 
202  tribool apply(const Basic &b);
203 };
204 
205 class ComplexVisitor : public BaseVisitor<ComplexVisitor>
206 {
207 private:
208  tribool is_complex_;
209  const Assumptions *assumptions_;
210 
211  void check_power(const Basic &base, const Basic &exp);
212  void complex_arg_not_zero(const OneArgFunction &x, const Basic &not_zero);
213  void complex_arg_not_pm(const OneArgFunction &x, bool one);
214 
215 public:
216  ComplexVisitor(const Assumptions *assumptions)
217  : assumptions_(assumptions){};
218  void bvisit(const Basic &x)
219  {
220  is_complex_ = tribool::indeterminate;
221  };
222  void bvisit(const Symbol &x);
223  void bvisit(const Number &x);
224  void bvisit(const Integer &x)
225  {
226  is_complex_ = tribool::tritrue;
227  }
228  void bvisit(const Rational &x)
229  {
230  is_complex_ = tribool::tritrue;
231  }
232  void bvisit(const Set &x)
233  {
234  is_complex_ = tribool::trifalse;
235  };
236  void bvisit(const Relational &x)
237  {
238  is_complex_ = tribool::trifalse;
239  };
240  void bvisit(const Boolean &x)
241  {
242  is_complex_ = tribool::trifalse;
243  };
244  void bvisit(const Constant &x)
245  {
246  is_complex_ = tribool::tritrue;
247  };
248  void bvisit(const Add &x);
249  void bvisit(const Mul &x);
250  void bvisit(const Pow &x);
251  void bvisit(const Cos &x)
252  {
253  x.get_arg()->accept(*this);
254  };
255  void bvisit(const Sin &x)
256  {
257  x.get_arg()->accept(*this);
258  };
259  void bvisit(const ASin &x)
260  {
261  x.get_arg()->accept(*this);
262  };
263  void bvisit(const ACos &x)
264  {
265  x.get_arg()->accept(*this);
266  };
267  void bvisit(const ATan &x);
268  void bvisit(const ATanh &x);
269  void bvisit(const ACot &x);
270  void bvisit(const ACoth &x);
271  void bvisit(const Sinh &x)
272  {
273  x.get_arg()->accept(*this);
274  };
275  void bvisit(const Cosh &x)
276  {
277  x.get_arg()->accept(*this);
278  };
279  void bvisit(const Tan &x);
280  void bvisit(const Cot &x);
281  void bvisit(const Sec &x);
282  void bvisit(const ASec &x);
283  void bvisit(const ASech &x);
284  void bvisit(const Csc &x);
285  void bvisit(const ACsc &x);
286  void bvisit(const ACsch &x);
287  void bvisit(const Log &x);
288  void bvisit(const Sign &x)
289  {
290  x.get_arg()->accept(*this);
291  };
292  void bvisit(const Floor &x)
293  {
294  x.get_arg()->accept(*this);
295  };
296  void bvisit(const Ceiling &x)
297  {
298  x.get_arg()->accept(*this);
299  };
300  void bvisit(const Abs &x)
301  {
302  x.get_arg()->accept(*this);
303  };
304  void bvisit(const Conjugate &x)
305  {
306  x.get_arg()->accept(*this);
307  };
308  void bvisit(const KroneckerDelta &x)
309  {
310  is_complex_ = tribool::tritrue;
311  };
312 
313  tribool apply(const Basic &b);
314 };
315 
316 class PolynomialVisitor : public BaseVisitor<PolynomialVisitor>
317 {
318 private:
319  bool is_polynomial_ = true;
320  bool variables_allowed_ = true;
321  const set_basic &variables_;
322 
323  void check_power(const Basic &base, const Basic &exp);
324 
325 public:
326  PolynomialVisitor(const set_basic &variables) : variables_(variables) {}
327  void bvisit(const Basic &x);
328  void bvisit(const Number &x){};
329  void bvisit(const Constant &x){};
330  void bvisit(const Symbol &x);
331  void bvisit(const Add &x);
332  void bvisit(const Mul &x);
333  void bvisit(const Pow &x);
334  void bvisit(const Set &x)
335  {
336  is_polynomial_ = false;
337  };
338  void bvisit(const Relational &x)
339  {
340  is_polynomial_ = false;
341  };
342 
343  bool apply(const Basic &b);
344 };
345 
356 bool is_polynomial(const Basic &b, const set_basic &variables = {});
357 
358 class RationalVisitor : public BaseVisitor<RationalVisitor>
359 {
360 private:
361  bool rational_; // are we testing for rational or irrational?
362  tribool is_rational_;
363  bool neither_ = false; // Neither rational or irrational (i.e. not real)
364 
365 public:
366  RationalVisitor(bool rational) : rational_{rational} {}
367  void bvisit(const Basic &x)
368  {
369  is_rational_ = tribool::indeterminate;
370  };
371  void bvisit(const Symbol &x)
372  {
373  is_rational_ = tribool::indeterminate;
374  };
375  void bvisit(const Integer &x)
376  {
377  is_rational_ = tribool::tritrue;
378  };
379  void bvisit(const Rational &x)
380  {
381  is_rational_ = tribool::tritrue;
382  };
383  void bvisit(const Number &x);
384  void bvisit(const Set &x)
385  {
386  is_rational_ = tribool::trifalse;
387  neither_ = true;
388  };
389  void bvisit(const Relational &x)
390  {
391  is_rational_ = tribool::trifalse;
392  neither_ = true;
393  };
394  void bvisit(const Boolean &x)
395  {
396  is_rational_ = tribool::trifalse;
397  neither_ = true;
398  };
399  void bvisit(const Constant &x);
400  void bvisit(const Add &x);
401 
402  tribool apply(const Basic &b);
403 };
404 
405 class FiniteVisitor : public BaseVisitor<FiniteVisitor>
406 {
407 private:
408  tribool is_finite_;
409  const Assumptions *assumptions_;
410 
411  void error();
412 
413 public:
414  FiniteVisitor(const Assumptions *assumptions) : assumptions_(assumptions){};
415 
416  void bvisit(const Basic &x);
417  void bvisit(const Symbol &x);
418  void bvisit(const Infty &x);
419  void bvisit(const NaN &x);
420  void bvisit(const Number &x);
421  void bvisit(const Set &x);
422  void bvisit(const Relational &x);
423  void bvisit(const Boolean &x);
424  void bvisit(const Constant &x);
425 
426  tribool apply(const Basic &b);
427 };
428 
429 class AlgebraicVisitor : public BaseVisitor<AlgebraicVisitor>
430 {
431 private:
432  tribool is_algebraic_;
433  const Assumptions *assumptions_;
434 
435  void trans_nonzero_and_algebraic(const Basic &b);
436  void error();
437 
438 public:
439  AlgebraicVisitor(const Assumptions *assumptions) : assumptions_(assumptions)
440  {
441  }
442 
443  void bvisit(const Basic &x);
444  void bvisit(const Add &x);
445  void bvisit(const Symbol &x);
446  void bvisit(const Integer &x);
447  void bvisit(const Rational &x);
448  void bvisit(const Set &x);
449  void bvisit(const Relational &x);
450  void bvisit(const Boolean &x);
451  void bvisit(const Constant &x);
452  void bvisit(const TrigFunction &x);
453  void bvisit(const HyperbolicFunction &x);
454  void bvisit(const LambertW &x);
455 
456  tribool apply(const Basic &b);
457 };
458 
459 } // namespace SymEngine
460 
461 #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:95
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
RCP< const Basic > exp(const RCP< const Basic > &x)
Returns the natural exponential function E**x = pow(E, x)
Definition: pow.cpp:270
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