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 Basic &x);
50  void bvisit(const Set &x);
51  void bvisit(const Relational &x);
52  void bvisit(const Boolean &x);
53 
54  tribool apply(const Basic &b);
55 };
56 
57 class NonPositiveVisitor : public BaseVisitor<NonPositiveVisitor>
58 {
59 private:
60  tribool is_nonpositive_;
61  const Assumptions *assumptions_;
62 
63  void error();
64 
65 public:
66  NonPositiveVisitor(const Assumptions *assumptions)
67  : assumptions_(assumptions){};
68  void bvisit(const Symbol &x);
69  void bvisit(const Number &x);
70  void bvisit(const Constant &x);
71  void bvisit(const Basic &x);
72  void bvisit(const Set &x);
73  void bvisit(const Relational &x);
74  void bvisit(const Boolean &x);
75 
76  tribool apply(const Basic &b);
77 };
78 
79 class NegativeVisitor : public BaseVisitor<NegativeVisitor>
80 {
81 private:
82  tribool is_negative_;
83  const Assumptions *assumptions_;
84 
85  void error();
86 
87 public:
88  NegativeVisitor(const Assumptions *assumptions)
89  : assumptions_(assumptions){};
90  void bvisit(const Basic &x);
91  void bvisit(const Symbol &x);
92  void bvisit(const Number &x);
93  void bvisit(const Set &x);
94  void bvisit(const Relational &x);
95  void bvisit(const Boolean &x);
96  void bvisit(const Constant &x);
97 
98  tribool apply(const Basic &b);
99 };
100 
101 class NonNegativeVisitor : public BaseVisitor<NonNegativeVisitor>
102 {
103 private:
104  tribool is_nonnegative_;
105  const Assumptions *assumptions_;
106 
107  void error();
108 
109 public:
110  NonNegativeVisitor(const Assumptions *assumptions)
111  : assumptions_(assumptions){};
112  void bvisit(const Basic &x);
113  void bvisit(const Symbol &x);
114  void bvisit(const Number &x);
115  void bvisit(const Set &x);
116  void bvisit(const Relational &x);
117  void bvisit(const Boolean &x);
118  void bvisit(const Constant &x);
119 
120  tribool apply(const Basic &b);
121 };
122 
123 class IntegerVisitor : public BaseVisitor<IntegerVisitor>
124 {
125 private:
126  tribool is_integer_;
127  const Assumptions *assumptions_;
128 
129 public:
130  IntegerVisitor(const Assumptions *assumptions)
131  : assumptions_(assumptions){};
132  void bvisit(const Basic &x)
133  {
134  is_integer_ = tribool::indeterminate;
135  };
136  void bvisit(const Symbol &x);
137  void bvisit(const Integer &x)
138  {
139  is_integer_ = tribool::tritrue;
140  };
141  void bvisit(const Number &x)
142  {
143  is_integer_ = tribool::trifalse;
144  };
145  void bvisit(const Set &x)
146  {
147  is_integer_ = tribool::trifalse;
148  };
149  void bvisit(const Relational &x)
150  {
151  is_integer_ = tribool::trifalse;
152  };
153  void bvisit(const Boolean &x)
154  {
155  is_integer_ = tribool::trifalse;
156  };
157  void bvisit(const Constant &x);
158  void bvisit(const Add &x);
159  void bvisit(const Mul &x);
160  void bvisit(const Conjugate &x)
161  {
162  x.get_arg()->accept(*this);
163  };
164  void bvisit(const KroneckerDelta &x)
165  {
166  is_integer_ = tribool::tritrue;
167  };
168 
169  tribool apply(const Basic &b);
170 };
171 
172 class RealVisitor : public BaseVisitor<RealVisitor>
173 {
174 private:
175  tribool is_real_;
176  const Assumptions *assumptions_;
177 
178 public:
179  RealVisitor(const Assumptions *assumptions) : assumptions_(assumptions){};
180  void bvisit(const Basic &x)
181  {
182  is_real_ = tribool::indeterminate;
183  };
184  void bvisit(const Symbol &x);
185  void bvisit(const Number &x);
186  void bvisit(const Set &x)
187  {
188  is_real_ = tribool::trifalse;
189  };
190  void bvisit(const Relational &x)
191  {
192  is_real_ = tribool::trifalse;
193  };
194  void bvisit(const Boolean &x)
195  {
196  is_real_ = tribool::trifalse;
197  };
198  void bvisit(const Constant &x);
199  void bvisit(const Add &x);
200 
201  tribool apply(const Basic &b);
202 };
203 
204 class ComplexVisitor : public BaseVisitor<ComplexVisitor>
205 {
206 private:
207  tribool is_complex_;
208  const Assumptions *assumptions_;
209 
210  void check_power(const Basic &base, const Basic &exp);
211  void complex_arg_not_zero(const OneArgFunction &x, const Basic &not_zero);
212  void complex_arg_not_pm(const OneArgFunction &x, bool one);
213 
214 public:
215  ComplexVisitor(const Assumptions *assumptions)
216  : assumptions_(assumptions){};
217  void bvisit(const Basic &x)
218  {
219  is_complex_ = tribool::indeterminate;
220  };
221  void bvisit(const Symbol &x);
222  void bvisit(const Number &x);
223  void bvisit(const Integer &x)
224  {
225  is_complex_ = tribool::tritrue;
226  }
227  void bvisit(const Rational &x)
228  {
229  is_complex_ = tribool::tritrue;
230  }
231  void bvisit(const Set &x)
232  {
233  is_complex_ = tribool::trifalse;
234  };
235  void bvisit(const Relational &x)
236  {
237  is_complex_ = tribool::trifalse;
238  };
239  void bvisit(const Boolean &x)
240  {
241  is_complex_ = tribool::trifalse;
242  };
243  void bvisit(const Constant &x)
244  {
245  is_complex_ = tribool::tritrue;
246  };
247  void bvisit(const Add &x);
248  void bvisit(const Mul &x);
249  void bvisit(const Pow &x);
250  void bvisit(const Cos &x)
251  {
252  x.get_arg()->accept(*this);
253  };
254  void bvisit(const Sin &x)
255  {
256  x.get_arg()->accept(*this);
257  };
258  void bvisit(const ASin &x)
259  {
260  x.get_arg()->accept(*this);
261  };
262  void bvisit(const ACos &x)
263  {
264  x.get_arg()->accept(*this);
265  };
266  void bvisit(const ATan &x);
267  void bvisit(const ATanh &x);
268  void bvisit(const ACot &x);
269  void bvisit(const ACoth &x);
270  void bvisit(const Sinh &x)
271  {
272  x.get_arg()->accept(*this);
273  };
274  void bvisit(const Cosh &x)
275  {
276  x.get_arg()->accept(*this);
277  };
278  void bvisit(const Tan &x);
279  void bvisit(const Cot &x);
280  void bvisit(const Sec &x);
281  void bvisit(const ASec &x);
282  void bvisit(const ASech &x);
283  void bvisit(const Csc &x);
284  void bvisit(const ACsc &x);
285  void bvisit(const ACsch &x);
286  void bvisit(const Log &x);
287  void bvisit(const Sign &x)
288  {
289  x.get_arg()->accept(*this);
290  };
291  void bvisit(const Floor &x)
292  {
293  x.get_arg()->accept(*this);
294  };
295  void bvisit(const Ceiling &x)
296  {
297  x.get_arg()->accept(*this);
298  };
299  void bvisit(const Abs &x)
300  {
301  x.get_arg()->accept(*this);
302  };
303  void bvisit(const Conjugate &x)
304  {
305  x.get_arg()->accept(*this);
306  };
307  void bvisit(const KroneckerDelta &x)
308  {
309  is_complex_ = tribool::tritrue;
310  };
311 
312  tribool apply(const Basic &b);
313 };
314 
315 class PolynomialVisitor : public BaseVisitor<PolynomialVisitor>
316 {
317 private:
318  bool is_polynomial_ = true;
319  bool variables_allowed_ = true;
320  const set_basic &variables_;
321 
322  void check_power(const Basic &base, const Basic &exp);
323 
324 public:
325  PolynomialVisitor(const set_basic &variables) : variables_(variables) {}
326  void bvisit(const Basic &x);
327  void bvisit(const Number &x){};
328  void bvisit(const Constant &x){};
329  void bvisit(const Symbol &x);
330  void bvisit(const Add &x);
331  void bvisit(const Mul &x);
332  void bvisit(const Pow &x);
333  void bvisit(const Set &x)
334  {
335  is_polynomial_ = false;
336  };
337  void bvisit(const Relational &x)
338  {
339  is_polynomial_ = false;
340  };
341 
342  bool apply(const Basic &b);
343 };
344 
355 bool is_polynomial(const Basic &b, const set_basic &variables = {});
356 
357 class RationalVisitor : public BaseVisitor<RationalVisitor>
358 {
359 private:
360  bool rational_; // are we testing for rational or irrational?
361  tribool is_rational_;
362  bool neither_ = false; // Neither rational or irrational (i.e. not real)
363 
364 public:
365  RationalVisitor(bool rational) : rational_{rational} {}
366  void bvisit(const Basic &x)
367  {
368  is_rational_ = tribool::indeterminate;
369  };
370  void bvisit(const Symbol &x)
371  {
372  is_rational_ = tribool::indeterminate;
373  };
374  void bvisit(const Integer &x)
375  {
376  is_rational_ = tribool::tritrue;
377  };
378  void bvisit(const Rational &x)
379  {
380  is_rational_ = tribool::tritrue;
381  };
382  void bvisit(const Number &x);
383  void bvisit(const Set &x)
384  {
385  is_rational_ = tribool::trifalse;
386  neither_ = true;
387  };
388  void bvisit(const Relational &x)
389  {
390  is_rational_ = tribool::trifalse;
391  neither_ = true;
392  };
393  void bvisit(const Boolean &x)
394  {
395  is_rational_ = tribool::trifalse;
396  neither_ = true;
397  };
398  void bvisit(const Constant &x);
399  void bvisit(const Add &x);
400 
401  tribool apply(const Basic &b);
402 };
403 } // namespace SymEngine
404 
405 #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