UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-03-18 21:30:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

Default expression tests to scalar.

Browse Source
This commit is contained in:
Jacob Young
2017-08-31 18:04:56 -04:00
parent 303120c7e2
commit 37700f9e11
11 changed files with 79 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
poincare/test/addition.cpp
View File

@@ -8,10 +8,10 @@ using namespace Poincare;
QUIZ_CASE(poincare_addition_evaluate) {
Complex<float> a[1] = {Complex<float>::Float(3.0f)};
assert_parsed_expression_evaluate_to("1+2", a, 1);
assert_parsed_expression_evaluate_to("1+2", a);
Complex<double> b[1] = {Complex<double>::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<float> c[6] = {Complex<float>::Float(4.0f), Complex<float>::Float(5.0f), Complex<float>::Float(6.0f), Complex<float>::Float(7.0f), Complex<float>::Float(8.0f), Complex<float>::Float(9.0f)};

4
poincare/test/fraction.cpp
View File

@@ -9,10 +9,10 @@ using namespace Poincare;
QUIZ_CASE(poincare_fraction_evaluate) {
Complex<float> a[1] = {Complex<float>::Float(0.5f)};
assert_parsed_expression_evaluate_to("1/2", a, 1);
assert_parsed_expression_evaluate_to("1/2", a);
Complex<double> b[1] = {Complex<double>::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<float> c[6] = {Complex<float>::Float(0.5f), Complex<float>::Float(1.0f), Complex<float>::Float(1.5f), Complex<float>::Float(2.0f), Complex<float>::Float(2.5f), Complex<float>::Float(3.0f)};

60
poincare/test/function.cpp
View File

@@ -150,10 +150,10 @@ QUIZ_CASE(poincare_parse_function) {
QUIZ_CASE(poincare_function_evaluate) {
Complex<double> a0[1] = {Complex<double>::Float(1.0)};
assert_parsed_expression_evaluate_to("abs(-1)", a0, 1);
assert_parsed_expression_evaluate_to("abs(-1)", a0);
Complex<float> a1[1] = {Complex<float>::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<double> a2[4] = {Complex<double>::Float(1.0), Complex<double>::Float(2.0), Complex<double>::Float(3.0), Complex<double>::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<double> b[1] = {Complex<double>::Float(210.0)};
assert_parsed_expression_evaluate_to("binomial(10, 4)", b, 1);
assert_parsed_expression_evaluate_to("binomial(10, 4)", b);
Complex<float> c[1] = {Complex<float>::Float(1.0f)};
assert_parsed_expression_evaluate_to("ceil(0.2)", c, 1);
assert_parsed_expression_evaluate_to("ceil(0.2)", c);
Complex<double> d[1] = {Complex<double>::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<float> e[1] = {Complex<float>::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<double> f[1] = {Complex<double>::Float(2.0)};
assert_parsed_expression_evaluate_to("floor(2.3)", f, 1);
assert_parsed_expression_evaluate_to("floor(2.3)", f);
Complex<float> g[1] = {Complex<float>::Float(0.3f)};
assert_parsed_expression_evaluate_to("frac(2.3)", g, 1);
assert_parsed_expression_evaluate_to("frac(2.3)", g);
Complex<double> h[1] = {Complex<double>::Float(2.0)};
assert_parsed_expression_evaluate_to("gcd(234,394)", h, 1);
assert_parsed_expression_evaluate_to("gcd(234,394)", h);
Complex<float> i[1] = {Complex<float>::Float(3.0f)};
assert_parsed_expression_evaluate_to("im(2+3I)", i, 1);
assert_parsed_expression_evaluate_to("im(2+3I)", i);
Complex<double> j[1] = {Complex<double>::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<float> k[1] = {Complex<float>::Float(46098.0f)};
assert_parsed_expression_evaluate_to("lcm(234,394)", k, 1);
assert_parsed_expression_evaluate_to("lcm(234,394)", k);
Complex<double> l[1] = {Complex<double>::Float(std::log(2.0))};
assert_parsed_expression_evaluate_to("ln(2)", l, 1);
assert_parsed_expression_evaluate_to("ln(2)", l);
Complex<float> m[1] = {Complex<float>::Float(std::log10(2.0f))};
assert_parsed_expression_evaluate_to("log(2)", m, 1);
assert_parsed_expression_evaluate_to("log(2)", m);
Complex<double> n[1] = {Complex<double>::Float(5040.0)};
assert_parsed_expression_evaluate_to("permute(10, 4)", n, 1);
assert_parsed_expression_evaluate_to("permute(10, 4)", n);
Complex<float> o[1] = {Complex<float>::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<double> p[1] = {Complex<double>::Float(2.0)};
assert_parsed_expression_evaluate_to("re(2+I)", p, 1);
assert_parsed_expression_evaluate_to("re(2+I)", p);
Complex<float> q[1] = {Complex<float>::Float(9.0f)};
assert_parsed_expression_evaluate_to("rem(29, 10)", q, 1);
assert_parsed_expression_evaluate_to("rem(29, 10)", q);
Complex<double> r[1] = {Complex<double>::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<float> s[1] = {Complex<float>::Float(std::sqrt(2.0f))};
assert_parsed_expression_evaluate_to("R(2)", s, 1);
assert_parsed_expression_evaluate_to("R(2)", s);
Complex<double> t[1] = {Complex<double>::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<float> u[1] = {Complex<float>::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<double> v[2] = {Complex<double>::Float(0.1 - std::sqrt(1.0/100.0)), Complex<double>::Float(0.1 + std::sqrt(1.0/100.0))};
@@ -234,7 +234,7 @@ QUIZ_CASE(poincare_function_evaluate) {
#endif
Complex<double> x[1] = {Complex<double>::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<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)};
@@ -248,19 +248,19 @@ QUIZ_CASE(poincare_function_evaluate) {
assert_parsed_expression_evaluate_to("prediction95(0.1, 100)", aa, 2);
Complex<double> ab[1] = {Complex<double>::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<float> ac[1] = {Complex<float>::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<double> ad[1] = {Complex<double>::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<float> ae[1] = {Complex<float>::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<double> af[1] = {Complex<double>::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<double> ag[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)};
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<float> ah[1] = {Complex<float>::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<double> ai[1] = {Complex<double>::Float(720.0f)};
assert_parsed_expression_evaluate_to("6!", ai, 1);
assert_parsed_expression_evaluate_to("6!", ai);
}

33
poincare/test/helper.cpp
View File

@@ -9,7 +9,7 @@
using namespace Poincare;
template<typename T>
static Evaluation<T> * parse_expression(const char * expression, Expression::AngleUnit angleUnit) {
void assert_parsed_expression_evaluate_to(const char * expression, Complex<T> * results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit) {
char buffer[200];
strlcpy(buffer, expression, 200);
for (size_t i=0; i<strlen(buffer); i++) {
@@ -32,36 +32,15 @@ static Evaluation<T> * parse_expression(const char * expression, Expression::Ang
GlobalContext globalContext;
Expression * a = Expression::parse(buffer);
Evaluation<T> * m = a->evaluate<T>(globalContext, angleUnit);
delete a;
return m;
}
template<typename T>
static void check_results(Evaluation<T> * actual, Complex<T> * 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<typename T>
void assert_parsed_expression_evaluate_to(const char * expression, Complex<T> * results, int numberOfEntries, Expression::AngleUnit angleUnit) {
Evaluation<T> * m = parse_expression<T>(expression, angleUnit);
assert(m->numberOfOperands() == numberOfEntries);
check_results(m, results);
delete m;
}
template<typename T>
void assert_parsed_expression_evaluate_to(const char * expression, Complex<T> * results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit) {
Evaluation<T> * m = parse_expression<T>(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<float>(char const*, Poincare::Complex<float>*, int, Poincare::Expression::AngleUnit);
template void assert_parsed_expression_evaluate_to<double>(char const*, Poincare::Complex<double>*, int, Poincare::Expression::AngleUnit);
template void assert_parsed_expression_evaluate_to<float>(char const*, Poincare::Complex<float>*, int, int, Poincare::Expression::AngleUnit);
template void assert_parsed_expression_evaluate_to<double>(char const*, Poincare::Complex<double>*, int, int, Poincare::Expression::AngleUnit);

6
poincare/test/helper.h
View File

@@ -4,6 +4,8 @@ constexpr Poincare::Expression::AngleUnit Degree = Poincare::Expression::AngleUn
constexpr Poincare::Expression::AngleUnit Radian = Poincare::Expression::AngleUnit::Radian;
template<typename T>
void assert_parsed_expression_evaluate_to(const char * expression, Poincare::Complex<T> * results, int numberOfEntries, Poincare::Expression::AngleUnit angleUnit = Degree);
void assert_parsed_expression_evaluate_to(const char * expression, Poincare::Complex<T> * results, int numberOfRows, int numberOfColumns = 1, Poincare::Expression::AngleUnit angleUnit = Degree);
template<typename T>
void assert_parsed_expression_evaluate_to(const char * expression, Poincare::Complex<T> * results, int numberOfRows, int numberOfColumns, Poincare::Expression::AngleUnit angleUnit = Degree);
void assert_parsed_expression_evaluate_to(const char * expression, Poincare::Complex<T> * results, Poincare::Expression::AngleUnit angleUnit = Degree) {
assert_parsed_expression_evaluate_to(expression, results, 1, 1, angleUnit);
}

26
poincare/test/parser.cpp
View File

@@ -9,29 +9,29 @@ using namespace Poincare;
QUIZ_CASE(poincare_parser) {
Complex<double> a[1] = {Complex<double>::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<float> b[1] = {Complex<float>::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<double> c[1] = {Complex<double>::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<float> d[1] = {Complex<float>::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<double> e[1] = {Complex<double>::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<float> f[1] = {Complex<float>::Float(-0.003f)};
assert_parsed_expression_evaluate_to("-.003", f, 1);
assert_parsed_expression_evaluate_to("-.003", f);
Complex<double> g[1] = {Complex<double>::Float(2.0)};
assert_parsed_expression_evaluate_to(".02E2", g, 1);
assert_parsed_expression_evaluate_to(".02E2", g);
Complex<float> h[1] = {Complex<float>::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<double> i[1] = {Complex<double>::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<float> j[1] = {Complex<float>::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<double> k[1] = {Complex<double>::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<float> l[1] = {Complex<float>::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<double> m[1] = {Complex<double>::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);
}

6
poincare/test/power.cpp
View File

@@ -8,13 +8,13 @@ using namespace Poincare;
QUIZ_CASE(poincare_power_evaluate) {
Complex<float> a[1] = {Complex<float>::Float(8.0f)};
assert_parsed_expression_evaluate_to("2^3", a, 1);
assert_parsed_expression_evaluate_to("2^3", a);
Complex<double> b[1] = {Complex<double>::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<float> c[1] = {Complex<float>::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<double> d[4] = {Complex<double>::Float(37.0), Complex<double>::Float(54.0), Complex<double>::Float(81.0), Complex<double>::Float(118.0)};

4
poincare/test/product.cpp
View File

@@ -8,10 +8,10 @@ using namespace Poincare;
QUIZ_CASE(poincare_product_evaluate) {
Complex<float> a[1] = {Complex<float>::Float(2.0f)};
assert_parsed_expression_evaluate_to("1*2", a, 1);
assert_parsed_expression_evaluate_to("1*2", a);
Complex<double> b[1] = {Complex<double>::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<float> c[6] = {Complex<float>::Float(2.0f), Complex<float>::Float(4.0f), Complex<float>::Float(6.0f), Complex<float>::Float(8.0f), Complex<float>::Float(10.0f), Complex<float>::Float(12.0f)};

4
poincare/test/subtraction.cpp
View File

@@ -8,10 +8,10 @@ using namespace Poincare;
QUIZ_CASE(poincare_substraction_evaluate) {
Complex<float> a[1] = {Complex<float>::Float(-1.0f)};
assert_parsed_expression_evaluate_to("1-2", a, 1);
assert_parsed_expression_evaluate_to("1-2", a);
Complex<double> b[1] = {Complex<double>::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<float> c[6] = {Complex<float>::Float(-2.0f), Complex<float>::Float(-1.0f), Complex<float>::Float(0.0f), Complex<float>::Float(1.0f), Complex<float>::Float(2.0f), Complex<float>::Float(3.0f)};

6
poincare/test/symbol.cpp
View File

@@ -36,10 +36,10 @@ QUIZ_CASE(poincare_parse_symbol) {
QUIZ_CASE(poincare_symbol_approximate) {
Complex<double> a[1] = {Complex<double>::Float(M_PI)};
assert_parsed_expression_evaluate_to("P", a, 1);
assert_parsed_expression_evaluate_to("P", a);
Complex<float> b[1] = {Complex<float>::Float(M_E)};
assert_parsed_expression_evaluate_to("X", b, 1);
assert_parsed_expression_evaluate_to("X", b);
Complex<double> c[1] = {Complex<double>::Float(1200.0)};
assert_parsed_expression_evaluate_to("1.2E3", c, 1);
assert_parsed_expression_evaluate_to("1.2E3", c);
}

24
poincare/test/trigo.cpp
View File

@@ -95,27 +95,27 @@ QUIZ_CASE(poincare_parse_trigo) {
QUIZ_CASE(poincare_trigo_evaluate) {
Complex<double> a[1] = {Complex<double>::Float(-0.4161468365)};
assert_parsed_expression_evaluate_to("cos(2)", a, 1, Radian);
assert_parsed_expression_evaluate_to("cos(2)", a, Radian);
Complex<float> a1[1] = {Complex<float>::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<double> b[1] = {Complex<double>::Float(0.9092974268)};
assert_parsed_expression_evaluate_to("sin(2)", b, 1, Radian);
assert_parsed_expression_evaluate_to("sin(2)", b, Radian);
Complex<float> b1[1] = {Complex<float>::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<double> c[1] = {Complex<double>::Float(-2.18503986326151899)};
assert_parsed_expression_evaluate_to("tan(2)", c, 1, Radian);
assert_parsed_expression_evaluate_to("tan(2)", c, Radian);
Complex<float> c1[1] = {Complex<float>::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<double> a2[1] = {Complex<double>::Float(3.762195691)};
assert_parsed_expression_evaluate_to("cosh(2)", a2, 1, Radian);
assert_parsed_expression_evaluate_to("cosh(2)", a2, Radian);
Complex<float> a3[1] = {Complex<float>::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<double> b2[1] = {Complex<double>::Float(3.62686040784701876)};
assert_parsed_expression_evaluate_to("sinh(2)", b2, 1, Radian);
assert_parsed_expression_evaluate_to("sinh(2)", b2, Radian);
Complex<float> b3[1] = {Complex<float>::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<double> c2[1] = {Complex<double>::Float(0.9640275800758168839464)};
assert_parsed_expression_evaluate_to("tanh(2)", c2, 1, Radian);
assert_parsed_expression_evaluate_to("tanh(2)", c2, Radian);
Complex<float> c3[1] = {Complex<float>::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);
}