Numworks Epsilon  1.4.1
Graphing Calculator Operating System
function.cpp
Go to the documentation of this file.
1 #include <quiz.h>
2 #include <poincare.h>
3 #include <cmath>
4 #include <ion.h>
5 #include <assert.h>
6 #include "helper.h"
7 
8 using namespace Poincare;
9 
10 template<typename T>
11 void assert_exp_is_bounded(Expression * exp, T lowBound, T upBound) {
12  GlobalContext globalContext;
13  Expression * result = exp->approximate<T>(globalContext);
14  assert(result->type() == Expression::Type::Complex);
15  assert(static_cast<const Complex<T> *>(result)->a() < upBound && static_cast<const Complex<T> *>(result)->a() >= lowBound);
16  delete result;
17 }
18 
19 QUIZ_CASE(poincare_parse_function) {
20  assert_parsed_expression_type("abs(-1)", Expression::Type::AbsoluteValue);
21  assert_parsed_expression_type("arg(2+I)", Expression::Type::ComplexArgument);
22  assert_parsed_expression_type("binomial(10, 4)", Expression::Type::BinomialCoefficient);
23  assert_parsed_expression_type("ceil(0.2)", Expression::Type::Ceiling);
24  assert_parsed_expression_type("diff(2*x, 2)", Expression::Type::Derivative);
25 #if MATRICES_ARE_DEFINED
26  assert_parsed_expression_type("dim([[2]])", Expression::Type::MatrixDimension);
27  assert_parsed_expression_type("det([[1,2,3][4,5,6][7,8,9]])", Expression::Type::Determinant);
28 #endif
29  assert_parsed_expression_type("confidence(0.1, 100)", Expression::Type::ConfidenceInterval);
30  assert_parsed_expression_type("conj(2)", Expression::Type::Conjugate);
31  assert_parsed_expression_type("factor(23/42)", Expression::Type::Factor);
32  assert_parsed_expression_type("floor(2.3)", Expression::Type::Floor);
33  assert_parsed_expression_type("frac(2.3)", Expression::Type::FracPart);
34  assert_parsed_expression_type("gcd(2,3)", Expression::Type::GreatCommonDivisor);
35  assert_parsed_expression_type("im(2+I)", Expression::Type::ImaginaryPart);
36  assert_parsed_expression_type("int(x, 2, 3)", Expression::Type::Integral);
37 #if MATRICES_ARE_DEFINED
38  assert_parsed_expression_type("inverse([[1,2,3][4,5,6][7,8,9]])", Expression::Type::MatrixInverse);
39 #endif
40  assert_parsed_expression_type("lcm(2,3)", Expression::Type::LeastCommonMultiple);
41  assert_parsed_expression_type("ln(2)", Expression::Type::NaperianLogarithm);
42  assert_parsed_expression_type("log(2)", Expression::Type::Logarithm);
43  assert_parsed_expression_type("permute(10, 4)", Expression::Type::PermuteCoefficient);
44  assert_parsed_expression_type("prediction(0.1, 100)", Expression::Type::ConfidenceInterval);
45  assert_parsed_expression_type("prediction95(0.1, 100)", Expression::Type::PredictionInterval);
46  assert_parsed_expression_type("product(n, 4, 10)", Expression::Type::Product);
47  assert_parsed_expression_type("quo(29, 10)", Expression::Type::DivisionQuotient);
48  assert_parsed_expression_type("random()", Expression::Type::Random);
49  assert_parsed_expression_type("randint(1, 2)", Expression::Type::Randint);
50  assert_parsed_expression_type("re(2+I)", Expression::Type::RealPart);
51  assert_parsed_expression_type("rem(29, 10)", Expression::Type::DivisionRemainder);
52  assert_parsed_expression_type("root(2,3)", Expression::Type::NthRoot);
53  assert_parsed_expression_type("R(2)", Expression::Type::SquareRoot);
54  assert_parsed_expression_type("round(2,3)", Expression::Type::Round);
55  assert_parsed_expression_type("sum(n, 4, 10)", Expression::Type::Sum);
56 #if MATRICES_ARE_DEFINED
57  assert_parsed_expression_type("trace([[1,2,3][4,5,6][7,8,9]])", Expression::Type::MatrixTrace);
58  assert_parsed_expression_type("transpose([[1,2,3][4,5,6][7,8,9]])", Expression::Type::MatrixTranspose);
59 #endif
60  assert_parsed_expression_type("6!", Expression::Type::Factorial);
61 }
62 
63 
64 QUIZ_CASE(poincare_function_evaluate) {
65  Complex<float> a0[1] = {Complex<float>::Float(1.0)};
66  assert_parsed_expression_evaluates_to("abs(-1)", a0);
67  Complex<double> ad0[1] = {Complex<double>::Float(1.0)};
68  assert_parsed_expression_evaluates_to("abs(-1)", ad0);
69 
70  Complex<float> a1[1] = {Complex<float>::Float(std::sqrt(3.0f*3.0f+2.0f*2.0f))};
71  assert_parsed_expression_evaluates_to("abs(3+2I)", a1);
72  Complex<double> ad1[1] = {Complex<double>::Float(std::sqrt(3.0*3.0+2.0*2.0))};
73  assert_parsed_expression_evaluates_to("abs(3+2I)", ad1);
74 
75  Complex<float> a2[4] = {Complex<float>::Float(1.0), Complex<float>::Float(2.0), Complex<float>::Float(3.0), Complex<float>::Float(4.0)};
76  assert_parsed_expression_evaluates_to("abs([[1,-2][3,-4]])", a2, 2, 2);
77  Complex<double> ad2[4] = {Complex<double>::Float(1.0), Complex<double>::Float(2.0), Complex<double>::Float(3.0), Complex<double>::Float(4.0)};
78  assert_parsed_expression_evaluates_to("abs([[1,-2][3,-4]])", ad2, 2, 2);
79 
80  Complex<float> a3[4] = {Complex<float>::Float(std::sqrt(3.0f*3.0f+2.0f*2.0f)), Complex<float>::Float(std::sqrt(3.0f*3.0f+4.0f*4.0f)), Complex<float>::Float(std::sqrt(5.0f*5.0f+2.0f*2.0f)), Complex<float>::Float(std::sqrt(3.0f*3.0f+2.0f*2.0f))};
81  assert_parsed_expression_evaluates_to("abs([[3+2I,3+4I][5+2I,3+2I]])", a3, 2, 2);
82  Complex<double> ad3[4] = {Complex<double>::Float(std::sqrt(3.0f*3.0f+2.0f*2.0f)), Complex<double>::Float(std::sqrt(3.0f*3.0f+4.0f*4.0f)), Complex<double>::Float(std::sqrt(5.0f*5.0f+2.0f*2.0f)), Complex<double>::Float(std::sqrt(3.0f*3.0f+2.0f*2.0f))};
83  assert_parsed_expression_evaluates_to("abs([[3+2I,3+4I][5+2I,3+2I]])", ad3, 2, 2);
84 
85  Complex<float> b[1] = {Complex<float>::Float(210.0)};
86  assert_parsed_expression_evaluates_to("binomial(10, 4)", b);
87  Complex<double> bd[1] = {Complex<double>::Float(210.0)};
88  assert_parsed_expression_evaluates_to("binomial(10, 4)", bd);
89 
90  Complex<float> c[1] = {Complex<float>::Float(1.0f)};
91  assert_parsed_expression_evaluates_to("ceil(0.2)", c);
92  Complex<double> cd[1] = {Complex<double>::Float(1.0f)};
93  assert_parsed_expression_evaluates_to("ceil(0.2)", cd);
94 
95  Complex<float> d[1] = {Complex<float>::Float(2.0)};
96  assert_parsed_expression_evaluates_to("diff(2*x, 2)", d);
97  Complex<double> dd[1] = {Complex<double>::Float(2.0)};
98  assert_parsed_expression_evaluates_to("diff(2*x, 2)", dd);
99 
100 #if MATRICES_ARE_DEFINED
101  Complex<float> e[1] = {Complex<float>::Float(126.0f)};
102  assert_parsed_expression_evaluates_to("det([[1,23,3][4,5,6][7,8,9]])", e);
103  Complex<double> ed[1] = {Complex<double>::Float(126.0f)};
104  assert_parsed_expression_evaluates_to("det([[1,23,3][4,5,6][7,8,9]])", ed);
105 #endif
106 
107  Complex<float> f[1] = {Complex<float>::Float(2.0)};
108  assert_parsed_expression_evaluates_to("floor(2.3)", f);
109  Complex<double> fd[1] = {Complex<double>::Float(2.0)};
110  assert_parsed_expression_evaluates_to("floor(2.3)", fd);
111 
112  Complex<float> g[1] = {Complex<float>::Float(0.3f)};
113  assert_parsed_expression_evaluates_to("frac(2.3)", g);
114  Complex<double> gd[1] = {Complex<double>::Float(0.3f)};
115  assert_parsed_expression_evaluates_to("frac(2.3)", gd);
116 
117  Complex<float> h[1] = {Complex<float>::Float(2.0)};
118  assert_parsed_expression_evaluates_to("gcd(234,394)", h);
119  Complex<double> hd[1] = {Complex<double>::Float(2.0)};
120  assert_parsed_expression_evaluates_to("gcd(234,394)", hd);
121 
122  Complex<float> i[1] = {Complex<float>::Float(3.0f)};
123  assert_parsed_expression_evaluates_to("im(2+3I)", i);
124  Complex<double> id[1] = {Complex<double>::Float(3.0f)};
125  assert_parsed_expression_evaluates_to("im(2+3I)", id);
126 
127  Complex<float> j[1] = {Complex<float>::Float(3.0/2.0)};
128  assert_parsed_expression_evaluates_to("int(x, 1, 2)", j);
129  Complex<double> jd[1] = {Complex<double>::Float(3.0/2.0)};
130  assert_parsed_expression_evaluates_to("int(x, 1, 2)", jd);
131 
132  Complex<float> k[1] = {Complex<float>::Float(46098.0f)};
133  assert_parsed_expression_evaluates_to("lcm(234,394)", k);
134  Complex<double> kd[1] = {Complex<double>::Float(46098.0f)};
135  assert_parsed_expression_evaluates_to("lcm(234,394)", kd);
136 
137  Complex<float> l[1] = {Complex<float>::Float(std::log(2.0))};
138  assert_parsed_expression_evaluates_to("ln(2)", l);
139  Complex<double> ld[1] = {Complex<double>::Float(std::log(2.0))};
140  assert_parsed_expression_evaluates_to("ln(2)", ld);
141 
142  Complex<float> m[1] = {Complex<float>::Float(std::log10(2.0f))};
143  assert_parsed_expression_evaluates_to("log(2)", m);
144  Complex<double> md[1] = {Complex<double>::Float(std::log10(2.0f))};
145  assert_parsed_expression_evaluates_to("log(2)", md);
146 
147  Complex<float> n[1] = {Complex<float>::Float(5040.0)};
148  assert_parsed_expression_evaluates_to("permute(10, 4)", n);
149  Complex<double> nd[1] = {Complex<double>::Float(5040.0)};
150  assert_parsed_expression_evaluates_to("permute(10, 4)", nd);
151 
152  Complex<float> o[1] = {Complex<float>::Float(604800.0f)};
153  assert_parsed_expression_evaluates_to("product(n, 4, 10)", o);
154  Complex<double> od[1] = {Complex<double>::Float(604800.0f)};
155  assert_parsed_expression_evaluates_to("product(n, 4, 10)", od);
156 
157  Complex<float> p[1] = {Complex<float>::Float(2.0)};
158  assert_parsed_expression_evaluates_to("re(2+I)", p);
159  Complex<double> pd[1] = {Complex<double>::Float(2.0)};
160  assert_parsed_expression_evaluates_to("re(2+I)", pd);
161 
162  Complex<float> q[1] = {Complex<float>::Float(9.0f)};
163  assert_parsed_expression_evaluates_to("rem(29, 10)", q);
164  Complex<double> qd[1] = {Complex<double>::Float(9.0f)};
165  assert_parsed_expression_evaluates_to("rem(29, 10)", qd);
166 
167  Complex<float> r[1] = {Complex<float>::Float(std::pow(2.0, 1.0/3.0))};
168  assert_parsed_expression_evaluates_to("root(2,3)", r);
169  Complex<double> rd[1] = {Complex<double>::Float(std::pow(2.0, 1.0/3.0))};
170  assert_parsed_expression_evaluates_to("root(2,3)", rd);
171 
172  Complex<float> s[1] = {Complex<float>::Float(std::sqrt(2.0f))};
173  assert_parsed_expression_evaluates_to("R(2)", s);
174  Complex<double> sd[1] = {Complex<double>::Float(std::sqrt(2.0f))};
175  assert_parsed_expression_evaluates_to("R(2)", sd);
176 
177  Complex<float> t[1] = {Complex<float>::Float(49.0)};
178  assert_parsed_expression_evaluates_to("sum(n, 4, 10)", t);
179  Complex<double> td[1] = {Complex<double>::Float(49.0)};
180  assert_parsed_expression_evaluates_to("sum(n, 4, 10)", td);
181 
182 #if MATRICES_ARE_DEFINED
183  Complex<float> u[1] = {Complex<float>::Float(15.0f)};
184  assert_parsed_expression_evaluates_to("trace([[1,2,3][4,5,6][7,8,9]])", u);
185  Complex<double> ud[1] = {Complex<double>::Float(15.0f)};
186  assert_parsed_expression_evaluates_to("trace([[1,2,3][4,5,6][7,8,9]])", ud);
187 #endif
188 
189  Complex<float> v[2] = {Complex<float>::Float(0.1 - std::sqrt(1.0/100.0)), Complex<float>::Float(0.1 + std::sqrt(1.0/100.0))};
190  assert_parsed_expression_evaluates_to("confidence(0.1, 100)", v, 1, 2);
191  Complex<double> vd[2] = {Complex<double>::Float(0.1 - std::sqrt(1.0/100.0)), Complex<double>::Float(0.1 + std::sqrt(1.0/100.0))};
192  assert_parsed_expression_evaluates_to("confidence(0.1, 100)", vd, 1, 2);
193 
194 #if MATRICES_ARE_DEFINED
195  Complex<float> w[2] = {Complex<float>::Float(2.0f), Complex<float>::Float(3.0f)};
196  assert_parsed_expression_evaluates_to("dim([[1,2,3][4,5,-6]])", w, 1, 2);
197  Complex<double> wd[2] = {Complex<double>::Float(2.0f), Complex<double>::Float(3.0f)};
198  assert_parsed_expression_evaluates_to("dim([[1,2,3][4,5,-6]])", wd, 1, 2);
199 #endif
200 
201  Complex<float> x[1] = {Complex<float>::Cartesian(3.0, -2.0)};
202  assert_parsed_expression_evaluates_to("conj(3+2*I)", x);
203  Complex<double> xd[1] = {Complex<double>::Cartesian(3.0, -2.0)};
204  assert_parsed_expression_evaluates_to("conj(3+2*I)", xd);
205 
206 #if MATRICES_ARE_DEFINED
207  Complex<float> y[9] = {Complex<float>::Float(-31.0f/24.0f), Complex<float>::Float(-1.0f/12.0f), Complex<float>::Float(3.0f/8.0f), Complex<float>::Float(13.0f/12.0f), Complex<float>::Float(1.0f/6.0f), Complex<float>::Float(-1.0f/4.0f), Complex<float>::Float(1.0f/24.0f),Complex<float>::Float(-1.0f/12.0f), Complex<float>::Float(1.0f/24.0f)};
208  assert_parsed_expression_evaluates_to("inverse([[1,2,3][4,5,-6][7,8,9]])", y, 3, 3);
209  Complex<double> yd[9] = {Complex<double>::Float(-31.0f/24.0f), Complex<double>::Float(-1.0f/12.0f), Complex<double>::Float(3.0f/8.0f), Complex<double>::Float(13.0f/12.0f), Complex<double>::Float(1.0f/6.0f), Complex<double>::Float(-1.0f/4.0f), Complex<double>::Float(1.0f/24.0f),Complex<double>::Float(-1.0f/12.0f), Complex<double>::Float(1.0f/24.0f)};
210  assert_parsed_expression_evaluates_to("inverse([[1,2,3][4,5,-6][7,8,9]])", yd, 3, 3);
211 #endif
212 
213  Complex<float> z[2] = {Complex<float>::Float(0.1-std::sqrt(1.0/100.0)), Complex<float>::Float(0.1+std::sqrt(1.0/100.0))};
214  assert_parsed_expression_evaluates_to("prediction(0.1, 100)", z, 1, 2);
215  Complex<double> zd[2] = {Complex<double>::Float(0.1-std::sqrt(1.0/100.0)), Complex<double>::Float(0.1+std::sqrt(1.0/100.0))};
216  assert_parsed_expression_evaluates_to("prediction(0.1, 100)", zd, 1, 2);
217 
218  Complex<float> aa[2] = {Complex<float>::Float(0.1f-1.96f*std::sqrt((0.1f*(1.0f-0.1f))/100.0f)), Complex<float>::Float(0.1f+1.96f*std::sqrt((0.1f*(1.0f-0.1f))/100.0f))};
219  assert_parsed_expression_evaluates_to("prediction95(0.1, 100)", aa, 1, 2);
220  Complex<double> aad[2] = {Complex<double>::Float(0.1f-1.96f*std::sqrt((0.1f*(1.0f-0.1f))/100.0f)), Complex<double>::Float(0.1f+1.96f*std::sqrt((0.1f*(1.0f-0.1f))/100.0f))};
221  assert_parsed_expression_evaluates_to("prediction95(0.1, 100)", aad, 1, 2);
222 
223  Complex<float> ab[1] = {Complex<float>::Cartesian(-100.0, -540.0)};
224  assert_parsed_expression_evaluates_to("product(2+n*I, 1, 5)", ab);
225  Complex<double> abd[1] = {Complex<double>::Cartesian(-100.0, -540.0)};
226  assert_parsed_expression_evaluates_to("product(2+n*I, 1, 5)", abd);
227 
228  Complex<float> ac[1] = {Complex<float>::Cartesian(1.4593656008f, 0.1571201229f)};
229  assert_parsed_expression_evaluates_to("root(3+I, 3)", ac);
230  Complex<double> acd[1] = {Complex<double>::Cartesian(1.4593656008f, 0.1571201229f)};
231  assert_parsed_expression_evaluates_to("root(3+I, 3)", acd);
232 
233  Complex<float> add[1] = {Complex<float>::Cartesian(1.38200696233, -0.152442779)};
234  assert_parsed_expression_evaluates_to("root(3, 3+I)", add);
235  Complex<double> addd[1] = {Complex<double>::Cartesian(1.38200696233, -0.152442779)};
236  assert_parsed_expression_evaluates_to("root(3, 3+I)", addd);
237 
238  Complex<float> ae[1] = {Complex<float>::Cartesian(1.75532f, 0.28485f)};
239  assert_parsed_expression_evaluates_to("R(3+I)", ae);
240  Complex<double> aed[1] = {Complex<double>::Cartesian(1.75532f, 0.28485f)};
241  assert_parsed_expression_evaluates_to("R(3+I)", aed);
242 
243  Complex<float> af[1] = {Complex<float>::Cartesian(10.0, 15.0)};
244  assert_parsed_expression_evaluates_to("sum(2+n*I,1,5)", af);
245  Complex<double> afd[1] = {Complex<double>::Cartesian(10.0, 15.0)};
246  assert_parsed_expression_evaluates_to("sum(2+n*I,1,5)", afd);
247 #if MATRICES_ARE_DEFINED
248  Complex<float> ag[9] = {Complex<float>::Float(1.0), Complex<float>::Float(4.0), Complex<float>::Float(7.0), Complex<float>::Float(2.0), Complex<float>::Float(5.0), Complex<float>::Float(8.0), Complex<float>::Float(3.0), Complex<float>::Float(-6.0), Complex<float>::Float(9.0)};
249  assert_parsed_expression_evaluates_to("transpose([[1,2,3][4,5,-6][7,8,9]])", ag, 3, 3);
250  assert_parsed_expression_evaluates_to("transpose([[1,7,5][4,2,8]])", ag, 3, 2);
251  assert_parsed_expression_evaluates_to("transpose([[1,2][4,5][7,8]])", ag, 2, 3);
252  Complex<double> agd[9] = {Complex<double>::Float(1.0), Complex<double>::Float(4.0), Complex<double>::Float(7.0), Complex<double>::Float(2.0), Complex<double>::Float(5.0), Complex<double>::Float(8.0), Complex<double>::Float(3.0), Complex<double>::Float(-6.0), Complex<double>::Float(9.0)};
253  assert_parsed_expression_evaluates_to("transpose([[1,2,3][4,5,-6][7,8,9]])", agd, 3, 3);
254  assert_parsed_expression_evaluates_to("transpose([[1,7,5][4,2,8]])", agd, 3, 2);
255  assert_parsed_expression_evaluates_to("transpose([[1,2][4,5][7,8]])", agd, 2, 3);
256 #endif
257 
258  Complex<float> ah[1] = {Complex<float>::Float(2.325f)};
259  assert_parsed_expression_evaluates_to("round(2.3246,3)", ah);
260  Complex<double> ahd[1] = {Complex<double>::Float(2.325f)};
261  assert_parsed_expression_evaluates_to("round(2.3245,3)", ahd);
262 
263  Complex<float> ai[1] = {Complex<float>::Float(720.0f)};
264  assert_parsed_expression_evaluates_to("6!", ai);
265  Complex<double> aid[1] = {Complex<double>::Float(720.0f)};
266  assert_parsed_expression_evaluates_to("6!", aid);
267 
268  Complex<float> aj[1] = {Complex<float>::Cartesian(0.0f, 1.0f)};
269  assert_parsed_expression_evaluates_to("R(-1)", aj);
270  Complex<double> ajd[1] = {Complex<double>::Cartesian(0.0f, 1.0f)};
271  assert_parsed_expression_evaluates_to("R(-1)", ajd);
272 
273  Complex<float> ak[1] = {Complex<float>::Cartesian(0.5, 0.86602540378443864676)};
274  assert_parsed_expression_evaluates_to("root(-1,3)", ak);
275  Complex<double> akd[1] = {Complex<double>::Cartesian(0.5, 0.86602540378443864676)};
276  assert_parsed_expression_evaluates_to("root(-1,3)", akd);
277 
278  Complex<float> al[1] = {Complex<float>::Float(-5.75f)};
279  assert_parsed_expression_evaluates_to("factor(-23/4)", al);
280  Complex<double> ald[1] = {Complex<double>::Float(-5.125)};
281  assert_parsed_expression_evaluates_to("factor(-123/24)", ald);
282 
283  Expression * exp = parse_expression("random()");
284  assert_exp_is_bounded(exp, 0.0f, 1.0f);
285  assert_exp_is_bounded(exp, 0.0, 1.0);
286  delete exp;
287 
288  exp = parse_expression("randint(4,45)");
289  assert_exp_is_bounded(exp, 4.0f, 45.0f);
290  assert_exp_is_bounded(exp, 4.0, 45.0);
291  delete exp;
292 }
293 
294 QUIZ_CASE(poincare_function_simplify) {
295  assert_parsed_expression_simplify_to("abs(P)", "P");
296  assert_parsed_expression_simplify_to("abs(-P)", "P");
297  assert_parsed_expression_simplify_to("binomial(20,3)", "1140");
298  assert_parsed_expression_simplify_to("binomial(20,10)", "184756");
299  assert_parsed_expression_simplify_to("ceil(-1.3)", "-1");
300  assert_parsed_expression_simplify_to("conj(1/2)", "1/2");
301  assert_parsed_expression_simplify_to("quo(19,3)", "6");
302  assert_parsed_expression_simplify_to("quo(19,0)", "undef");
303  assert_parsed_expression_simplify_to("quo(-19,3)", "-7");
304  assert_parsed_expression_simplify_to("rem(19,3)", "1");
305  assert_parsed_expression_simplify_to("rem(-19,3)", "2");
306  assert_parsed_expression_simplify_to("rem(19,0)", "undef");
307  assert_parsed_expression_simplify_to("99!", "933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000");
308  assert_parsed_expression_simplify_to("factor(-10008/6895)", "-(2^3*3^2*139)/(5*7*197)");
309  assert_parsed_expression_simplify_to("factor(1008/6895)", "(2^4*3^2)/(5*197)");
310  assert_parsed_expression_simplify_to("factor(10007)", "10007");
311  assert_parsed_expression_simplify_to("factor(10007^2)", "undef");
312  assert_parsed_expression_simplify_to("floor(-1.3)", "-2");
313  assert_parsed_expression_simplify_to("frac(-1.3)", "7/10");
314  assert_parsed_expression_simplify_to("gcd(123,278)", "1");
315  assert_parsed_expression_simplify_to("gcd(11,121)", "11");
316  assert_parsed_expression_simplify_to("lcm(123,278)", "34194");
317  assert_parsed_expression_simplify_to("lcm(11,121)", "121");
318  assert_parsed_expression_simplify_to("R(4)", "2");
319  assert_parsed_expression_simplify_to("root(4,3)", "root(4,3)");
320  assert_parsed_expression_simplify_to("root(4,P)", "4^(1/P)");
321  assert_parsed_expression_simplify_to("root(27,3)", "3");
322  assert_parsed_expression_simplify_to("round(4.235,2)", "106/25");
323  assert_parsed_expression_simplify_to("round(4.23,0)", "4");
324  assert_parsed_expression_simplify_to("round(4.9,0)", "5");
325  assert_parsed_expression_simplify_to("round(12.9,-1)", "10");
326  assert_parsed_expression_simplify_to("round(12.9,-2)", "0");
327  assert_parsed_expression_simplify_to("permute(99,4)", "90345024");
328  assert_parsed_expression_simplify_to("permute(20,-10)", "undef");
329  assert_parsed_expression_simplify_to("re(1/2)", "1/2");
330 }
exp
#define exp(x)
Definition: math.h:176
Poincare::Complex::Cartesian
static Complex< T > Cartesian(T a, T b)
Definition: complex.cpp:28
QUIZ_CASE
QUIZ_CASE(poincare_parse_function)
Definition: function.cpp:19
assert
#define assert(e)
Definition: assert.h:9
T
#define T(x)
Definition: events.cpp:26
parse_expression
Expression * parse_expression(const char *expression)
Definition: helper.cpp:44
assert_parsed_expression_type
void assert_parsed_expression_type(const char *expression, Poincare::Expression::Type type)
Definition: helper.cpp:54
c
c(generic_all_nodes)
log
#define log(x)
Definition: math.h:184
assert_parsed_expression_simplify_to
void assert_parsed_expression_simplify_to(const char *expression, const char *simplifiedExpression, Expression::AngleUnit angleUnit)
Definition: helper.cpp:90
pow
#define pow(x, y)
Definition: math.h:190
assert_parsed_expression_evaluates_to
void assert_parsed_expression_evaluates_to(const char *expression, Complex< T > *results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit)
Definition: helper.cpp:69
log10
#define log10(x)
Definition: math.h:186
assert_exp_is_bounded
void assert_exp_is_bounded(Expression *exp, T lowBound, T upBound)
Definition: function.cpp:11
Poincare::Complex::Float
static Complex< T > Float(T x)
Definition: complex.cpp:23
sqrt
#define sqrt(x)
Definition: math.h:196
Poincare::Expression::type
virtual Type type() const =0