diff --git a/poincare/test/addition.cpp b/poincare/test/addition.cpp index c82499e52..2c2c1a79f 100644 --- a/poincare/test/addition.cpp +++ b/poincare/test/addition.cpp @@ -8,10 +8,10 @@ using namespace Poincare; QUIZ_CASE(poincare_addition_evaluate) { Complex a[1] = {Complex::Float(3.0f)}; - assert_parsed_expression_evaluate_to("1+2", a, 1); + assert_parsed_expression_evaluate_to("1+2", a); Complex b[1] = {Complex::Cartesian(6.0, 2.0)}; - assert_parsed_expression_evaluate_to("2+I+4+I", b, 1); + assert_parsed_expression_evaluate_to("2+I+4+I", b); #if MATRICES_ARE_DEFINED Complex c[6] = {Complex::Float(4.0f), Complex::Float(5.0f), Complex::Float(6.0f), Complex::Float(7.0f), Complex::Float(8.0f), Complex::Float(9.0f)}; diff --git a/poincare/test/fraction.cpp b/poincare/test/fraction.cpp index 1cfaeb88c..688c6c0a1 100644 --- a/poincare/test/fraction.cpp +++ b/poincare/test/fraction.cpp @@ -9,10 +9,10 @@ using namespace Poincare; QUIZ_CASE(poincare_fraction_evaluate) { Complex a[1] = {Complex::Float(0.5f)}; - assert_parsed_expression_evaluate_to("1/2", a, 1); + assert_parsed_expression_evaluate_to("1/2", a); Complex b[1] = {Complex::Cartesian(13.0/17.0, 1.0/17.0)}; - assert_parsed_expression_evaluate_to("(3+I)/(4+I)", b, 1); + assert_parsed_expression_evaluate_to("(3+I)/(4+I)", b); #if MATRICES_ARE_DEFINED Complex c[6] = {Complex::Float(0.5f), Complex::Float(1.0f), Complex::Float(1.5f), Complex::Float(2.0f), Complex::Float(2.5f), Complex::Float(3.0f)}; diff --git a/poincare/test/function.cpp b/poincare/test/function.cpp index 6d883a279..f14972538 100644 --- a/poincare/test/function.cpp +++ b/poincare/test/function.cpp @@ -150,10 +150,10 @@ QUIZ_CASE(poincare_parse_function) { QUIZ_CASE(poincare_function_evaluate) { Complex a0[1] = {Complex::Float(1.0)}; - assert_parsed_expression_evaluate_to("abs(-1)", a0, 1); + assert_parsed_expression_evaluate_to("abs(-1)", a0); Complex a1[1] = {Complex::Float(std::sqrt(3.0f*3.0f+2.0f*2.0f))}; - assert_parsed_expression_evaluate_to("abs(3+2I)", a1, 1); + assert_parsed_expression_evaluate_to("abs(3+2I)", a1); Complex a2[4] = {Complex::Float(1.0), Complex::Float(2.0), Complex::Float(3.0), Complex::Float(4.0)}; assert_parsed_expression_evaluate_to("abs([[1,-2][3,-4]])", a2, 2, 2); @@ -162,67 +162,67 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluate_to("abs([[3+2I,3+4I][5+2I,3+2I]])", a3, 2, 2); Complex b[1] = {Complex::Float(210.0)}; - assert_parsed_expression_evaluate_to("binomial(10, 4)", b, 1); + assert_parsed_expression_evaluate_to("binomial(10, 4)", b); Complex c[1] = {Complex::Float(1.0f)}; - assert_parsed_expression_evaluate_to("ceil(0.2)", c, 1); + assert_parsed_expression_evaluate_to("ceil(0.2)", c); Complex d[1] = {Complex::Float(2.0)}; - assert_parsed_expression_evaluate_to("diff(2*x, 2)", d, 1); + assert_parsed_expression_evaluate_to("diff(2*x, 2)", d); #if MATRICES_ARE_DEFINED Complex e[1] = {Complex::Float(126.0f)}; - assert_parsed_expression_evaluate_to("det([[1,23,3][4,5,6][7,8,9]])", e, 1); + assert_parsed_expression_evaluate_to("det([[1,23,3][4,5,6][7,8,9]])", e); #endif Complex f[1] = {Complex::Float(2.0)}; - assert_parsed_expression_evaluate_to("floor(2.3)", f, 1); + assert_parsed_expression_evaluate_to("floor(2.3)", f); Complex g[1] = {Complex::Float(0.3f)}; - assert_parsed_expression_evaluate_to("frac(2.3)", g, 1); + assert_parsed_expression_evaluate_to("frac(2.3)", g); Complex h[1] = {Complex::Float(2.0)}; - assert_parsed_expression_evaluate_to("gcd(234,394)", h, 1); + assert_parsed_expression_evaluate_to("gcd(234,394)", h); Complex i[1] = {Complex::Float(3.0f)}; - assert_parsed_expression_evaluate_to("im(2+3I)", i, 1); + assert_parsed_expression_evaluate_to("im(2+3I)", i); Complex j[1] = {Complex::Float(3.0/2.0)}; - assert_parsed_expression_evaluate_to("int(x, 1, 2)", j, 1); + assert_parsed_expression_evaluate_to("int(x, 1, 2)", j); Complex k[1] = {Complex::Float(46098.0f)}; - assert_parsed_expression_evaluate_to("lcm(234,394)", k, 1); + assert_parsed_expression_evaluate_to("lcm(234,394)", k); Complex l[1] = {Complex::Float(std::log(2.0))}; - assert_parsed_expression_evaluate_to("ln(2)", l, 1); + assert_parsed_expression_evaluate_to("ln(2)", l); Complex m[1] = {Complex::Float(std::log10(2.0f))}; - assert_parsed_expression_evaluate_to("log(2)", m, 1); + assert_parsed_expression_evaluate_to("log(2)", m); Complex n[1] = {Complex::Float(5040.0)}; - assert_parsed_expression_evaluate_to("permute(10, 4)", n, 1); + assert_parsed_expression_evaluate_to("permute(10, 4)", n); Complex o[1] = {Complex::Float(604800.0f)}; - assert_parsed_expression_evaluate_to("product(n, 4, 10)", o, 1); + assert_parsed_expression_evaluate_to("product(n, 4, 10)", o); Complex p[1] = {Complex::Float(2.0)}; - assert_parsed_expression_evaluate_to("re(2+I)", p, 1); + assert_parsed_expression_evaluate_to("re(2+I)", p); Complex q[1] = {Complex::Float(9.0f)}; - assert_parsed_expression_evaluate_to("rem(29, 10)", q, 1); + assert_parsed_expression_evaluate_to("rem(29, 10)", q); Complex r[1] = {Complex::Float(std::pow(2.0, 1.0/3.0))}; - assert_parsed_expression_evaluate_to("root(2,3)", r, 1); + assert_parsed_expression_evaluate_to("root(2,3)", r); Complex s[1] = {Complex::Float(std::sqrt(2.0f))}; - assert_parsed_expression_evaluate_to("R(2)", s, 1); + assert_parsed_expression_evaluate_to("R(2)", s); Complex t[1] = {Complex::Float(49.0)}; - assert_parsed_expression_evaluate_to("sum(n, 4, 10)", t, 1); + assert_parsed_expression_evaluate_to("sum(n, 4, 10)", t); #if MATRICES_ARE_DEFINED Complex u[1] = {Complex::Float(15.0f)}; - assert_parsed_expression_evaluate_to("trace([[1,2,3][4,5,6][7,8,9]])", u, 1); + assert_parsed_expression_evaluate_to("trace([[1,2,3][4,5,6][7,8,9]])", u); #endif Complex v[2] = {Complex::Float(0.1 - std::sqrt(1.0/100.0)), Complex::Float(0.1 + std::sqrt(1.0/100.0))}; @@ -234,7 +234,7 @@ QUIZ_CASE(poincare_function_evaluate) { #endif Complex x[1] = {Complex::Cartesian(3.0, -2.0)}; - assert_parsed_expression_evaluate_to("conj(3+2*I)", x, 1); + assert_parsed_expression_evaluate_to("conj(3+2*I)", x); #if MATRICES_ARE_DEFINED Complex y[9] = {Complex::Float(-31.0f/24.0f), Complex::Float(-1.0f/12.0f), Complex::Float(3.0f/8.0f), Complex::Float(13.0f/12.0f), Complex::Float(1.0f/6.0f), Complex::Float(-1.0f/4.0f), Complex::Float(1.0f/24.0f),Complex::Float(-1.0f/12.0f), Complex::Float(1.0f/24.0f)}; @@ -248,19 +248,19 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluate_to("prediction95(0.1, 100)", aa, 2); Complex ab[1] = {Complex::Cartesian(-100.0, -540.0)}; - assert_parsed_expression_evaluate_to("product(2+n*I, 1, 5)", ab, 1); + assert_parsed_expression_evaluate_to("product(2+n*I, 1, 5)", ab); Complex ac[1] = {Complex::Cartesian(1.4593656008f, 0.1571201229f)}; - assert_parsed_expression_evaluate_to("root(3+I, 3)", ac, 1); + assert_parsed_expression_evaluate_to("root(3+I, 3)", ac); Complex ad[1] = {Complex::Cartesian(1.38200696233, -0.152442779)}; - assert_parsed_expression_evaluate_to("root(3, 3+I)", ad, 1); + assert_parsed_expression_evaluate_to("root(3, 3+I)", ad); Complex ae[1] = {Complex::Cartesian(1.75532f, 0.28485f)}; - assert_parsed_expression_evaluate_to("R(3+I)", ae, 1); + assert_parsed_expression_evaluate_to("R(3+I)", ae); Complex af[1] = {Complex::Cartesian(10.0, 15.0)}; - assert_parsed_expression_evaluate_to("sum(2+n*I,1,5)", af, 1); + assert_parsed_expression_evaluate_to("sum(2+n*I,1,5)", af); #if MATRICES_ARE_DEFINED Complex ag[9] = {Complex::Float(1.0), Complex::Float(4.0), Complex::Float(7.0), Complex::Float(2.0), Complex::Float(5.0), Complex::Float(8.0), Complex::Float(3.0), Complex::Float(-6.0), Complex::Float(9.0)}; assert_parsed_expression_evaluate_to("transpose([[1,2,3][4,5,-6][7,8,9]])", ag, 3, 3); @@ -269,8 +269,8 @@ QUIZ_CASE(poincare_function_evaluate) { #endif Complex ah[1] = {Complex::Float(2.325f)}; - assert_parsed_expression_evaluate_to("round(2.3245,3)", ah, 1); + assert_parsed_expression_evaluate_to("round(2.3245,3)", ah); Complex ai[1] = {Complex::Float(720.0f)}; - assert_parsed_expression_evaluate_to("6!", ai, 1); + assert_parsed_expression_evaluate_to("6!", ai); } diff --git a/poincare/test/helper.cpp b/poincare/test/helper.cpp index a2ecd4905..c44209d9c 100644 --- a/poincare/test/helper.cpp +++ b/poincare/test/helper.cpp @@ -9,7 +9,7 @@ using namespace Poincare; template -static Evaluation * parse_expression(const char * expression, Expression::AngleUnit angleUnit) { +void assert_parsed_expression_evaluate_to(const char * expression, Complex * results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit) { char buffer[200]; strlcpy(buffer, expression, 200); for (size_t i=0; i * parse_expression(const char * expression, Expression::Ang GlobalContext globalContext; Expression * a = Expression::parse(buffer); Evaluation * m = a->evaluate(globalContext, angleUnit); - delete a; - return m; -} - -template -static void check_results(Evaluation * actual, Complex * expected) { - for (int i = 0; i < actual->numberOfOperands(); i++) { - assert(std::fabs(actual->complexOperand(i)->a() - expected[i].a()) < 0.0001f); - assert(std::fabs(actual->complexOperand(i)->b() - expected[i].b()) < 0.0001f); - } -} - -template -void assert_parsed_expression_evaluate_to(const char * expression, Complex * results, int numberOfEntries, Expression::AngleUnit angleUnit) { - Evaluation * m = parse_expression(expression, angleUnit); - assert(m->numberOfOperands() == numberOfEntries); - check_results(m, results); - delete m; -} - -template -void assert_parsed_expression_evaluate_to(const char * expression, Complex * results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit) { - Evaluation * m = parse_expression(expression, angleUnit); assert(m->numberOfRows() == numberOfRows); assert(m->numberOfColumns() == numberOfColumns); - check_results(m, results); + for (int i = 0; i < m->numberOfOperands(); i++) { + assert(std::fabs(m->complexOperand(i)->a() - results[i].a()) < 0.0001f); + assert(std::fabs(m->complexOperand(i)->b() - results[i].b()) < 0.0001f); + } + delete a; delete m; } -template void assert_parsed_expression_evaluate_to(char const*, Poincare::Complex*, int, Poincare::Expression::AngleUnit); -template void assert_parsed_expression_evaluate_to(char const*, Poincare::Complex*, int, Poincare::Expression::AngleUnit); template void assert_parsed_expression_evaluate_to(char const*, Poincare::Complex*, int, int, Poincare::Expression::AngleUnit); template void assert_parsed_expression_evaluate_to(char const*, Poincare::Complex*, int, int, Poincare::Expression::AngleUnit); diff --git a/poincare/test/helper.h b/poincare/test/helper.h index bea89f063..ccac78a74 100644 --- a/poincare/test/helper.h +++ b/poincare/test/helper.h @@ -4,6 +4,8 @@ constexpr Poincare::Expression::AngleUnit Degree = Poincare::Expression::AngleUn constexpr Poincare::Expression::AngleUnit Radian = Poincare::Expression::AngleUnit::Radian; template -void assert_parsed_expression_evaluate_to(const char * expression, Poincare::Complex * results, int numberOfEntries, Poincare::Expression::AngleUnit angleUnit = Degree); +void assert_parsed_expression_evaluate_to(const char * expression, Poincare::Complex * results, int numberOfRows, int numberOfColumns = 1, Poincare::Expression::AngleUnit angleUnit = Degree); template -void assert_parsed_expression_evaluate_to(const char * expression, Poincare::Complex * results, int numberOfRows, int numberOfColumns, Poincare::Expression::AngleUnit angleUnit = Degree); +void assert_parsed_expression_evaluate_to(const char * expression, Poincare::Complex * results, Poincare::Expression::AngleUnit angleUnit = Degree) { + assert_parsed_expression_evaluate_to(expression, results, 1, 1, angleUnit); +} diff --git a/poincare/test/parser.cpp b/poincare/test/parser.cpp index 860f9cb50..f03a4039b 100644 --- a/poincare/test/parser.cpp +++ b/poincare/test/parser.cpp @@ -9,29 +9,29 @@ using namespace Poincare; QUIZ_CASE(poincare_parser) { Complex a[1] = {Complex::Float(1.2*M_E)}; - assert_parsed_expression_evaluate_to("1.2*X^(1)", a, 1); + assert_parsed_expression_evaluate_to("1.2*X^(1)", a); Complex b[1] = {Complex::Float(std::pow((float)M_E, 2.0f)*M_E)}; - assert_parsed_expression_evaluate_to("X^2*X^(1)", b, 1); + assert_parsed_expression_evaluate_to("X^2*X^(1)", b); Complex c[1] = {Complex::Float(2.0*std::pow(3.0, 4.0)+2.0)}; - assert_parsed_expression_evaluate_to("2*3^4+2", c, 1); + assert_parsed_expression_evaluate_to("2*3^4+2", c); Complex d[1] = {Complex::Float(-2.0f*std::pow(3.0f, 4.0f)+2.0f)}; - assert_parsed_expression_evaluate_to("-2*3^4+2", d,1); + assert_parsed_expression_evaluate_to("-2*3^4+2", d); Complex e[1] = {Complex::Float(-std::sin(3.0)*2.0-3.0)}; - assert_parsed_expression_evaluate_to("-sin(3)*2-3", e, 1, Radian); + assert_parsed_expression_evaluate_to("-sin(3)*2-3", e, Radian); Complex f[1] = {Complex::Float(-0.003f)}; - assert_parsed_expression_evaluate_to("-.003", f, 1); + assert_parsed_expression_evaluate_to("-.003", f); Complex g[1] = {Complex::Float(2.0)}; - assert_parsed_expression_evaluate_to(".02E2", g, 1); + assert_parsed_expression_evaluate_to(".02E2", g); Complex h[1] = {Complex::Float(5.0f-2.0f/3.0f)}; - assert_parsed_expression_evaluate_to("5-2/3", h, 1); + assert_parsed_expression_evaluate_to("5-2/3", h); Complex i[1] = {Complex::Float(2.0/3.0-5.0)}; - assert_parsed_expression_evaluate_to("2/3-5", i, 1); + assert_parsed_expression_evaluate_to("2/3-5", i); Complex j[1] = {Complex::Float(-2.0f/3.0f-5.0f)}; - assert_parsed_expression_evaluate_to("-2/3-5", j, 1); + assert_parsed_expression_evaluate_to("-2/3-5", j); Complex k[1] = {Complex::Float(std::sin(3.0)*2.0*(4.0+2.0))}; - assert_parsed_expression_evaluate_to("sin(3)2(4+2)", k, 1, Radian); + assert_parsed_expression_evaluate_to("sin(3)2(4+2)", k, Radian); Complex l[1] = {Complex::Float(4.0f/2.0f*(2.0f+3.0f))}; - assert_parsed_expression_evaluate_to("4/2*(2+3)", l, 1, Radian); + assert_parsed_expression_evaluate_to("4/2*(2+3)", l, Radian); Complex m[1] = {Complex::Float(4.0/2.0*(2.0+3.0))}; - assert_parsed_expression_evaluate_to("4/2*(2+3)", m, 1, Radian); + assert_parsed_expression_evaluate_to("4/2*(2+3)", m, Radian); } diff --git a/poincare/test/power.cpp b/poincare/test/power.cpp index 04ceac58d..daa6da7a2 100644 --- a/poincare/test/power.cpp +++ b/poincare/test/power.cpp @@ -8,13 +8,13 @@ using namespace Poincare; QUIZ_CASE(poincare_power_evaluate) { Complex a[1] = {Complex::Float(8.0f)}; - assert_parsed_expression_evaluate_to("2^3", a, 1); + assert_parsed_expression_evaluate_to("2^3", a); Complex b[1] = {Complex::Cartesian(28.0, 96.0)}; - assert_parsed_expression_evaluate_to("(3+I)^4", b, 1); + assert_parsed_expression_evaluate_to("(3+I)^4", b); Complex c[1] = {Complex::Cartesian(11.7412464f, 62.9137754f)}; - assert_parsed_expression_evaluate_to("4^(3+I)", c, 1); + assert_parsed_expression_evaluate_to("4^(3+I)", c); #if MATRICES_ARE_DEFINED Complex d[4] = {Complex::Float(37.0), Complex::Float(54.0), Complex::Float(81.0), Complex::Float(118.0)}; diff --git a/poincare/test/product.cpp b/poincare/test/product.cpp index c7e45bf65..f129ee11c 100644 --- a/poincare/test/product.cpp +++ b/poincare/test/product.cpp @@ -8,10 +8,10 @@ using namespace Poincare; QUIZ_CASE(poincare_product_evaluate) { Complex a[1] = {Complex::Float(2.0f)}; - assert_parsed_expression_evaluate_to("1*2", a, 1); + assert_parsed_expression_evaluate_to("1*2", a); Complex b[1] = {Complex::Cartesian(11.0, 7.0)}; - assert_parsed_expression_evaluate_to("(3+I)*(4+I)", b, 1); + assert_parsed_expression_evaluate_to("(3+I)*(4+I)", b); #if MATRICES_ARE_DEFINED Complex c[6] = {Complex::Float(2.0f), Complex::Float(4.0f), Complex::Float(6.0f), Complex::Float(8.0f), Complex::Float(10.0f), Complex::Float(12.0f)}; diff --git a/poincare/test/subtraction.cpp b/poincare/test/subtraction.cpp index 30d6d589a..598fdf433 100644 --- a/poincare/test/subtraction.cpp +++ b/poincare/test/subtraction.cpp @@ -8,10 +8,10 @@ using namespace Poincare; QUIZ_CASE(poincare_substraction_evaluate) { Complex a[1] = {Complex::Float(-1.0f)}; - assert_parsed_expression_evaluate_to("1-2", a, 1); + assert_parsed_expression_evaluate_to("1-2", a); Complex b[1] = {Complex::Cartesian(-1.0, 0.0)}; - assert_parsed_expression_evaluate_to("3+I-(4+I)", b, 1); + assert_parsed_expression_evaluate_to("3+I-(4+I)", b); #if MATRICES_ARE_DEFINED Complex c[6] = {Complex::Float(-2.0f), Complex::Float(-1.0f), Complex::Float(0.0f), Complex::Float(1.0f), Complex::Float(2.0f), Complex::Float(3.0f)}; diff --git a/poincare/test/symbol.cpp b/poincare/test/symbol.cpp index 0d34c9dbe..5d5f1268f 100644 --- a/poincare/test/symbol.cpp +++ b/poincare/test/symbol.cpp @@ -36,10 +36,10 @@ QUIZ_CASE(poincare_parse_symbol) { QUIZ_CASE(poincare_symbol_approximate) { Complex a[1] = {Complex::Float(M_PI)}; - assert_parsed_expression_evaluate_to("P", a, 1); + assert_parsed_expression_evaluate_to("P", a); Complex b[1] = {Complex::Float(M_E)}; - assert_parsed_expression_evaluate_to("X", b, 1); + assert_parsed_expression_evaluate_to("X", b); Complex c[1] = {Complex::Float(1200.0)}; - assert_parsed_expression_evaluate_to("1.2E3", c, 1); + assert_parsed_expression_evaluate_to("1.2E3", c); } diff --git a/poincare/test/trigo.cpp b/poincare/test/trigo.cpp index 705eb888d..b20e2370a 100644 --- a/poincare/test/trigo.cpp +++ b/poincare/test/trigo.cpp @@ -95,27 +95,27 @@ QUIZ_CASE(poincare_parse_trigo) { QUIZ_CASE(poincare_trigo_evaluate) { Complex a[1] = {Complex::Float(-0.4161468365)}; - assert_parsed_expression_evaluate_to("cos(2)", a, 1, Radian); + assert_parsed_expression_evaluate_to("cos(2)", a, Radian); Complex a1[1] = {Complex::Cartesian(-1.0086248134f, -0.8893951958f)}; - assert_parsed_expression_evaluate_to("cos(I-4)", a1, 1, Radian); + assert_parsed_expression_evaluate_to("cos(I-4)", a1, Radian); Complex b[1] = {Complex::Float(0.9092974268)}; - assert_parsed_expression_evaluate_to("sin(2)", b, 1, Radian); + assert_parsed_expression_evaluate_to("sin(2)", b, Radian); Complex b1[1] = {Complex::Cartesian( 1.16780727488f, -0.768162763456f)}; - assert_parsed_expression_evaluate_to("sin(I-4)", b1, 1, Radian); + assert_parsed_expression_evaluate_to("sin(I-4)", b1, Radian); Complex c[1] = {Complex::Float(-2.18503986326151899)}; - assert_parsed_expression_evaluate_to("tan(2)", c, 1, Radian); + assert_parsed_expression_evaluate_to("tan(2)", c, Radian); Complex c1[1] = {Complex::Cartesian(-0.27355308280730f, 1.002810507583504f)}; - assert_parsed_expression_evaluate_to("tan(I-4)", c1, 1, Radian); + assert_parsed_expression_evaluate_to("tan(I-4)", c1, Radian); Complex a2[1] = {Complex::Float(3.762195691)}; - assert_parsed_expression_evaluate_to("cosh(2)", a2, 1, Radian); + assert_parsed_expression_evaluate_to("cosh(2)", a2, Radian); Complex a3[1] = {Complex::Cartesian(14.754701170483756280f,-22.96367349919304059f)}; - assert_parsed_expression_evaluate_to("cosh(I-4)", a3, 1, Radian); + assert_parsed_expression_evaluate_to("cosh(I-4)", a3, Radian); Complex b2[1] = {Complex::Float(3.62686040784701876)}; - assert_parsed_expression_evaluate_to("sinh(2)", b2, 1, Radian); + assert_parsed_expression_evaluate_to("sinh(2)", b2, Radian); Complex b3[1] = {Complex::Cartesian(-14.744805188558725031023f, 22.979085577886129555168f)}; - assert_parsed_expression_evaluate_to("sinh(I-4)", b3, 1, Radian); + assert_parsed_expression_evaluate_to("sinh(I-4)", b3, Radian); Complex c2[1] = {Complex::Float(0.9640275800758168839464)}; - assert_parsed_expression_evaluate_to("tanh(2)", c2, 1, Radian); + assert_parsed_expression_evaluate_to("tanh(2)", c2, Radian); Complex c3[1] = {Complex::Cartesian(-1.00027905623446556836909f, 0.000610240921376259f)}; - assert_parsed_expression_evaluate_to("tanh(I-4)", c3, 1, Radian); + assert_parsed_expression_evaluate_to("tanh(I-4)", c3, Radian); }