diff --git a/apps/calculation/test/calculation_store.cpp b/apps/calculation/test/calculation_store.cpp index c64fdd9ac..e241fc4b5 100644 --- a/apps/calculation/test/calculation_store.cpp +++ b/apps/calculation/test/calculation_store.cpp @@ -97,13 +97,13 @@ QUIZ_CASE(calculation_display_exact_approximate) { assertCalculationDisplay("[[1,2,3]]", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store); assertCalculationDisplay("[[1,x,3]]", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store); assertCalculationDisplay("28^7", false, false, ::Calculation::Calculation::EqualSign::Unknown, nullptr, nullptr, &globalContext, &store); - assertCalculationDisplay("3+R(2)>a", false, false, ::Calculation::Calculation::EqualSign::Approximation, "R(2)+3", nullptr, &globalContext, &store); + assertCalculationDisplay("3+√(2)→a", false, false, ::Calculation::Calculation::EqualSign::Approximation, "√(2)+3", nullptr, &globalContext, &store); Ion::Storage::sharedStorage()->recordNamed("a.exp").destroy(); - assertCalculationDisplay("3+2>a", false, true, ::Calculation::Calculation::EqualSign::Equal, "5", "5", &globalContext, &store); + assertCalculationDisplay("3+2→a", false, true, ::Calculation::Calculation::EqualSign::Equal, "5", "5", &globalContext, &store); Ion::Storage::sharedStorage()->recordNamed("a.exp").destroy(); - assertCalculationDisplay("3>a", false, true, ::Calculation::Calculation::EqualSign::Equal, "3", "3", &globalContext, &store); + assertCalculationDisplay("3→a", false, true, ::Calculation::Calculation::EqualSign::Equal, "3", "3", &globalContext, &store); Ion::Storage::sharedStorage()->recordNamed("a.exp").destroy(); - assertCalculationDisplay("3+x>f(x)", true, false, ::Calculation::Calculation::EqualSign::Unknown, "x+3", nullptr, &globalContext, &store); + assertCalculationDisplay("3+x→f(x)", true, false, ::Calculation::Calculation::EqualSign::Unknown, "x+3", nullptr, &globalContext, &store); Ion::Storage::sharedStorage()->recordNamed("f.func").destroy(); } @@ -112,31 +112,31 @@ QUIZ_CASE(calculation_complex_format) { CalculationStore store; Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Real); - assertCalculationDisplay("1+I", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "1+I", &globalContext, &store); - assertCalculationDisplay("R(-1)", false, true, ::Calculation::Calculation::EqualSign::Unknown, "unreal", nullptr, &globalContext, &store); + assertCalculationDisplay("1+𝐢", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "1+𝐢", &globalContext, &store); + assertCalculationDisplay("√(-1)", false, true, ::Calculation::Calculation::EqualSign::Unknown, "unreal", nullptr, &globalContext, &store); assertCalculationDisplay("ln(-2)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "unreal", &globalContext, &store); - assertCalculationDisplay("R(-1)*R(-1)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "unreal", &globalContext, &store); + assertCalculationDisplay("√(-1)×√(-1)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "unreal", &globalContext, &store); assertCalculationDisplay("(-8)^(1/3)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "-2", &globalContext, &store); assertCalculationDisplay("(-8)^(2/3)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "4", &globalContext, &store); assertCalculationDisplay("(-2)^(1/4)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "unreal", &globalContext, &store); Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Cartesian); - assertCalculationDisplay("1+I", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "1+I", &globalContext, &store); - assertCalculationDisplay("R(-1)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "I", &globalContext, &store); + assertCalculationDisplay("1+𝐢", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "1+𝐢", &globalContext, &store); + assertCalculationDisplay("√(-1)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "𝐢", &globalContext, &store); assertCalculationDisplay("ln(-2)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "ln(-2)", nullptr, &globalContext, &store); - assertCalculationDisplay("R(-1)*R(-1)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "-1", &globalContext, &store); - assertCalculationDisplay("(-8)^(1/3)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "1+R(3)*I", nullptr, &globalContext, &store); - assertCalculationDisplay("(-8)^(2/3)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "-2+2*R(3)*I", nullptr, &globalContext, &store); - assertCalculationDisplay("(-2)^(1/4)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "root(8,4)/2+root(8,4)/2*I", nullptr, &globalContext, &store); + assertCalculationDisplay("√(-1)×√(-1)", false, true, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "-1", &globalContext, &store); + assertCalculationDisplay("(-8)^(1/3)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "1+√(3)×𝐢", nullptr, &globalContext, &store); + assertCalculationDisplay("(-8)^(2/3)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "-2+2×√(3)×𝐢", nullptr, &globalContext, &store); + assertCalculationDisplay("(-2)^(1/4)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "root(8,4)/2+root(8,4)/2×𝐢", nullptr, &globalContext, &store); Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Polar); - assertCalculationDisplay("1+I", false, false, ::Calculation::Calculation::EqualSign::Approximation, "R(2)*X^(P/4*I)", nullptr, &globalContext, &store); - assertCalculationDisplay("R(-1)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "X^(P/2*I)", nullptr, &globalContext, &store); + assertCalculationDisplay("1+𝐢", false, false, ::Calculation::Calculation::EqualSign::Approximation, "√(2)×ℯ^(π/4×𝐢)", nullptr, &globalContext, &store); + assertCalculationDisplay("√(-1)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "ℯ^(π/2×𝐢)", nullptr, &globalContext, &store); assertCalculationDisplay("ln(-2)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "ln(-2)", nullptr, &globalContext, &store); - assertCalculationDisplay("R(-1)*R(-1)", false, false, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "X^(3.1415926535898*I)", &globalContext, &store); - assertCalculationDisplay("(-8)^(1/3)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "2*X^(P/3*I)", nullptr, &globalContext, &store); - assertCalculationDisplay("(-8)^(2/3)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "4*X^((2*P)/3*I)", nullptr, &globalContext, &store); - assertCalculationDisplay("(-2)^(1/4)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "root(2,4)*X^(P/4*I)", nullptr, &globalContext, &store); + assertCalculationDisplay("√(-1)×√(-1)", false, false, ::Calculation::Calculation::EqualSign::Unknown, nullptr, "ℯ^(3.1415926535898×𝐢)", &globalContext, &store); + assertCalculationDisplay("(-8)^(1/3)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "2×ℯ^(π/3×𝐢)", nullptr, &globalContext, &store); + assertCalculationDisplay("(-8)^(2/3)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "4×ℯ^((2×π)/3×𝐢)", nullptr, &globalContext, &store); + assertCalculationDisplay("(-2)^(1/4)", false, false, ::Calculation::Calculation::EqualSign::Approximation, "root(2,4)×ℯ^(π/4×𝐢)", nullptr, &globalContext, &store); Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Cartesian); } diff --git a/apps/solver/test/equation_store.cpp b/apps/solver/test/equation_store.cpp index 2053defb6..bd86b7569 100644 --- a/apps/solver/test/equation_store.cpp +++ b/apps/solver/test/equation_store.cpp @@ -36,8 +36,11 @@ void assert_equation_system_exact_solve_to(const char * equations[], EquationSto } else { quiz_assert(strcmp(equationStore.variableAtIndex(0), variables[0]) == 0); } + constexpr int bufferSize = 200; + char buffer[bufferSize]; for (int i = 0; i < numberOfSolutions; i++) { - quiz_assert(strcmp(equationStore.exactSolutionLayoutAtIndex(i, true), solutions[i]) == 0); + equationStore.exactSolutionLayoutAtIndex(i, true).serializeForParsing(buffer, bufferSize); + quiz_assert(strcmp(buffer, solutions[i]) == 0); } } @@ -95,29 +98,34 @@ QUIZ_CASE(equation_solve) { assert_equation_system_exact_solve_to(equations7, EquationStore::Error::NoError, EquationStore::Type::LinearSystem, (const char **)variablesx, solutions7, 1); // 3x^2-4x+4=2 - const char * equations8[] = {"3*x^2-4x+4=2", 0}; - const char * solutions8[] = {"(2)/(3)-(R(2))/(3)*I","(2)/(3)+(R(2))/(3)*I", "-8"}; + const char * equations8[] = {"3×x^2-4x+4=2", 0}; + const char * solutions8[] = {"(2)/(3)-(√(2))/(3)·𝐢","(2)/(3)+(√(2))/(3)·𝐢", "-8"}; assert_equation_system_exact_solve_to(equations8, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, solutions8, 3); - // 2*x^2-4*x+4=3 - const char * equations9[] = {"2*x^2-4*x+4=3", 0}; - const char * solutions9[] = {"(-R(2)+2)/(2)","(R(2)+2)/(2)", "8"}; + // 2×x^2-4×x+4=3 + const char * equations9[] = {"2×x^2-4×x+4=3", 0}; + const char * solutions9[] = {"(-√(2)+2)/(2)","(√(2)+2)/(2)", "8"}; assert_equation_system_exact_solve_to(equations9, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, solutions9, 3); - // 2*x^2-4*x+2=0 - const char * equations10[] = {"2*x^2-4*x+2=0", 0}; + // 2×x^2-4×x+2=0 + const char * equations10[] = {"2×x^2-4×x+2=0", 0}; const char * solutions10[] = {"1", "0"}; assert_equation_system_exact_solve_to(equations10, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, solutions10, 2); - // x^2+x+1=3*x^2+pi*x-R(5) - const char * equations11[] = {"x^2+x+1=3*x^2+P*x-R(5)", 0}; - const char * solutions11[] = {"(R(P$2#-2*P+8*R(5)+9)-P+1)/(4)", "(-R(P$2#-2*P+8*R(5)+9)-P+1)/(4)", "P$2#-2*P+8*R(5)+9"}; + quiz_assert(KDCodePointLeftSuperscript == '\022'); + quiz_assert(KDCodePointLeftSuperscript == '\x12'); + quiz_assert(KDCodePointRightSuperscript == '\023'); + quiz_assert(KDCodePointRightSuperscript == '\x13'); + + // x^2+x+1=3×x^2+pi×x-√(5) + const char * equations11[] = {"x^2+x+1=3×x^2+π×x-√(5)", 0}; + const char * solutions11[] = {"(√(π\0222\023-2·π+8·√(5)+9)-π+1)/(4)", "(-√(π\0222\023-2·π+8·√(5)+9)-π+1)/(4)", "π\0222\023-2·π+8·√(5)+9"}; assert_equation_system_exact_solve_to(equations11, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, solutions11, 3); // TODO // x^3 - 4x^2 + 6x - 24 = 0 - //const char * equations10[] = {"2*x^2-4*x+4=3", 0}; - //assert_equation_system_exact_solve_to(equations10, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, {"x", ""}, {"4", "I*R(6)", "-I*R(6)", "-11616"}, 4); + //const char * equations10[] = {"2×x^2-4×x+4=3", 0}; + //assert_equation_system_exact_solve_to(equations10, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, {"x", ""}, {"4", "𝐢×√(6)", "-𝐢×√(6)", "-11616"}, 4); //x^3+x^2+1=0 // x^3-3x-2=0 @@ -134,8 +142,8 @@ QUIZ_CASE(equation_solve) { const char * variablesxyz[] = {"x", "y", "z", ""}; - const char * equations14[] = {"x+y=0", "3x+y+z=-5", "4z-P=0", 0}; - const char * solutions14[] = {"(-P-20)/(8)", "(P+20)/(8)", "(P)/(4)"}; + const char * equations14[] = {"x+y=0", "3x+y+z=-5", "4z-π=0", 0}; + const char * solutions14[] = {"(-π-20)/(8)", "(π+20)/(8)", "(π)/(4)"}; assert_equation_system_exact_solve_to(equations14, EquationStore::Error::NoError, EquationStore::Type::LinearSystem, (const char **)variablesxyz, solutions14, 3); // Monovariable non-polynomial equation @@ -146,7 +154,7 @@ QUIZ_CASE(equation_solve) { assert_equation_approximate_solve_to("cos(x)=0", -900.0, 1000.0, "x", solutions16, 10, true); double solutions17[] = {0}; - assert_equation_approximate_solve_to("R(y)=0", -900.0, 1000.0, "y", solutions17, 1, false); + assert_equation_approximate_solve_to("√(y)=0", -900.0, 1000.0, "y", solutions17, 1, false); // Long variable names const char * variablesabcde[] = {"abcde", ""}; @@ -163,13 +171,13 @@ QUIZ_CASE(equation_solve) { QUIZ_CASE(equation_solve_complex_format) { Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Real); const char * variablesx[] = {"x", ""}; - // x+I = 0 --> x = -I - const char * equations0[] = {"x+I=0", 0}; - const char * solutions0[] = {"-I"}; + // x+I = 0 --> x = -𝐢 + const char * equations0[] = {"x+𝐢=0", 0}; + const char * solutions0[] = {"-𝐢"}; assert_equation_system_exact_solve_to(equations0, EquationStore::Error::NoError, EquationStore::Type::LinearSystem, (const char **)variablesx, solutions0, 1); - // x+R(-1) = 0 --> Not defined in R - const char * equations1[] = {"x+R(-1)=0", 0}; + // x+√(-1) = 0 --> Not defined in R + const char * equations1[] = {"x+√(-1)=0", 0}; assert_equation_system_exact_solve_to(equations1, EquationStore::Error::EquationUnreal, EquationStore::Type::LinearSystem, (const char **)variablesx, nullptr, 0); // x^2+x+1=0 --> No solution in R @@ -177,47 +185,47 @@ QUIZ_CASE(equation_solve_complex_format) { const char * delta2[] = {"-3"}; assert_equation_system_exact_solve_to(equations2, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, delta2, 1); - // x^2-R(-1)=0 --> Not defined in R - const char * equations3[] = {"x^2-R(-1)=0", 0}; + // x^2-√(-1)=0 --> Not defined in R + const char * equations3[] = {"x^2-√(-1)=0", 0}; assert_equation_system_exact_solve_to(equations3, EquationStore::Error::EquationUnreal, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, nullptr, 0); - // x+R(-1)*R(-1) = 0 --> Not defined in R - const char * equations4[] = {"x+R(-1)*R(-1)=0", 0}; + // x+√(-1)×√(-1) = 0 --> Not defined in R + const char * equations4[] = {"x+√(-1)×√(-1)=0", 0}; assert_equation_system_exact_solve_to(equations4, EquationStore::Error::EquationUnreal, EquationStore::Type::LinearSystem, (const char **)variablesx, nullptr, 0); Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Cartesian); - // x+I = 0 --> x = -I + // x+𝐢 = 0 --> x = -𝐢 assert_equation_system_exact_solve_to(equations0, EquationStore::Error::NoError, EquationStore::Type::LinearSystem, (const char **)variablesx, solutions0, 1); - // x+R(-1) = 0 --> x = -I + // x+√(-1) = 0 --> x = -𝐢 assert_equation_system_exact_solve_to(equations1, EquationStore::Error::NoError, EquationStore::Type::LinearSystem, (const char **)variablesx, solutions0, 1); // x^2+x+1=0 - const char * solutions2[] = {"-(1)/(2)-(R(3))/(2)*I","-(1)/(2)+(R(3))/(2)*I", "-3"}; + const char * solutions2[] = {"-(1)/(2)-(√(3))/(2)·𝐢","-(1)/(2)+(√(3))/(2)·𝐢", "-3"}; assert_equation_system_exact_solve_to(equations2, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, solutions2, 3); - // x^2-R(-1)=0 - const char * solutions3[] = {"-(R(2))/(2)-(R(2))/(2)*I", "(R(2))/(2)+(R(2))/(2)*I","4*I"}; + // x^2-√(-1)=0 + const char * solutions3[] = {"-(√(2))/(2)-(√(2))/(2)·𝐢", "(√(2))/(2)+(√(2))/(2)·𝐢","4·𝐢"}; assert_equation_system_exact_solve_to(equations3, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, solutions3, 3); - // x+R(-1)*R(-1) = 0 + // x+√(-1)×√(-1) = 0 const char * solutions4[] = {"1"}; assert_equation_system_exact_solve_to(equations4, EquationStore::Error::NoError, EquationStore::Type::LinearSystem, (const char **)variablesx, solutions4, 1); Poincare::Preferences::sharedPreferences()->setComplexFormat(Poincare::Preferences::ComplexFormat::Polar); - // x+I = 0 --> x = e^(-pi/2*i) - const char * solutions0Polar[] = {"X$-(P)/(2)*I#"}; + // x+𝐢 = 0 --> x = e^(-π/2×i) + const char * solutions0Polar[] = {"ℯ\x12-(π)/(2)·𝐢\x13"}; assert_equation_system_exact_solve_to(equations0, EquationStore::Error::NoError, EquationStore::Type::LinearSystem, (const char **)variablesx, solutions0Polar, 1); - // x+R(-1) = 0 --> x = e^(-pi/2*i) + // x+√(-1) = 0 --> x = e^(-π/2×𝐢) assert_equation_system_exact_solve_to(equations1, EquationStore::Error::NoError, EquationStore::Type::LinearSystem, (const char **)variablesx, solutions0Polar, 1); // x^2+x+1=0 - const char * solutions2Polar[] = {"X$-(2*P)/(3)*I#","X$(2*P)/(3)*I#", "3*X$P*I#"}; + const char * solutions2Polar[] = {"ℯ\x12-(2·π)/(3)·𝐢\x13","ℯ\x12(2·π)/(3)·𝐢\x13", "3·ℯ\x12π·𝐢\x13"}; assert_equation_system_exact_solve_to(equations2, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, solutions2Polar, 3); - // x^2-R(-1)=0 - const char * solutions3Polar[] = {"X$-(3*P)/(4)*I#", "X$(P)/(4)*I#", "4*X$(P)/(2)*I#"}; + // x^2-√(-1)=0 + const char * solutions3Polar[] = {"ℯ\x12-(3·π)/(4)·𝐢\x13", "ℯ\x12(π)/(4)·𝐢\x13", "4·ℯ\x12(π)/(2)·𝐢\x13"}; assert_equation_system_exact_solve_to(equations3, EquationStore::Error::NoError, EquationStore::Type::PolynomialMonovariable, (const char **)variablesx, solutions3Polar, 3); } diff --git a/kandinsky/test/utf8decoder.cpp b/kandinsky/test/utf8decoder.cpp deleted file mode 100644 index 3c649f3b7..000000000 --- a/kandinsky/test/utf8decoder.cpp +++ /dev/null @@ -1,15 +0,0 @@ -#include -#include - -void assert_decodes_to(const char * string, CodePoint c) { - UTF8Decoder d(string); - quiz_assert(d.nextCodePoint() == c); - quiz_assert(d.nextCodePoint() == 0); -} - -QUIZ_CASE(kandinsky_utf8_decoder) { - assert_decodes_to("\x20", 0x20); - assert_decodes_to("\xC2\xA2", 0xA2); - assert_decodes_to("\xED\x9F\xBF", 0xD7FF); - assert_decodes_to("\xCC\x81", 0x301); -} diff --git a/poincare/src/decimal.cpp b/poincare/src/decimal.cpp index fcad08c9a..c24095089 100644 --- a/poincare/src/decimal.cpp +++ b/poincare/src/decimal.cpp @@ -177,7 +177,7 @@ int DecimalNode::convertToText(char * buffer, int bufferSize, Preferences::Print return currentChar; } if (currentChar >= bufferSize-1) { return bufferSize-1; } - currentChar += SerializationHelper::CodePoint(buffer + currentChar, bufferSize - currentChar, KDCodePointScriptSmallE); + currentChar += SerializationHelper::CodePoint(buffer + currentChar, bufferSize - currentChar, KDCodePointLatinLetterSmallCapitalE); if (currentChar >= bufferSize-1) { return bufferSize-1; } currentChar += Integer(exponent).serialize(buffer+currentChar, bufferSize-currentChar); return currentChar; diff --git a/poincare/src/print_float.cpp b/poincare/src/print_float.cpp index af65a5d59..76f31560c 100644 --- a/poincare/src/print_float.cpp +++ b/poincare/src/print_float.cpp @@ -179,7 +179,7 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int bufferSize, in numberOfCharExponent++; } - /* Part III: print mantissa*10^exponent*/ + /* Part III: print mantissa*10^exponent */ int numberOfCharsForMantissaWithSign = f >= 0 ? numberOfCharsForMantissaWithoutSign : numberOfCharsForMantissaWithoutSign + 1; // Print mantissa assert(!dividend.isOverflow()); @@ -199,11 +199,11 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int bufferSize, in // Print exponent assert(numberOfCharsForMantissaWithSign < bufferSize); int currentNumberOfChar = numberOfCharsForMantissaWithSign; - currentNumberOfChar+= SerializationHelper::CodePoint(buffer + currentNumberOfChar, bufferSize - currentNumberOfChar, KDCodePointScriptSmallE); + currentNumberOfChar+= SerializationHelper::CodePoint(buffer + currentNumberOfChar, bufferSize - currentNumberOfChar, KDCodePointLatinLetterSmallCapitalE); assert(numberOfCharExponent+currentNumberOfChar < bufferSize); - PrintFloat::printBase10IntegerWithDecimalMarker(buffer+numberOfCharsForMantissaWithSign+1, numberOfCharExponent, Integer(exponentInBase10), -1); - buffer[numberOfCharsForMantissaWithSign+1+numberOfCharExponent] = 0; - return (numberOfCharsForMantissaWithSign+1+numberOfCharExponent); + PrintFloat::printBase10IntegerWithDecimalMarker(buffer + currentNumberOfChar, numberOfCharExponent, Integer(exponentInBase10), -1); + buffer[currentNumberOfChar + numberOfCharExponent] = 0; + return (currentNumberOfChar + numberOfCharExponent); } template int PrintFloat::convertFloatToText(float, char*, int, int, Preferences::Preferences::PrintFloatMode, bool); diff --git a/poincare/test/addition.cpp b/poincare/test/addition.cpp index f7588f627..e0114946f 100644 --- a/poincare/test/addition.cpp +++ b/poincare/test/addition.cpp @@ -47,16 +47,16 @@ QUIZ_CASE(poincare_addition_parsing) { QUIZ_CASE(poincare_addition_evaluate) { assert_parsed_expression_evaluates_to("1+2", "3"); - assert_parsed_expression_evaluates_to("I", "I"); - assert_parsed_expression_evaluates_to("I+I", "2*I"); - assert_parsed_expression_evaluates_to("2+I+4+I", "6+2*I"); + assert_parsed_expression_evaluates_to("𝐢", "𝐢"); + assert_parsed_expression_evaluates_to("𝐢+𝐢", "2×𝐢"); + assert_parsed_expression_evaluates_to("2+𝐢+4+𝐢", "6+2×𝐢"); #if MATRICES_ARE_DEFINED assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]+3", "[[4,5][6,7][8,9]]"); - assert_parsed_expression_evaluates_to("[[1,2+I][3,4][5,6]]+3+I", "[[4+I,5+2*I][6+I,7+I][8+I,9+I]]"); + assert_parsed_expression_evaluates_to("[[1,2+𝐢][3,4][5,6]]+3+𝐢", "[[4+𝐢,5+2×𝐢][6+𝐢,7+𝐢][8+𝐢,9+𝐢]]"); assert_parsed_expression_evaluates_to("3+[[1,2][3,4][5,6]]", "[[4,5][6,7][8,9]]"); - assert_parsed_expression_evaluates_to("3+I+[[1,2+I][3,4][5,6]]", "[[4+I,5+2*I][6+I,7+I][8+I,9+I]]"); + assert_parsed_expression_evaluates_to("3+𝐢+[[1,2+𝐢][3,4][5,6]]", "[[4+𝐢,5+2×𝐢][6+𝐢,7+𝐢][8+𝐢,9+𝐢]]"); assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]+[[1,2][3,4][5,6]]", "[[2,4][6,8][10,12]]"); - assert_parsed_expression_evaluates_to("[[1,2+I][3,4][5,6]]+[[1,2+I][3,4][5,6]]", "[[2,4+2*I][6,8][10,12]]"); + assert_parsed_expression_evaluates_to("[[1,2+𝐢][3,4][5,6]]+[[1,2+𝐢][3,4][5,6]]", "[[2,4+2×𝐢][6,8][10,12]]"); #endif } @@ -75,18 +75,18 @@ QUIZ_CASE(poincare_addition_simplify) { assert_parsed_expression_simplify_to("-2-6", "-8"); assert_parsed_expression_simplify_to("-A", "-A"); assert_parsed_expression_simplify_to("A-A", "0"); - assert_parsed_expression_simplify_to("-5P+3P", "-2*P"); + assert_parsed_expression_simplify_to("-5π+3π", "-2×π"); assert_parsed_expression_simplify_to("1-3+A-5+2A-4A", "-A-7"); assert_parsed_expression_simplify_to("A+B-A-B", "0"); - assert_parsed_expression_simplify_to("A+B+(-1)*A+(-1)*B", "0"); - assert_parsed_expression_simplify_to("2+13cos(2)-23cos(2)", "-10*cos(2)+2"); - assert_parsed_expression_simplify_to("1+1+ln(2)+(5+3*2)/9-4/7+1/98", "(882*ln(2)+2347)/882"); + assert_parsed_expression_simplify_to("A+B+(-1)×A+(-1)×B", "0"); + assert_parsed_expression_simplify_to("2+13cos(2)-23cos(2)", "-10×cos(2)+2"); + assert_parsed_expression_simplify_to("1+1+ln(2)+(5+3×2)/9-4/7+1/98", "(882×ln(2)+2347)/882"); assert_parsed_expression_simplify_to("1+2+0+cos(2)", "cos(2)+3"); assert_parsed_expression_simplify_to("A-A+2cos(2)+B-B-cos(2)", "cos(2)"); - assert_parsed_expression_simplify_to("x+3+P+2*x", "3*x+P+3"); - assert_parsed_expression_simplify_to("1/(x+1)+1/(P+2)", "(x+P+3)/(P*x+2*x+P+2)"); - assert_parsed_expression_simplify_to("1/x^2+1/(x^2*P)", "(P+1)/(P*x^2)"); - assert_parsed_expression_simplify_to("1/x^2+1/(x^3*P)", "(P*x+1)/(P*x^3)"); - assert_parsed_expression_simplify_to("4x/x^2+3P/(x^3*P)", "(4*x^2+3)/x^3"); - assert_parsed_expression_simplify_to("3^(1/2)+2^(-2*3^(1/2)*X^P)/2", "(2*2^(2*R(3)*X^P)*R(3)+1)/(2*2^(2*R(3)*X^P))"); + assert_parsed_expression_simplify_to("x+3+π+2×x", "3×x+π+3"); + assert_parsed_expression_simplify_to("1/(x+1)+1/(π+2)", "(x+π+3)/(π×x+2×x+π+2)"); + assert_parsed_expression_simplify_to("1/x^2+1/(x^2×π)", "(π+1)/(π×x^2)"); + assert_parsed_expression_simplify_to("1/x^2+1/(x^3×π)", "(π×x+1)/(π×x^3)"); + assert_parsed_expression_simplify_to("4x/x^2+3π/(x^3×π)", "(4×x^2+3)/x^3"); + assert_parsed_expression_simplify_to("3^(1/2)+2^(-2×3^(1/2)×ℯ^π)/2", "(2×2^(2×√(3)×ℯ^π)×√(3)+1)/(2×2^(2×√(3)×ℯ^π))"); } diff --git a/poincare/test/complex.cpp b/poincare/test/complex.cpp index f72f26bb5..76749ba06 100644 --- a/poincare/test/complex.cpp +++ b/poincare/test/complex.cpp @@ -8,9 +8,9 @@ using namespace Poincare; QUIZ_CASE(poincare_complex_evaluate) { // Real - assert_parsed_expression_evaluates_to("I", "unreal", System, Radian, Real); - assert_parsed_expression_evaluates_to("R(-1)", "unreal", System, Radian, Real); - assert_parsed_expression_evaluates_to("R(-1)*R(-1)", "unreal", System, Radian, Real); + assert_parsed_expression_evaluates_to("𝐢", "unreal", System, Radian, Real); + assert_parsed_expression_evaluates_to("√(-1)", "unreal", System, Radian, Real); + assert_parsed_expression_evaluates_to("√(-1)×√(-1)", "unreal", System, Radian, Real); assert_parsed_expression_evaluates_to("ln(-2)", "unreal", System, Radian, Real); assert_parsed_expression_evaluates_to("(-8)^(1/3)", "-2", System, Radian, Real); assert_parsed_expression_evaluates_to("8^(1/3)", "2", System, Radian, Real); @@ -18,89 +18,89 @@ QUIZ_CASE(poincare_complex_evaluate) { assert_parsed_expression_evaluates_without_simplifying_to("root(-8,3)", "-2", Radian, Real); // Cartesian - assert_parsed_expression_evaluates_to("I", "I", System, Radian, Cartesian); - assert_parsed_expression_evaluates_to("R(-1)", "I", System, Radian, Cartesian); - assert_parsed_expression_evaluates_to("R(-1)*R(-1)", "-1", System, Radian, Cartesian); - assert_parsed_expression_evaluates_to("ln(-2)", "6.9314718055995E-1+3.1415926535898*I", System, Radian, Cartesian); - assert_parsed_expression_evaluates_to("(-8)^(1/3)", "1+1.7320508075689*I", System, Radian, Cartesian); - assert_parsed_expression_evaluates_to("(-8)^(2/3)", "-2+3.464102*I", System, Radian, Cartesian); - assert_parsed_expression_evaluates_without_simplifying_to("root(-8,3)", "1+1.7320508075689*I", Radian, Cartesian); + assert_parsed_expression_evaluates_to("𝐢", "𝐢", System, Radian, Cartesian); + assert_parsed_expression_evaluates_to("√(-1)", "𝐢", System, Radian, Cartesian); + assert_parsed_expression_evaluates_to("√(-1)×√(-1)", "-1", System, Radian, Cartesian); + assert_parsed_expression_evaluates_to("ln(-2)", "6.9314718055995ᴇ-1+3.1415926535898×𝐢", System, Radian, Cartesian); + assert_parsed_expression_evaluates_to("(-8)^(1/3)", "1+1.7320508075689×𝐢", System, Radian, Cartesian); + assert_parsed_expression_evaluates_to("(-8)^(2/3)", "-2+3.464102×𝐢", System, Radian, Cartesian); + assert_parsed_expression_evaluates_without_simplifying_to("root(-8,3)", "1+1.7320508075689×𝐢", Radian, Cartesian); // Polar - assert_parsed_expression_evaluates_to("I", "X^(1.570796*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("R(-1)", "X^(1.5707963267949*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("R(-1)*R(-1)", "X^(3.1415926535898*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("(-8)^(1/3)", "2*X^(1.0471975511966*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("(-8)^(2/3)", "4*X^(2.094395*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_without_simplifying_to("root(-8,3)", "2*X^(1.0471975511966*I)", Radian, Polar); + assert_parsed_expression_evaluates_to("𝐢", "ℯ^(1.570796×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("√(-1)", "ℯ^(1.5707963267949×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("√(-1)×√(-1)", "ℯ^(3.1415926535898×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("(-8)^(1/3)", "2×ℯ^(1.0471975511966×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("(-8)^(2/3)", "4×ℯ^(2.094395×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_without_simplifying_to("root(-8,3)", "2×ℯ^(1.0471975511966×𝐢)", Radian, Polar); } QUIZ_CASE(poincare_complex_simplify) { // Real - assert_parsed_expression_simplify_to("I", "unreal", User, Radian, Real); - assert_parsed_expression_simplify_to("R(-1)", "unreal", User, Radian, Real); - assert_parsed_expression_simplify_to("R(-1)*R(-1)", "unreal", User, Radian, Real); + assert_parsed_expression_simplify_to("𝐢", "unreal", User, Radian, Real); + assert_parsed_expression_simplify_to("√(-1)", "unreal", User, Radian, Real); + assert_parsed_expression_simplify_to("√(-1)×√(-1)", "unreal", User, Radian, Real); assert_parsed_expression_simplify_to("ln(-2)", "ln(-2)", User, Radian, Real); assert_parsed_expression_simplify_to("(-8)^(2/3)", "4", User, Radian, Real); - assert_parsed_expression_simplify_to("(-8)^(2/5)", "2*root(2,5)", User, Radian, Real); + assert_parsed_expression_simplify_to("(-8)^(2/5)", "2×root(2,5)", User, Radian, Real); assert_parsed_expression_simplify_to("(-8)^(1/5)", "-root(8,5)", User, Radian, Real); assert_parsed_expression_simplify_to("(-8)^(1/4)", "unreal", User, Radian, Real); assert_parsed_expression_simplify_to("(-8)^(1/3)", "-2", User, Radian, Real); // Cartesian - assert_parsed_expression_simplify_to("-2.3E3", "-2300", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("-2.3ᴇ3", "-2300", User, Radian, Cartesian); assert_parsed_expression_simplify_to("3", "3", User, Radian, Cartesian); assert_parsed_expression_simplify_to("inf", "inf", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("1+2+I", "3+I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("-(5+2*I)", "-5-2*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("(5+2*I)", "5+2*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("I+I", "2*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("-2+2*I", "-2+2*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("(3+I)-(2+4*I)", "1-3*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("(2+3*I)*(4-2*I)", "14+8*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("(3+I)/2", "3/2+1/2*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("(3+I)/(2+I)", "7/5-1/5*I", User, Radian, Cartesian); - // The simplification of (3+I)^(2+I) in a Cartesian complex form generates to many nodes - //assert_parsed_expression_simplify_to("(3+I)^(2+I)", "10*cos((-4*atan(3)+ln(2)+ln(5)+2*P)/2)*X^((2*atan(3)-P)/2)+10*sin((-4*atan(3)+ln(2)+ln(5)+2*P)/2)*X^((2*atan(3)-P)/2)*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("(3+I)^(2+I)", "(I+3)^(I+2)", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("R(1+6I)", "R(2*R(37)+2)/2+R(2*R(37)-2)/2*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("(1+I)^2", "2*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("2*I", "2*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("I!", "I!", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("1+2+𝐢", "3+𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("-(5+2×𝐢)", "-5-2×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("(5+2×𝐢)", "5+2×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("𝐢+𝐢", "2×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("-2+2×𝐢", "-2+2×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("(3+𝐢)-(2+4×𝐢)", "1-3×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("(2+3×𝐢)×(4-2×𝐢)", "14+8×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("(3+𝐢)/2", "3/2+1/2×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("(3+𝐢)/(2+𝐢)", "7/5-1/5×𝐢", User, Radian, Cartesian); + // The simplification of (3+𝐢)^(2+𝐢) in a Cartesian complex form generates to many nodes + //assert_parsed_expression_simplify_to("(3+𝐢)^(2+𝐢)", "10×cos((-4×atan(3)+ln(2)+ln(5)+2×π)/2)×ℯ^((2×atan(3)-π)/2)+10×sin((-4×atan(3)+ln(2)+ln(5)+2×π)/2)×ℯ^((2×atan(3)-π)/2)×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("(3+𝐢)^(2+𝐢)", "(𝐢+3)^(𝐢+2)", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("√(1+6𝐢)", "√(2×√(37)+2)/2+√(2×√(37)-2)/2×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("(1+𝐢)^2", "2×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("2×𝐢", "2×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("𝐢!", "𝐢!", User, Radian, Cartesian); assert_parsed_expression_simplify_to("3!", "6", User, Radian, Cartesian); assert_parsed_expression_simplify_to("x!", "x!", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("X", "X", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("P", "P", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("I", "I", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("ℯ", "ℯ", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("π", "π", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("𝐢", "𝐢", User, Radian, Cartesian); assert_parsed_expression_simplify_to("abs(-3)", "3", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("abs(-3+I)", "R(10)", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("abs(-3+𝐢)", "√(10)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("atan(2)", "atan(2)", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("atan(2+I)", "atan(2+I)", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("atan(2+𝐢)", "atan(2+𝐢)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("binomial(10, 4)", "210", User, Radian, Cartesian); assert_parsed_expression_simplify_to("ceil(-1.3)", "-1", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("arg(-2)", "P", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("arg(-2)", "π", User, Radian, Cartesian); // TODO: confidence is not simplified yet //assert_parsed_expression_simplify_to("confidence(-2,-3)", "confidence(-2)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("conj(-2)", "-2", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("conj(-2+2*I+I)", "-2-3*I", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("conj(-2+2×𝐢+𝐢)", "-2-3×𝐢", User, Radian, Cartesian); assert_parsed_expression_simplify_to("cos(12)", "cos(12)", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("cos(12+I)", "cos(12+I)", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("diff(3*x, x, 3)", "diff(3*x,x,3)", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("cos(12+𝐢)", "cos(12+𝐢)", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("diff(3×x, x, 3)", "diff(3×x,x,3)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("quo(34,x)", "quo(34,x)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("rem(5,3)", "2", User, Radian, Cartesian); assert_parsed_expression_simplify_to("floor(x)", "floor(x)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("frac(x)", "frac(x)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("gcd(x,y)", "gcd(x,y)", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("im(1+I)", "1", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("im(1+𝐢)", "1", User, Radian, Cartesian); assert_parsed_expression_simplify_to("int(x^2, x, 1, 2)", "int(x^2,x,1,2)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("lcm(x,y)", "lcm(x,y)", User, Radian, Cartesian); // TODO: dim is not simplified yet //assert_parsed_expression_simplify_to("dim(x)", "dim(x)", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("root(2,I)", "cos(ln(2))-sin(ln(2))*I", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("root(2,I+1)", "R(2)*cos((90*ln(2))/P)-R(2)*sin((90*ln(2))/P)*I", User, Degree, Cartesian); - assert_parsed_expression_simplify_to("root(2,I+1)", "R(2)*cos(ln(2)/2)-R(2)*sin(ln(2)/2)*I", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("root(2,𝐢)", "cos(ln(2))-sin(ln(2))×𝐢", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("root(2,𝐢+1)", "√(2)×cos((90×ln(2))/π)-√(2)×sin((90×ln(2))/π)×𝐢", User, Degree, Cartesian); + assert_parsed_expression_simplify_to("root(2,𝐢+1)", "√(2)×cos(ln(2)/2)-√(2)×sin(ln(2)/2)×𝐢", User, Radian, Cartesian); assert_parsed_expression_simplify_to("permute(10, 4)", "5040", User, Radian, Cartesian); // TODO: prediction is not simplified yet //assert_parsed_expression_simplify_to("prediction(-2,-3)", "prediction(-2)", User, Radian, Cartesian); @@ -110,70 +110,70 @@ QUIZ_CASE(poincare_complex_simplify) { assert_parsed_expression_simplify_to("round(x,y)", "round(x,y)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("sign(x)", "sign(x)", User, Radian, Cartesian); assert_parsed_expression_simplify_to("sin(23)", "sin(23)", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("sin(23+I)", "sin(23+I)", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("R(1-I)", "R(2*R(2)+2)/2-R(2*R(2)-2)/2*I", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("sin(23+𝐢)", "sin(23+𝐢)", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("√(1-𝐢)", "√(2×√(2)+2)/2-√(2×√(2)-2)/2×𝐢", User, Radian, Cartesian); assert_parsed_expression_simplify_to("tan(23)", "tan(23)", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("tan(23+I)", "tan(23+I)", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("tan(23+𝐢)", "tan(23+𝐢)", User, Radian, Cartesian); // User defined variable assert_parsed_expression_simplify_to("a", "a", User, Radian, Cartesian); // a = 2+i - assert_simplify("2+I>a"); - assert_parsed_expression_simplify_to("a", "2+I", User, Radian, Cartesian); + assert_simplify("2+𝐢→a"); + assert_parsed_expression_simplify_to("a", "2+𝐢", User, Radian, Cartesian); // Clean the storage for other tests Ion::Storage::sharedStorage()->recordNamed("a.exp").destroy(); // User defined function assert_parsed_expression_simplify_to("f(3)", "f(3)", User, Radian, Cartesian); - // f: x -> x+1 - assert_simplify("x+1+I>f(x)"); - assert_parsed_expression_simplify_to("f(3)", "4+I", User, Radian, Cartesian); + // f : x → x+1 + assert_simplify("x+1+𝐢→f(x)"); + assert_parsed_expression_simplify_to("f(3)", "4+𝐢", User, Radian, Cartesian); // Clean the storage for other tests Ion::Storage::sharedStorage()->recordNamed("f.func").destroy(); // Polar - assert_parsed_expression_simplify_to("-2.3E3", "2300*X^(P*I)", User, Radian, Polar); + assert_parsed_expression_simplify_to("-2.3ᴇ3", "2300×ℯ^(π×𝐢)", User, Radian, Polar); assert_parsed_expression_simplify_to("3", "3", User, Radian, Polar); assert_parsed_expression_simplify_to("inf", "inf", User, Radian, Polar); - assert_parsed_expression_simplify_to("1+2+I", "R(10)*X^((-2*atan(3)+P)/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("1+2+I", "R(10)*X^((-P*atan(3)+90*P)/180*I)", User, Degree, Polar); - assert_parsed_expression_simplify_to("-(5+2*I)", "R(29)*X^((-2*atan(5/2)-P)/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("(5+2*I)", "R(29)*X^((-2*atan(5/2)+P)/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("I+I", "2*X^(P/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("I+I", "2*X^(P/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("-2+2*I", "2*R(2)*X^((3*P)/4*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("(3+I)-(2+4*I)", "R(10)*X^((2*atan(1/3)-P)/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("(2+3*I)*(4-2*I)", "2*R(65)*X^((-2*atan(7/4)+P)/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("(3+I)/2", "R(10)/2*X^((-2*atan(3)+P)/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("(3+I)/(2+I)", "R(2)*X^((2*atan(7)-P)/2*I)", User, Radian, Polar); - // TODO: simplify atan(tan(x)) = x±k*pi? - //assert_parsed_expression_simplify_to("(3+I)^(2+I)", "10*X^((2*atan(3)-P)/2)*X^((-4*atan(3)+ln(2)+ln(5)+2*P)/2*I)", User, Radian, Polar); - // The simplification of (3+I)^(2+I) in a Polar complex form generates to many nodes - //assert_parsed_expression_simplify_to("(3+I)^(2+I)", "10*X^((2*atan(3)-P)/2)*X^((atan(tan((-4*atan(3)+ln(2)+ln(5)+2*P)/2))+P)*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("(3+I)^(2+I)", "(I+3)^(I+2)", User, Radian, Polar); - assert_parsed_expression_simplify_to("(1+I)^2", "2*X^(P/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("2*I", "2*X^(P/2*I)", User, Radian, Polar); + assert_parsed_expression_simplify_to("1+2+𝐢", "√(10)×ℯ^((-2×atan(3)+π)/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("1+2+𝐢", "√(10)×ℯ^((-π×atan(3)+90×π)/180×𝐢)", User, Degree, Polar); + assert_parsed_expression_simplify_to("-(5+2×𝐢)", "√(29)×ℯ^((-2×atan(5/2)-π)/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("(5+2×𝐢)", "√(29)×ℯ^((-2×atan(5/2)+π)/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("𝐢+𝐢", "2×ℯ^(π/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("𝐢+𝐢", "2×ℯ^(π/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("-2+2×𝐢", "2×√(2)×ℯ^((3×π)/4×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("(3+𝐢)-(2+4×𝐢)", "√(10)×ℯ^((2×atan(1/3)-π)/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("(2+3×𝐢)×(4-2×𝐢)", "2×√(65)×ℯ^((-2×atan(7/4)+π)/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("(3+𝐢)/2", "√(10)/2×ℯ^((-2×atan(3)+π)/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("(3+𝐢)/(2+𝐢)", "√(2)×ℯ^((2×atan(7)-π)/2×𝐢)", User, Radian, Polar); + // TODO: simplify atan(tan(x)) = x±k×pi? + //assert_parsed_expression_simplify_to("(3+𝐢)^(2+𝐢)", "10×ℯ^((2×atan(3)-π)/2)×ℯ^((-4×atan(3)+ln(2)+ln(5)+2×π)/2×𝐢)", User, Radian, Polar); + // The simplification of (3+𝐢)^(2+𝐢) in a Polar complex form generates to many nodes + //assert_parsed_expression_simplify_to("(3+𝐢)^(2+𝐢)", "10×ℯ^((2×atan(3)-π)/2)×ℯ^((atan(tan((-4×atan(3)+ln(2)+ln(5)+2×π)/2))+π)×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("(3+𝐢)^(2+𝐢)", "(𝐢+3)^(𝐢+2)", User, Radian, Polar); + assert_parsed_expression_simplify_to("(1+𝐢)^2", "2×ℯ^(π/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("2×𝐢", "2×ℯ^(π/2×𝐢)", User, Radian, Polar); assert_parsed_expression_simplify_to("3!", "6", User, Radian, Polar); assert_parsed_expression_simplify_to("x!", "x!", User, Radian, Polar); - assert_parsed_expression_simplify_to("X", "X", User, Radian, Polar); - assert_parsed_expression_simplify_to("P", "P", User, Radian, Polar); - assert_parsed_expression_simplify_to("I", "X^(P/2*I)", User, Radian, Polar); + assert_parsed_expression_simplify_to("ℯ", "ℯ", User, Radian, Polar); + assert_parsed_expression_simplify_to("π", "π", User, Radian, Polar); + assert_parsed_expression_simplify_to("𝐢", "ℯ^(π/2×𝐢)", User, Radian, Polar); assert_parsed_expression_simplify_to("abs(-3)", "3", User, Radian, Polar); - assert_parsed_expression_simplify_to("abs(-3+I)", "R(10)", User, Radian, Polar); - assert_parsed_expression_simplify_to("conj(2*X^(I*P/2))", "2*X^(-P/2*I)", User, Radian, Polar); - assert_parsed_expression_simplify_to("-2*X^(I*P/2)", "2*X^(-P/2*I)", User, Radian, Polar); + assert_parsed_expression_simplify_to("abs(-3+𝐢)", "√(10)", User, Radian, Polar); + assert_parsed_expression_simplify_to("conj(2×ℯ^(𝐢×π/2))", "2×ℯ^(-π/2×𝐢)", User, Radian, Polar); + assert_parsed_expression_simplify_to("-2×ℯ^(𝐢×π/2)", "2×ℯ^(-π/2×𝐢)", User, Radian, Polar); // User defined variable - assert_parsed_expression_simplify_to("a", "R(a^2)*X^((-P*sign(a)+P)/2*I)", User, Radian, Polar); - // a = 2+i - assert_simplify("2+I>a"); - assert_parsed_expression_simplify_to("a", "R(5)*X^((-2*atan(2)+P)/2*I)", User, Radian, Polar); + assert_parsed_expression_simplify_to("a", "√(a^2)×ℯ^((-π×sign(a)+π)/2×𝐢)", User, Radian, Polar); + // a = 2 + 𝐢 + assert_simplify("2+𝐢→a"); + assert_parsed_expression_simplify_to("a", "√(5)×ℯ^((-2×atan(2)+π)/2×𝐢)", User, Radian, Polar); // Clean the storage for other tests Ion::Storage::sharedStorage()->recordNamed("a.exp").destroy(); // User defined function - assert_parsed_expression_simplify_to("f(3)", "R(f(3)^2)*X^((-P*sign(f(3))+P)/2*I)", User, Radian, Polar); - // f: x -> x+1 - assert_simplify("x+1+I>f(x)"); - assert_parsed_expression_simplify_to("f(3)", "R(17)*X^((-2*atan(4)+P)/2*I)", User, Radian, Polar); + assert_parsed_expression_simplify_to("f(3)", "√(f(3)^2)×ℯ^((-π×sign(f(3))+π)/2×𝐢)", User, Radian, Polar); + // f: x → x+1 + assert_simplify("x+1+𝐢→f(x)"); + assert_parsed_expression_simplify_to("f(3)", "√(17)×ℯ^((-2×atan(4)+π)/2×𝐢)", User, Radian, Polar); // Clean the storage for other tests Ion::Storage::sharedStorage()->recordNamed("f.func").destroy(); } diff --git a/poincare/test/complex_to_expression.cpp b/poincare/test/complex_to_expression.cpp index 669669586..3f44d8a0c 100644 --- a/poincare/test/complex_to_expression.cpp +++ b/poincare/test/complex_to_expression.cpp @@ -17,71 +17,71 @@ QUIZ_CASE(poincare_complex_to_expression) { assert_parsed_expression_evaluates_to("0.1", "0.1"); assert_parsed_expression_evaluates_to("0.1234567", "0.1234567"); assert_parsed_expression_evaluates_to("0.12345678", "0.1234568"); - assert_parsed_expression_evaluates_to("1+2*I", "1+2*I"); - assert_parsed_expression_evaluates_to("1+I-I", "1"); - assert_parsed_expression_evaluates_to("1+I-1", "I"); - assert_parsed_expression_evaluates_to("1+I", "1+I"); - assert_parsed_expression_evaluates_to("3+I", "3+I"); - assert_parsed_expression_evaluates_to("3-I", "3-I"); - assert_parsed_expression_evaluates_to("3-I-3", "-I"); + assert_parsed_expression_evaluates_to("1+2×𝐢", "1+2×𝐢"); + assert_parsed_expression_evaluates_to("1+𝐢-𝐢", "1"); + assert_parsed_expression_evaluates_to("1+𝐢-1", "𝐢"); + assert_parsed_expression_evaluates_to("1+𝐢", "1+𝐢"); + assert_parsed_expression_evaluates_to("3+𝐢", "3+𝐢"); + assert_parsed_expression_evaluates_to("3-𝐢", "3-𝐢"); + assert_parsed_expression_evaluates_to("3-𝐢-3", "-𝐢"); assert_parsed_expression_evaluates_to("10", "10", System, Radian, Polar); - assert_parsed_expression_evaluates_to("-10", "10*X^(3.141593*I)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("-10", "10×ℯ^(3.141593×𝐢)", System, Radian, Polar); assert_parsed_expression_evaluates_to("100", "100", System, Radian, Polar); assert_parsed_expression_evaluates_to("0.1", "0.1", System, Radian, Polar); assert_parsed_expression_evaluates_to("0.1234567", "0.1234567", System, Radian, Polar); assert_parsed_expression_evaluates_to("0.12345678", "0.1234568", System, Radian, Polar); - assert_parsed_expression_evaluates_to("1+2*I", "2.236068*X^(1.107149*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("1+I-I", "1", System, Radian, Polar); - assert_parsed_expression_evaluates_to("1+I-1", "X^(1.570796*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("1+I", "1.414214*X^(0.7853982*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("3+I", "3.162278*X^(0.3217506*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("3-I", "3.162278*X^(-0.3217506*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("3-I-3", "X^(-1.570796*I)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("1+2×𝐢", "2.236068×ℯ^(1.107149×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("1+𝐢-𝐢", "1", System, Radian, Polar); + assert_parsed_expression_evaluates_to("1+𝐢-1", "ℯ^(1.570796×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("1+𝐢", "1.414214×ℯ^(0.7853982×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("3+𝐢", "3.162278×ℯ^(0.3217506×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("3-𝐢", "3.162278×ℯ^(-0.3217506×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("3-𝐢-3", "ℯ^(-1.570796×𝐢)", System, Radian, Polar); assert_parsed_expression_evaluates_to("10", "10"); assert_parsed_expression_evaluates_to("-10", "-10"); assert_parsed_expression_evaluates_to("100", "100"); assert_parsed_expression_evaluates_to("0.1", "0.1"); - assert_parsed_expression_evaluates_to("0.12345678901234", "1.2345678901234E-1"); - assert_parsed_expression_evaluates_to("0.123456789012345", "1.2345678901235E-1"); - assert_parsed_expression_evaluates_to("1+2*I", "1+2*I"); - assert_parsed_expression_evaluates_to("1+I-I", "1"); - assert_parsed_expression_evaluates_to("1+I-1", "I"); - assert_parsed_expression_evaluates_to("1+I", "1+I"); - assert_parsed_expression_evaluates_to("3+I", "3+I"); - assert_parsed_expression_evaluates_to("3-I", "3-I"); - assert_parsed_expression_evaluates_to("3-I-3", "-I"); + assert_parsed_expression_evaluates_to("0.12345678901234", "1.2345678901234ᴇ-1"); + assert_parsed_expression_evaluates_to("0.123456789012345", "1.2345678901235ᴇ-1"); + assert_parsed_expression_evaluates_to("1+2×𝐢", "1+2×𝐢"); + assert_parsed_expression_evaluates_to("1+𝐢-𝐢", "1"); + assert_parsed_expression_evaluates_to("1+𝐢-1", "𝐢"); + assert_parsed_expression_evaluates_to("1+𝐢", "1+𝐢"); + assert_parsed_expression_evaluates_to("3+𝐢", "3+𝐢"); + assert_parsed_expression_evaluates_to("3-𝐢", "3-𝐢"); + assert_parsed_expression_evaluates_to("3-𝐢-3", "-𝐢"); assert_parsed_expression_evaluates_to("10", "10", System, Radian, Polar); - assert_parsed_expression_evaluates_to("-10", "10*X^(3.1415926535898*I)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("-10", "10×ℯ^(3.1415926535898×𝐢)", System, Radian, Polar); assert_parsed_expression_evaluates_to("100", "100", System, Radian, Polar); assert_parsed_expression_evaluates_to("0.1", "0.1", System, Radian, Polar); assert_parsed_expression_evaluates_to("0.1234567", "0.1234567", System, Radian, Polar); assert_parsed_expression_evaluates_to("0.12345678", "0.12345678", System, Radian, Polar); - assert_parsed_expression_evaluates_to("1+2*I", "2.2360679775*X^(1.10714871779*I)", System, Radian, Polar, 12); - assert_parsed_expression_evaluates_to("1+I-I", "1", System, Radian, Polar); - assert_parsed_expression_evaluates_to("1+I-1", "X^(1.57079632679*I)", System, Radian, Polar, 12); - assert_parsed_expression_evaluates_to("1+I", "1.41421356237*X^(0.785398163397*I)", System, Radian, Polar, 12); - assert_parsed_expression_evaluates_to("3+I", "3.16227766017*X^(0.321750554397*I)", System, Radian, Polar,12); - assert_parsed_expression_evaluates_to("3-I", "3.16227766017*X^(-0.321750554397*I)", System, Radian, Polar,12); - assert_parsed_expression_evaluates_to("3-I-3", "X^(-1.57079632679*I)", System, Radian, Polar,12); + assert_parsed_expression_evaluates_to("1+2×𝐢", "2.2360679775×ℯ^(1.10714871779×𝐢)", System, Radian, Polar, 12); + assert_parsed_expression_evaluates_to("1+𝐢-𝐢", "1", System, Radian, Polar); + assert_parsed_expression_evaluates_to("1+𝐢-1", "ℯ^(1.57079632679×𝐢)", System, Radian, Polar, 12); + assert_parsed_expression_evaluates_to("1+𝐢", "1.41421356237×ℯ^(0.785398163397×𝐢)", System, Radian, Polar, 12); + assert_parsed_expression_evaluates_to("3+𝐢", "3.16227766017×ℯ^(0.321750554397×𝐢)", System, Radian, Polar,12); + assert_parsed_expression_evaluates_to("3-𝐢", "3.16227766017×ℯ^(-0.321750554397×𝐢)", System, Radian, Polar,12); + assert_parsed_expression_evaluates_to("3-𝐢-3", "ℯ^(-1.57079632679×𝐢)", System, Radian, Polar,12); - assert_parsed_expression_evaluates_to("2+3*I", "3.60555127546*X^(0.982793723247*I)", System, Radian, Polar, 12); - assert_parsed_expression_evaluates_to("3.60555127546*X^(0.982793723247*I)", "2+3*I", System, Radian, Cartesian, 12); - assert_parsed_expression_evaluates_to("12.04159457879229548012824103*X^(1.4876550949*I)", "1+12*I", System, Radian, Cartesian, 5); - assert_parsed_expression_evaluates_to("-2E20+2E20*I", "-2E20+2E20*I"); - assert_parsed_expression_evaluates_to("-2E20+2E20*I", "2.828427E20*X^(2.356194*I)", System, Radian, Polar); - assert_parsed_expression_evaluates_to("1E155-1E155*I", "1E155-1E155*I"); - assert_parsed_expression_evaluates_to("1E155-1E155*I", "1.41421356237E155*X^(-0.785398163397*I)", System, Radian, Polar,12); + assert_parsed_expression_evaluates_to("2+3×𝐢", "3.60555127546×ℯ^(0.982793723247×𝐢)", System, Radian, Polar, 12); + assert_parsed_expression_evaluates_to("3.60555127546×ℯ^(0.982793723247×𝐢)", "2+3×𝐢", System, Radian, Cartesian, 12); + assert_parsed_expression_evaluates_to("12.04159457879229548012824103×ℯ^(1.4876550949×𝐢)", "1+12×𝐢", System, Radian, Cartesian, 5); + assert_parsed_expression_evaluates_to("-2ᴇ20+2ᴇ20×𝐢", "-2ᴇ20+2ᴇ20×𝐢"); + assert_parsed_expression_evaluates_to("-2ᴇ20+2ᴇ20×𝐢", "2.828427ᴇ20×ℯ^(2.356194×𝐢)", System, Radian, Polar); + assert_parsed_expression_evaluates_to("1ᴇ155-1ᴇ155×𝐢", "1ᴇ155-1ᴇ155×𝐢"); + assert_parsed_expression_evaluates_to("1ᴇ155-1ᴇ155×𝐢", "1.41421356237ᴇ155×ℯ^(-0.785398163397×𝐢)", System, Radian, Polar,12); - assert_parsed_expression_evaluates_to("-2E100+2E100*I", Undefined::Name()); - assert_parsed_expression_evaluates_to("-2E360+2E360*I", Undefined::Name()); - assert_parsed_expression_evaluates_to("-2E100+2E10*I", "-inf+2E10*I"); - assert_parsed_expression_evaluates_to("-2E360+2*I", "-inf+2*I"); - assert_parsed_expression_evaluates_to("undef+2E100*I", Undefined::Name()); - assert_parsed_expression_evaluates_to("-2E360+undef*I", Undefined::Name()); + assert_parsed_expression_evaluates_to("-2ᴇ100+2ᴇ100×𝐢", Undefined::Name()); + assert_parsed_expression_evaluates_to("-2ᴇ360+2ᴇ360×𝐢", Undefined::Name()); + assert_parsed_expression_evaluates_to("-2ᴇ100+2ᴇ10×𝐢", "-inf+2ᴇ10×𝐢"); + assert_parsed_expression_evaluates_to("-2ᴇ360+2×𝐢", "-inf+2×𝐢"); + assert_parsed_expression_evaluates_to("undef+2ᴇ100×𝐢", Undefined::Name()); + assert_parsed_expression_evaluates_to("-2ᴇ360+undef×𝐢", Undefined::Name()); - assert_parsed_expression_evaluates_to("2*X^(I)", "2*X^I", System, Radian, Polar, 5); - assert_parsed_expression_evaluates_to("2*X^(-I)", "2*X^(-I)", System, Radian, Polar, 5); + assert_parsed_expression_evaluates_to("2×ℯ^(𝐢)", "2×ℯ^𝐢", System, Radian, Polar, 5); + assert_parsed_expression_evaluates_to("2×ℯ^(-𝐢)", "2×ℯ^(-𝐢)", System, Radian, Polar, 5); } diff --git a/poincare/test/convert_expression_to_text.cpp b/poincare/test/convert_expression_to_text.cpp index 37702f9b8..0d557cbb1 100644 --- a/poincare/test/convert_expression_to_text.cpp +++ b/poincare/test/convert_expression_to_text.cpp @@ -58,9 +58,9 @@ void assert_expression_prints_to(Expression e, const char * result, Preferences: } QUIZ_CASE(assert_float_prints_to) { - assert_float_prints_to(123.456f, "1.23456E2", ScientificMode, 7); + assert_float_prints_to(123.456f, "1.23456ᴇ2", ScientificMode, 7); assert_float_prints_to(123.456f, "123.456", DecimalMode, 7); - assert_float_prints_to(123.456, "1.23456E2", ScientificMode, 14); + assert_float_prints_to(123.456, "1.23456ᴇ2", ScientificMode, 14); assert_float_prints_to(123.456, "123.456", DecimalMode, 14); assert_float_prints_to(1.234567891011f, "1.234568", ScientificMode, 7); @@ -73,29 +73,29 @@ QUIZ_CASE(assert_float_prints_to) { assert_float_prints_to(2.0, "2", ScientificMode, 14); assert_float_prints_to(2.0, "2", DecimalMode, 14); - assert_float_prints_to(123456789.0f, "1.234568E8", ScientificMode, 7); - assert_float_prints_to(123456789.0f, "1.234568E8", DecimalMode, 7); - assert_float_prints_to(123456789.0, "1.23456789E8", ScientificMode, 14); + assert_float_prints_to(123456789.0f, "1.234568ᴇ8", ScientificMode, 7); + assert_float_prints_to(123456789.0f, "1.234568ᴇ8", DecimalMode, 7); + assert_float_prints_to(123456789.0, "1.23456789ᴇ8", ScientificMode, 14); assert_float_prints_to(123456789.0, "123456789", DecimalMode, 14); - assert_float_prints_to(0.00000123456789f, "1.234568E-6", ScientificMode, 7); + assert_float_prints_to(0.00000123456789f, "1.234568ᴇ-6", ScientificMode, 7); assert_float_prints_to(0.00000123456789f, "0.000001234568", DecimalMode, 7); - assert_float_prints_to(0.00000123456789, "1.23456789E-6", ScientificMode, 14); + assert_float_prints_to(0.00000123456789, "1.23456789ᴇ-6", ScientificMode, 14); assert_float_prints_to(0.00000123456789, "0.00000123456789", DecimalMode, 14); - assert_float_prints_to(0.99f, "9.9E-1", ScientificMode, 7); + assert_float_prints_to(0.99f, "9.9ᴇ-1", ScientificMode, 7); assert_float_prints_to(0.99f, "0.99", DecimalMode, 7); - assert_float_prints_to(0.99, "9.9E-1", ScientificMode, 14); + assert_float_prints_to(0.99, "9.9ᴇ-1", ScientificMode, 14); assert_float_prints_to(0.99, "0.99", DecimalMode, 14); - assert_float_prints_to(-123.456789f, "-1.234568E2", ScientificMode, 7); + assert_float_prints_to(-123.456789f, "-1.234568ᴇ2", ScientificMode, 7); assert_float_prints_to(-123.456789f, "-123.4568", DecimalMode, 7); - assert_float_prints_to(-123.456789, "-1.23456789E2", ScientificMode, 14); + assert_float_prints_to(-123.456789, "-1.23456789ᴇ2", ScientificMode, 14); assert_float_prints_to(-123.456789, "-123.456789", DecimalMode, 14); - assert_float_prints_to(-0.000123456789f, "-1.234568E-4", ScientificMode, 7); + assert_float_prints_to(-0.000123456789f, "-1.234568ᴇ-4", ScientificMode, 7); assert_float_prints_to(-0.000123456789f, "-0.0001234568", DecimalMode, 7); - assert_float_prints_to(-0.000123456789, "-1.23456789E-4", ScientificMode, 14); + assert_float_prints_to(-0.000123456789, "-1.23456789ᴇ-4", ScientificMode, 14); assert_float_prints_to(-0.000123456789, "-0.000123456789", DecimalMode, 14); assert_float_prints_to(0.0f, "0", ScientificMode, 7); @@ -103,86 +103,86 @@ QUIZ_CASE(assert_float_prints_to) { assert_float_prints_to(0.0, "0", ScientificMode, 14); assert_float_prints_to(0.0, "0", DecimalMode, 14); - assert_float_prints_to(10000000000000000000000000000.0, "1E28", ScientificMode, 7); + assert_float_prints_to(10000000000000000000000000000.0, "1ᴇ28", ScientificMode, 7); /* Converting 10000000000000000000000000000.0f into a decimal display would * overflow the number of significant digits set to 7. When this is the case, the * display mode is automatically set to scientific. */ - assert_float_prints_to(10000000000000000000000000000.0, "1E28", DecimalMode, 7); - assert_float_prints_to(10000000000000000000000000000.0, "1E28", ScientificMode, 14); - assert_float_prints_to(10000000000000000000000000000.0, "1E28", DecimalMode, 14); + assert_float_prints_to(10000000000000000000000000000.0, "1ᴇ28", DecimalMode, 7); + assert_float_prints_to(10000000000000000000000000000.0, "1ᴇ28", ScientificMode, 14); + assert_float_prints_to(10000000000000000000000000000.0, "1ᴇ28", DecimalMode, 14); - assert_float_prints_to(1000000.0f, "1E6", ScientificMode, 7); + assert_float_prints_to(1000000.0f, "1ᴇ6", ScientificMode, 7); assert_float_prints_to(1000000.0f, "1000000", DecimalMode, 7); - assert_float_prints_to(1000000.0, "1E6", ScientificMode, 14); + assert_float_prints_to(1000000.0, "1ᴇ6", ScientificMode, 14); assert_float_prints_to(1000000.0, "1000000", DecimalMode); - assert_float_prints_to(10000000.0f, "1E7", ScientificMode, 7); - assert_float_prints_to(10000000.0f, "1E7", DecimalMode, 7); - assert_float_prints_to(10000000.0, "1E7", ScientificMode, 14); + assert_float_prints_to(10000000.0f, "1ᴇ7", ScientificMode, 7); + assert_float_prints_to(10000000.0f, "1ᴇ7", DecimalMode, 7); + assert_float_prints_to(10000000.0, "1ᴇ7", ScientificMode, 14); assert_float_prints_to(10000000.0, "10000000", DecimalMode, 14); - assert_float_prints_to(0.0000001, "1E-7", ScientificMode, 7); + assert_float_prints_to(0.0000001, "1ᴇ-7", ScientificMode, 7); /* Converting 0.00000001f into a decimal display would also overflow the * number of significant digits set to 7. */ assert_float_prints_to(0.0000001f, "0.0000001", DecimalMode, 7); - assert_float_prints_to(0.0000001, "1E-7", ScientificMode, 14); + assert_float_prints_to(0.0000001, "1ᴇ-7", ScientificMode, 14); assert_float_prints_to(0.0000001, "0.0000001", DecimalMode, 14); - assert_float_prints_to(-0.000000000000000000000000000000009090018f, "-9.090018E-33", ScientificMode, 7); - assert_float_prints_to(-0.000000000000000000000000000000009090018f, "-9.090018E-33", DecimalMode, 7); - assert_float_prints_to(-0.000000000000000000000000000000009090018, "-9.090018E-33", ScientificMode, 14); - assert_float_prints_to(-0.000000000000000000000000000000009090018, "-9.090018E-33", DecimalMode, 14); + assert_float_prints_to(-0.000000000000000000000000000000009090018f, "-9.090018ᴇ-33", ScientificMode, 7); + assert_float_prints_to(-0.000000000000000000000000000000009090018f, "-9.090018ᴇ-33", DecimalMode, 7); + assert_float_prints_to(-0.000000000000000000000000000000009090018, "-9.090018ᴇ-33", ScientificMode, 14); + assert_float_prints_to(-0.000000000000000000000000000000009090018, "-9.090018ᴇ-33", DecimalMode, 14); - assert_float_prints_to(123.421f, "1.23421E2", ScientificMode, 7); + assert_float_prints_to(123.421f, "1.23421ᴇ2", ScientificMode, 7); assert_float_prints_to(123.421f, "123.4", DecimalMode, 4, 6); - assert_float_prints_to(123.421f, "1.2E2", ScientificMode, 4, 6); + assert_float_prints_to(123.421f, "1.2ᴇ2", ScientificMode, 4, 8); // 'ᴇ' uses 3 bytes - assert_float_prints_to(9.999999f, "1E1", ScientificMode, 6); + assert_float_prints_to(9.999999f, "1ᴇ1", ScientificMode, 6); assert_float_prints_to(9.999999f, "10", DecimalMode, 6); assert_float_prints_to(9.999999f, "9.999999", ScientificMode, 7); assert_float_prints_to(9.999999f, "9.999999", DecimalMode, 7); - assert_float_prints_to(-9.99999904f, "-1E1", ScientificMode, 6); + assert_float_prints_to(-9.99999904f, "-1ᴇ1", ScientificMode, 6); assert_float_prints_to(-9.99999904f, "-10", DecimalMode, 6); assert_float_prints_to(-9.99999904, "-9.999999", ScientificMode, 7); assert_float_prints_to(-9.99999904, "-9.999999", DecimalMode, 7); - assert_float_prints_to(-0.017452f, "-1.745E-2", ScientificMode, 4); + assert_float_prints_to(-0.017452f, "-1.745ᴇ-2", ScientificMode, 4); assert_float_prints_to(-0.017452f, "-0.01745", DecimalMode, 4); - assert_float_prints_to(-0.017452, "-1.7452E-2", ScientificMode, 14); + assert_float_prints_to(-0.017452, "-1.7452ᴇ-2", ScientificMode, 14); assert_float_prints_to(-0.017452, "-0.017452", DecimalMode, 14); - assert_float_prints_to(1E50, "1E50", ScientificMode, 9); - assert_float_prints_to(1E50, "1E50", DecimalMode, 9); - assert_float_prints_to(1E50, "1E50", ScientificMode, 14); - assert_float_prints_to(1E50, "1E50", DecimalMode, 14); + assert_float_prints_to(1E50, "1ᴇ50", ScientificMode, 9); + assert_float_prints_to(1E50, "1ᴇ50", DecimalMode, 9); + assert_float_prints_to(1E50, "1ᴇ50", ScientificMode, 14); + assert_float_prints_to(1E50, "1ᴇ50", DecimalMode, 14); - assert_float_prints_to(100.0, "1E2", ScientificMode, 9); + assert_float_prints_to(100.0, "1ᴇ2", ScientificMode, 9); assert_float_prints_to(100.0, "100", DecimalMode, 9); - assert_float_prints_to(12345.678910121314f, "1.234568E4", ScientificMode, 7); + assert_float_prints_to(12345.678910121314f, "1.234568ᴇ4", ScientificMode, 7); assert_float_prints_to(12345.678910121314f, "12345.68", DecimalMode, 7); - assert_float_prints_to(12345.678910121314, "1.2345678910121E4", ScientificMode, 14); + assert_float_prints_to(12345.678910121314, "1.2345678910121ᴇ4", ScientificMode, 14); assert_float_prints_to(12345.678910121314, "12345.678910121", DecimalMode, 14); - assert_float_prints_to(9.999999999999999999999E12, "1E13", ScientificMode, 9); - assert_float_prints_to(9.999999999999999999999E12, "1E13", DecimalMode, 9); - assert_float_prints_to(9.999999999999999999999E12, "1E13", ScientificMode, 14); + assert_float_prints_to(9.999999999999999999999E12, "1ᴇ13", ScientificMode, 9); + assert_float_prints_to(9.999999999999999999999E12, "1ᴇ13", DecimalMode, 9); + assert_float_prints_to(9.999999999999999999999E12, "1ᴇ13", ScientificMode, 14); assert_float_prints_to(9.999999999999999999999E12, "10000000000000", DecimalMode, 14); - assert_float_prints_to(-0.000000099999999f, "-1E-7", ScientificMode, 7); + assert_float_prints_to(-0.000000099999999f, "-1ᴇ-7", ScientificMode, 7); assert_float_prints_to(-0.000000099999999f, "-0.0000001", DecimalMode, 7); - assert_float_prints_to(-0.000000099999999, "-9.9999999E-8", ScientificMode, 9); + assert_float_prints_to(-0.000000099999999, "-9.9999999ᴇ-8", ScientificMode, 9); assert_float_prints_to(-0.000000099999999, "-0.000000099999999", DecimalMode, 9); - assert_float_prints_to(999.99999999999977f, "1E3", ScientificMode, 5); + assert_float_prints_to(999.99999999999977f, "1ᴇ3", ScientificMode, 5); assert_float_prints_to(999.99999999999977f, "1000", DecimalMode, 5); - assert_float_prints_to(999.99999999999977, "1E3", ScientificMode, 14); + assert_float_prints_to(999.99999999999977, "1ᴇ3", ScientificMode, 14); assert_float_prints_to(999.99999999999977, "1000", DecimalMode, 14); - assert_float_prints_to(0.000000999999997, "1E-6", ScientificMode, 7); + assert_float_prints_to(0.000000999999997, "1ᴇ-6", ScientificMode, 7); assert_float_prints_to(0.000000999999997, "0.000001", DecimalMode, 7); - assert_float_prints_to(9999999.97, "1E7", DecimalMode, 7); + assert_float_prints_to(9999999.97, "1ᴇ7", DecimalMode, 7); assert_float_prints_to(9999999.97, "10000000", DecimalMode, 8); } @@ -194,51 +194,51 @@ QUIZ_CASE(poincare_rational_to_text) { QUIZ_CASE(poincare_decimal_to_text) { Decimal d0 = Decimal::Builder(Integer("-123456789"),30); - assert_expression_prints_to(d0, "-1.23456789E30", ScientificMode, 14); - assert_expression_prints_to(d0, "-1.234568E30", DecimalMode, 7); + assert_expression_prints_to(d0, "-1.23456789ᴇ30", ScientificMode, 14); + assert_expression_prints_to(d0, "-1.234568ᴇ30", DecimalMode, 7); Decimal d1 = Decimal::Builder(Integer("123456789"),30); - assert_expression_prints_to(d1, "1.23456789E30", ScientificMode, 14); - assert_expression_prints_to(d1, "1.235E30", DecimalMode, 4); + assert_expression_prints_to(d1, "1.23456789ᴇ30", ScientificMode, 14); + assert_expression_prints_to(d1, "1.235ᴇ30", DecimalMode, 4); Decimal d2 = Decimal::Builder(Integer("-123456789"),-30); - assert_expression_prints_to(d2, "-1.23456789E-30", DecimalMode, 14); - assert_expression_prints_to(d2, "-1.235E-30", ScientificMode, 4); + assert_expression_prints_to(d2, "-1.23456789ᴇ-30", DecimalMode, 14); + assert_expression_prints_to(d2, "-1.235ᴇ-30", ScientificMode, 4); Decimal d3 = Decimal::Builder(Integer("-12345"),-3); assert_expression_prints_to(d3, "-0.0012345", DecimalMode, 7); assert_expression_prints_to(d3, "-0.00123", DecimalMode, 3); assert_expression_prints_to(d3, "-0.001235", DecimalMode, 4); - assert_expression_prints_to(d3, "-1.23E-3", ScientificMode, 3); + assert_expression_prints_to(d3, "-1.23ᴇ-3", ScientificMode, 3); Decimal d4 = Decimal::Builder(Integer("12345"),-3); assert_expression_prints_to(d4, "0.0012345", DecimalMode, 7); - assert_expression_prints_to(d4, "1.2E-3", ScientificMode, 2); + assert_expression_prints_to(d4, "1.2ᴇ-3", ScientificMode, 2); Decimal d5 = Decimal::Builder(Integer("12345"),3); assert_expression_prints_to(d5, "1234.5", DecimalMode, 7); - assert_expression_prints_to(d5, "1.23E3", DecimalMode, 3); + assert_expression_prints_to(d5, "1.23ᴇ3", DecimalMode, 3); assert_expression_prints_to(d5, "1235", DecimalMode, 4); - assert_expression_prints_to(d5, "1.235E3", ScientificMode, 4); + assert_expression_prints_to(d5, "1.235ᴇ3", ScientificMode, 4); Decimal d6 = Decimal::Builder(Integer("-12345"),3); assert_expression_prints_to(d6, "-1234.5", DecimalMode, 7); - assert_expression_prints_to(d6, "-1.2345E3", ScientificMode, 10); + assert_expression_prints_to(d6, "-1.2345ᴇ3", ScientificMode, 10); Decimal d7 = Decimal::Builder(Integer("12345"),6); assert_expression_prints_to(d7, "1234500", DecimalMode, 7); - assert_expression_prints_to(d7, "1.2345E6", DecimalMode, 6); - assert_expression_prints_to(d7, "1.2345E6", ScientificMode); + assert_expression_prints_to(d7, "1.2345ᴇ6", DecimalMode, 6); + assert_expression_prints_to(d7, "1.2345ᴇ6", ScientificMode); Decimal d8 = Decimal::Builder(Integer("-12345"),6); assert_expression_prints_to(d8, "-1234500", DecimalMode, 7); - assert_expression_prints_to(d8, "-1.2345E6", DecimalMode, 5); - assert_expression_prints_to(d7, "1.235E6", ScientificMode, 4); + assert_expression_prints_to(d8, "-1.2345ᴇ6", DecimalMode, 5); + assert_expression_prints_to(d7, "1.235ᴇ6", ScientificMode, 4); Decimal d9 = Decimal::Builder(Integer("-12345"),-1); assert_expression_prints_to(d9, "-0.12345", DecimalMode, 7); assert_expression_prints_to(d9, "-0.1235", DecimalMode, 4); - assert_expression_prints_to(d9, "-1.235E-1", ScientificMode, 4); + assert_expression_prints_to(d9, "-1.235ᴇ-1", ScientificMode, 4); Decimal d10 = Decimal::Builder(Integer("12345"),-1); - assert_expression_prints_to(d10, "1.2345E-1"); + assert_expression_prints_to(d10, "1.2345ᴇ-1"); assert_expression_prints_to(d10, "0.12345", DecimalMode, 7); assert_expression_prints_to(d10, "0.1235", DecimalMode, 4); - assert_expression_prints_to(d10, "1.235E-1", ScientificMode, 4); + assert_expression_prints_to(d10, "1.235ᴇ-1", ScientificMode, 4); - assert_expression_prints_to(Decimal::Builder(-1.23456789E30), "-1.23456789E30", ScientificMode, 14); - assert_expression_prints_to(Decimal::Builder(1.23456789E30), "1.23456789E30", ScientificMode, 14); - assert_expression_prints_to(Decimal::Builder(-1.23456789E-30), "-1.23456789E-30", ScientificMode, 14); + assert_expression_prints_to(Decimal::Builder(-1.23456789E30), "-1.23456789ᴇ30", ScientificMode, 14); + assert_expression_prints_to(Decimal::Builder(1.23456789E30), "1.23456789ᴇ30", ScientificMode, 14); + assert_expression_prints_to(Decimal::Builder(-1.23456789E-30), "-1.23456789ᴇ-30", ScientificMode, 14); assert_expression_prints_to(Decimal::Builder(-1.2345E-3), "-0.0012345", DecimalMode); assert_expression_prints_to(Decimal::Builder(1.2345E-3), "0.0012345", DecimalMode); assert_expression_prints_to(Decimal::Builder(1.2345E3), "1234.5", DecimalMode); @@ -249,28 +249,28 @@ QUIZ_CASE(poincare_decimal_to_text) { assert_expression_prints_to(Decimal::Builder(1.2345E-1), "0.12345", DecimalMode); assert_expression_prints_to(Decimal::Builder(1.0), "1"); assert_expression_prints_to(Decimal::Builder(0.9999999999999996), "1"); - assert_expression_prints_to(Decimal::Builder(0.99999999999995), "9.9999999999995E-1", ScientificMode, 14); - assert_expression_prints_to(Decimal::Builder(0.00000099999999999995), "9.9999999999995E-7", ScientificMode, 14); + assert_expression_prints_to(Decimal::Builder(0.99999999999995), "9.9999999999995ᴇ-1", ScientificMode, 14); + assert_expression_prints_to(Decimal::Builder(0.00000099999999999995), "9.9999999999995ᴇ-7", ScientificMode, 14); assert_expression_prints_to(Decimal::Builder(0.000000999999999999995), "0.000001", DecimalMode); - assert_expression_prints_to(Decimal::Builder(0.000000999999999901200121020102010201201201021099995), "9.999999999012E-7", DecimalMode, 14); + assert_expression_prints_to(Decimal::Builder(0.000000999999999901200121020102010201201201021099995), "9.999999999012ᴇ-7", DecimalMode, 14); assert_expression_prints_to(Decimal::Builder(9999999999999.54), "9999999999999.5", DecimalMode, 14); - assert_expression_prints_to(Decimal::Builder(99999999999999.54), "1E14", DecimalMode, 14); - assert_expression_prints_to(Decimal::Builder(999999999999999.54), "1E15", DecimalMode, 14); - assert_expression_prints_to(Decimal::Builder(9999999999999999.54), "1E16", DecimalMode, 14); - assert_expression_prints_to(Decimal::Builder(-9.702365051313E-297), "-9.702365051313E-297", DecimalMode, 14); + assert_expression_prints_to(Decimal::Builder(99999999999999.54), "1ᴇ14", DecimalMode, 14); + assert_expression_prints_to(Decimal::Builder(999999999999999.54), "1ᴇ15", DecimalMode, 14); + assert_expression_prints_to(Decimal::Builder(9999999999999999.54), "1ᴇ16", DecimalMode, 14); + assert_expression_prints_to(Decimal::Builder(-9.702365051313E-297), "-9.702365051313ᴇ-297", DecimalMode, 14); } QUIZ_CASE(poincare_approximation_to_text) { - assert_expression_prints_to(Float::Builder(-1.23456789E30), "-1.23456789E30", DecimalMode, 14); - assert_expression_prints_to(Float::Builder(1.23456789E30), "1.23456789E30", DecimalMode, 14); - assert_expression_prints_to(Float::Builder(-1.23456789E-30), "-1.23456789E-30", DecimalMode, 14); + assert_expression_prints_to(Float::Builder(-1.23456789E30), "-1.23456789ᴇ30", DecimalMode, 14); + assert_expression_prints_to(Float::Builder(1.23456789E30), "1.23456789ᴇ30", DecimalMode, 14); + assert_expression_prints_to(Float::Builder(-1.23456789E-30), "-1.23456789ᴇ-30", DecimalMode, 14); assert_expression_prints_to(Float::Builder(-1.2345E-3), "-0.0012345", DecimalMode); assert_expression_prints_to(Float::Builder(1.2345E-3), "0.0012345", DecimalMode); assert_expression_prints_to(Float::Builder(1.2345E3), "1234.5", DecimalMode); assert_expression_prints_to(Float::Builder(-1.2345E3), "-1234.5", DecimalMode); - assert_expression_prints_to(Float::Builder(0.99999999999995), "9.9999999999995E-1", ScientificMode, 14); - assert_expression_prints_to(Float::Builder(0.00000099999999999995), "9.9999999999995E-7", DecimalMode, 14); - assert_expression_prints_to(Float::Builder(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7", DecimalMode, 14); + assert_expression_prints_to(Float::Builder(0.99999999999995), "9.9999999999995ᴇ-1", ScientificMode, 14); + assert_expression_prints_to(Float::Builder(0.00000099999999999995), "9.9999999999995ᴇ-7", DecimalMode, 14); + assert_expression_prints_to(Float::Builder(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012ᴇ-7", DecimalMode, 14); assert_expression_prints_to(Float::Builder(1.2345E-1), "0.12345", DecimalMode); assert_expression_prints_to(Float::Builder(1), "1", DecimalMode); assert_expression_prints_to(Float::Builder(0.9999999999999995), "1", DecimalMode); diff --git a/poincare/test/decimal.cpp b/poincare/test/decimal.cpp index bb91c0114..f3c17ff3d 100644 --- a/poincare/test/decimal.cpp +++ b/poincare/test/decimal.cpp @@ -47,13 +47,13 @@ QUIZ_CASE(poincare_decimal_properties) { QUIZ_CASE(poincare_decimal_simplify) { assert_parsed_expression_simplify_to("-2.3", "-23/10"); - assert_parsed_expression_simplify_to("-232.2E-4", "-1161/50000"); - assert_parsed_expression_simplify_to("0000.000000E-2", "0"); + assert_parsed_expression_simplify_to("-232.2ᴇ-4", "-1161/50000"); + assert_parsed_expression_simplify_to("0000.000000ᴇ-2", "0"); assert_parsed_expression_simplify_to(".000000", "0"); assert_parsed_expression_simplify_to("0000", "0"); } QUIZ_CASE(poincare_decimal_approximate) { - assert_parsed_expression_evaluates_to("1.2343E-2", "0.012343"); - assert_parsed_expression_evaluates_to("-567.2E2", "-56720"); + assert_parsed_expression_evaluates_to("1.2343ᴇ-2", "0.012343"); + assert_parsed_expression_evaluates_to("-567.2ᴇ2", "-56720"); } diff --git a/poincare/test/division.cpp b/poincare/test/division.cpp index 0895d8d3d..7e0ea43d2 100644 --- a/poincare/test/division.cpp +++ b/poincare/test/division.cpp @@ -8,16 +8,16 @@ using namespace Poincare; QUIZ_CASE(poincare_division_evaluate) { assert_parsed_expression_evaluates_to("1/2", "0.5"); - assert_parsed_expression_evaluates_to("(3+I)/(4+I)", "7.6470588235294E-1+5.8823529411765E-2*I"); + assert_parsed_expression_evaluates_to("(3+𝐢)/(4+𝐢)", "7.6470588235294ᴇ-1+5.8823529411765ᴇ-2×𝐢"); #if MATRICES_ARE_DEFINED assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]/2", "[[0.5,1][1.5,2][2.5,3]]"); - assert_parsed_expression_evaluates_to("[[1,2+I][3,4][5,6]]/(1+I)", "[[0.5-0.5*I,1.5-0.5*I][1.5-1.5*I,2-2*I][2.5-2.5*I,3-3*I]]"); + assert_parsed_expression_evaluates_to("[[1,2+𝐢][3,4][5,6]]/(1+𝐢)", "[[0.5-0.5×𝐢,1.5-0.5×𝐢][1.5-1.5×𝐢,2-2×𝐢][2.5-2.5×𝐢,3-3×𝐢]]"); assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]/2", "[[0.5,1][1.5,2][2.5,3]]"); - assert_parsed_expression_evaluates_to("[[1,2][3,4]]/[[3,4][6,9]]", "[[-1,6.6666666666667E-1][1,0]]"); + assert_parsed_expression_evaluates_to("[[1,2][3,4]]/[[3,4][6,9]]", "[[-1,6.6666666666667ᴇ-1][1,0]]"); assert_parsed_expression_evaluates_to("3/[[3,4][5,6]]", "[[-9,6][7.5,-4.5]]"); - assert_parsed_expression_evaluates_to("(3+4I)/[[1,I][3,4]]", "[[4*I,1][-3*I,I]]"); + assert_parsed_expression_evaluates_to("(3+4𝐢)/[[1,𝐢][3,4]]", "[[4×𝐢,1][-3×𝐢,𝐢]]"); #endif - assert_parsed_expression_evaluates_to("1E20/(1E20+1E20I)", "0.5-0.5*I"); - assert_parsed_expression_evaluates_to("1E155/(1E155+1E155I)", "0.5-0.5*I"); + assert_parsed_expression_evaluates_to("1ᴇ20/(1ᴇ20+1ᴇ20𝐢)", "0.5-0.5×𝐢"); + assert_parsed_expression_evaluates_to("1ᴇ155/(1ᴇ155+1ᴇ155𝐢)", "0.5-0.5×𝐢"); } diff --git a/poincare/test/factorial.cpp b/poincare/test/factorial.cpp index 09b63d367..5ab7884f1 100644 --- a/poincare/test/factorial.cpp +++ b/poincare/test/factorial.cpp @@ -9,6 +9,6 @@ QUIZ_CASE(poincare_factorial_simplify) { assert_parsed_expression_simplify_to("1/3!", "1/6"); assert_parsed_expression_simplify_to("5!", "120"); assert_parsed_expression_simplify_to("(1/3)!", Undefined::Name()); - assert_parsed_expression_simplify_to("P!", Undefined::Name()); - assert_parsed_expression_simplify_to("X!", Undefined::Name()); + assert_parsed_expression_simplify_to("π!", Undefined::Name()); + assert_parsed_expression_simplify_to("ℯ!", Undefined::Name()); } diff --git a/poincare/test/float.cpp b/poincare/test/float.cpp index 009cbc867..756327396 100644 --- a/poincare/test/float.cpp +++ b/poincare/test/float.cpp @@ -21,16 +21,16 @@ void assert_float_evaluates_to(Float f, const char * result) { } QUIZ_CASE(poincare_float_evaluate) { - assert_float_evaluates_to(Float::Builder(-1.23456789E30), "-1.23456789E30"); - assert_float_evaluates_to(Float::Builder(1.23456789E30), "1.23456789E30"); - assert_float_evaluates_to(Float::Builder(-1.23456789E-30), "-1.23456789E-30"); + assert_float_evaluates_to(Float::Builder(-1.23456789E30), "-1.23456789ᴇ30"); + assert_float_evaluates_to(Float::Builder(1.23456789E30), "1.23456789ᴇ30"); + assert_float_evaluates_to(Float::Builder(-1.23456789E-30), "-1.23456789ᴇ-30"); assert_float_evaluates_to(Float::Builder(-1.2345E-3), "-0.0012345"); assert_float_evaluates_to(Float::Builder(1.2345E-3), "0.0012345"); assert_float_evaluates_to(Float::Builder(1.2345E3), "1234.5"); assert_float_evaluates_to(Float::Builder(-1.2345E3), "-1234.5"); - assert_float_evaluates_to(Float::Builder(0.99999999999995), "9.9999999999995E-1"); - assert_float_evaluates_to(Float::Builder(0.00000099999999999995), "9.9999999999995E-7"); - assert_float_evaluates_to(Float::Builder(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7"); + assert_float_evaluates_to(Float::Builder(0.99999999999995), "9.9999999999995ᴇ-1"); + assert_float_evaluates_to(Float::Builder(0.00000099999999999995), "9.9999999999995ᴇ-7"); + assert_float_evaluates_to(Float::Builder(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012ᴇ-7"); assert_float_evaluates_to(Float::Builder(1.2345E-1), "0.12345"); assert_float_evaluates_to(Float::Builder(1), "1"); assert_float_evaluates_to(Float::Builder(0.9999999999999995), "1"); diff --git a/poincare/test/function.cpp b/poincare/test/function.cpp index 9b7d343c7..f8a406032 100644 --- a/poincare/test/function.cpp +++ b/poincare/test/function.cpp @@ -20,9 +20,9 @@ QUIZ_CASE(poincare_parse_function) { assert_parsed_expression_type("abs(-1)", ExpressionNode::Type::AbsoluteValue); assert_parsed_expression_type("binomial(10, 4)", ExpressionNode::Type::BinomialCoefficient); assert_parsed_expression_type("ceil(0.2)", ExpressionNode::Type::Ceiling); - assert_parsed_expression_type("arg(2+I)", ExpressionNode::Type::ComplexArgument); + assert_parsed_expression_type("arg(2+𝐢)", ExpressionNode::Type::ComplexArgument); assert_parsed_expression_type("det([[1,2,3][4,5,6][7,8,9]])", ExpressionNode::Type::Determinant); - assert_parsed_expression_type("diff(2*x, x, 2)", ExpressionNode::Type::Derivative); + assert_parsed_expression_type("diff(2×x, x, 2)", ExpressionNode::Type::Derivative); #if MATRICES_ARE_DEFINED assert_parsed_expression_type("dim([[2]])", ExpressionNode::Type::MatrixDimension); #endif @@ -32,7 +32,7 @@ QUIZ_CASE(poincare_parse_function) { assert_parsed_expression_type("floor(2.3)", ExpressionNode::Type::Floor); assert_parsed_expression_type("frac(2.3)", ExpressionNode::Type::FracPart); assert_parsed_expression_type("gcd(2,3)", ExpressionNode::Type::GreatCommonDivisor); - assert_parsed_expression_type("im(2+I)", ExpressionNode::Type::ImaginaryPart); + assert_parsed_expression_type("im(2+𝐢)", ExpressionNode::Type::ImaginaryPart); assert_parsed_expression_type("lcm(2,3)", ExpressionNode::Type::LeastCommonMultiple); assert_parsed_expression_type("int(x, x, 2, 3)", ExpressionNode::Type::Integral); #if MATRICES_ARE_DEFINED @@ -49,10 +49,10 @@ QUIZ_CASE(poincare_parse_function) { assert_parsed_expression_type("random()", ExpressionNode::Type::Random); assert_parsed_expression_type("randint(1, 2)", ExpressionNode::Type::Randint); - assert_parsed_expression_type("re(2+I)", ExpressionNode::Type::RealPart); + assert_parsed_expression_type("re(2+𝐢)", ExpressionNode::Type::RealPart); assert_parsed_expression_type("rem(29, 10)", ExpressionNode::Type::DivisionRemainder); assert_parsed_expression_type("root(2,3)", ExpressionNode::Type::NthRoot); - assert_parsed_expression_type("R(2)", ExpressionNode::Type::SquareRoot); + assert_parsed_expression_type("√(2)", ExpressionNode::Type::SquareRoot); assert_parsed_expression_type("round(2,3)", ExpressionNode::Type::Round); assert_parsed_expression_type("sign(3)", ExpressionNode::Type::SignFunction); assert_parsed_expression_type("sum(n,n, 4, 10)", ExpressionNode::Type::Sum); @@ -68,14 +68,14 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluates_to("abs(-1)", "1"); assert_parsed_expression_evaluates_to("abs(-1)", "1"); - assert_parsed_expression_evaluates_to("abs(3+2I)", "3.605551"); - assert_parsed_expression_evaluates_to("abs(3+2I)", "3.605551275464"); + assert_parsed_expression_evaluates_to("abs(3+2𝐢)", "3.605551"); + assert_parsed_expression_evaluates_to("abs(3+2𝐢)", "3.605551275464"); assert_parsed_expression_evaluates_to("abs([[1,-2][3,-4]])", "[[1,2][3,4]]"); assert_parsed_expression_evaluates_to("abs([[1,-2][3,-4]])", "[[1,2][3,4]]"); - assert_parsed_expression_evaluates_to("abs([[3+2I,3+4I][5+2I,3+2I]])", "[[3.605551,5][5.385165,3.605551]]"); - assert_parsed_expression_evaluates_to("abs([[3+2I,3+4I][5+2I,3+2I]])", "[[3.605551275464,5][5.3851648071345,3.605551275464]]"); + assert_parsed_expression_evaluates_to("abs([[3+2𝐢,3+4𝐢][5+2𝐢,3+2𝐢]])", "[[3.605551,5][5.385165,3.605551]]"); + assert_parsed_expression_evaluates_to("abs([[3+2𝐢,3+4𝐢][5+2𝐢,3+2𝐢]])", "[[3.605551275464,5][5.3851648071345,3.605551275464]]"); assert_parsed_expression_evaluates_to("binomial(10, 4)", "210"); assert_parsed_expression_evaluates_to("binomial(10, 4)", "210"); @@ -86,14 +86,16 @@ QUIZ_CASE(poincare_function_evaluate) { #if MATRICES_ARE_DEFINED assert_parsed_expression_evaluates_to("det([[1,23,3][4,5,6][7,8,9]])", "126", System, Degree, Cartesian, 6); // FIXME: the determinant computation is not precised enough to be displayed with 7 significant digits assert_parsed_expression_evaluates_to("det([[1,23,3][4,5,6][7,8,9]])", "126"); - assert_parsed_expression_evaluates_to("det([[I,23-2I,3*I][4+I,5*I,6][7,8*I+2,9]])", "126-231*I", System, Degree, Cartesian, 6); // FIXME: the determinant computation is not precised enough to be displayed with 7 significant digits - assert_parsed_expression_evaluates_to("det([[I,23-2I,3*I][4+I,5*I,6][7,8*I+2,9]])", "126-231*I"); -#endif - assert_parsed_expression_evaluates_to("diff(2*x, x, 2)", "2"); - assert_parsed_expression_evaluates_to("diff(2*x, x, 2)", "2"); - assert_parsed_expression_evaluates_to("diff(2*TO^2, TO, 7)", "28"); - assert_parsed_expression_evaluates_to("diff(2*TO^2, TO, 7)", "28"); + assert_parsed_expression_evaluates_to("det([[𝐢,23-2𝐢,3×𝐢][4+𝐢,5×𝐢,6][7,8×𝐢+2,9]])", "126-231×𝐢", System, Degree, Cartesian, 6); // FIXME: the determinant computation is not precised enough to be displayed with 7 significant digits + assert_parsed_expression_evaluates_to("det([[𝐢,23-2𝐢,3×𝐢][4+𝐢,5×𝐢,6][7,8×𝐢+2,9]])", "126-231×𝐢"); +#endif + + assert_parsed_expression_evaluates_to("diff(2×x, x, 2)", "2"); + assert_parsed_expression_evaluates_to("diff(2×x, x, 2)", "2"); + + assert_parsed_expression_evaluates_to("diff(2×TO^2, TO, 7)", "28"); + assert_parsed_expression_evaluates_to("diff(2×TO^2, TO, 7)", "28"); assert_parsed_expression_evaluates_to("floor(2.3)", "2"); assert_parsed_expression_evaluates_to("floor(2.3)", "2"); @@ -104,8 +106,8 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluates_to("gcd(234,394)", "2"); assert_parsed_expression_evaluates_to("gcd(234,394)", "2"); - assert_parsed_expression_evaluates_to("im(2+3I)", "3"); - assert_parsed_expression_evaluates_to("im(2+3I)", "3"); + assert_parsed_expression_evaluates_to("im(2+3𝐢)", "3"); + assert_parsed_expression_evaluates_to("im(2+3𝐢)", "3"); assert_parsed_expression_evaluates_to("lcm(234,394)", "46098"); assert_parsed_expression_evaluates_to("lcm(234,394)", "46098"); @@ -114,10 +116,10 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluates_to("int(x,x, 1, 2)", "1.5"); assert_parsed_expression_evaluates_to("ln(2)", "0.6931472"); - assert_parsed_expression_evaluates_to("ln(2)", "6.9314718055995E-1"); + assert_parsed_expression_evaluates_to("ln(2)", "6.9314718055995ᴇ-1"); assert_parsed_expression_evaluates_to("log(2)", "0.30103"); - assert_parsed_expression_evaluates_to("log(2)", "3.0102999566398E-1"); + assert_parsed_expression_evaluates_to("log(2)", "3.0102999566398ᴇ-1"); assert_parsed_expression_evaluates_to("permute(10, 4)", "5040"); assert_parsed_expression_evaluates_to("permute(10, 4)", "5040"); @@ -128,19 +130,19 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluates_to("quo(29, 10)", "2"); assert_parsed_expression_evaluates_to("quo(29, 10)", "2"); - assert_parsed_expression_evaluates_to("re(2+I)", "2"); - assert_parsed_expression_evaluates_to("re(2+I)", "2"); + assert_parsed_expression_evaluates_to("re(2+𝐢)", "2"); + assert_parsed_expression_evaluates_to("re(2+𝐢)", "2"); assert_parsed_expression_evaluates_to("rem(29, 10)", "9"); assert_parsed_expression_evaluates_to("rem(29, 10)", "9"); assert_parsed_expression_evaluates_to("root(2,3)", "1.259921"); assert_parsed_expression_evaluates_to("root(2,3)", "1.2599210498949"); - assert_parsed_expression_evaluates_to("R(2)", "1.414214"); - assert_parsed_expression_evaluates_to("R(2)", "1.4142135623731"); + assert_parsed_expression_evaluates_to("√(2)", "1.414214"); + assert_parsed_expression_evaluates_to("√(2)", "1.4142135623731"); - assert_parsed_expression_evaluates_to("R(-1)", "I"); - assert_parsed_expression_evaluates_to("R(-1)", "I"); + assert_parsed_expression_evaluates_to("√(-1)", "𝐢"); + assert_parsed_expression_evaluates_to("√(-1)", "𝐢"); assert_parsed_expression_evaluates_to("sum(r,r, 4, 10)", "49"); assert_parsed_expression_evaluates_to("sum(k,k, 4, 10)", "49"); @@ -158,17 +160,17 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluates_to("dim([[1,2,3][4,5,-6]])", "[[2,3]]"); #endif - assert_parsed_expression_evaluates_to("conj(3+2*I)", "3-2*I"); - assert_parsed_expression_evaluates_to("conj(3+2*I)", "3-2*I"); + assert_parsed_expression_evaluates_to("conj(3+2×𝐢)", "3-2×𝐢"); + assert_parsed_expression_evaluates_to("conj(3+2×𝐢)", "3-2×𝐢"); assert_parsed_expression_evaluates_to("factor(-23/4)", "-5.75"); assert_parsed_expression_evaluates_to("factor(-123/24)", "-5.125"); #if MATRICES_ARE_DEFINED assert_parsed_expression_evaluates_to("inverse([[1,2,3][4,5,-6][7,8,9]])", "[[-1.2917,-0.083333,0.375][1.0833,0.16667,-0.25][0.041667,-0.083333,0.041667]]", System, Degree, Cartesian, 5); // inverse is not precise enough to display 7 significative digits - assert_parsed_expression_evaluates_to("inverse([[1,2,3][4,5,-6][7,8,9]])", "[[-1.2916666666667,-8.3333333333333E-2,0.375][1.0833333333333,1.6666666666667E-1,-0.25][4.1666666666667E-2,-8.3333333333333E-2,4.1666666666667E-2]]"); - assert_parsed_expression_evaluates_to("inverse([[I,23-2I,3*I][4+I,5*I,6][7,8*I+2,9]])", "[[-0.0118-0.0455*I,-0.5-0.727*I,0.318+0.489*I][0.0409+0.00364*I,0.04-0.0218*I,-0.0255+0.00091*I][0.00334-0.00182*I,0.361+0.535*I,-0.13-0.358*I]]", System, Degree, Cartesian, 3); // inverse is not precise enough to display 7 significative digits - assert_parsed_expression_evaluates_to("inverse([[I,23-2I,3*I][4+I,5*I,6][7,8*I+2,9]])", "[[-0.0118289353958-0.0454959053685*I,-0.500454959054-0.727024567789*I,0.31847133758+0.488626023658*I][0.0409463148317+3.63967242948E-3*I,0.0400363967243-0.0218380345769*I,-0.0254777070064+9.0991810737E-4*I][3.33636639369E-3-1.81983621474E-3*I,0.36093418259+0.534728541098*I,-0.130118289354-0.357597816197*I]]", System, Degree, Cartesian, 12); // FIXME: inverse is not precise enough to display 14 significative digits + assert_parsed_expression_evaluates_to("inverse([[1,2,3][4,5,-6][7,8,9]])", "[[-1.2916666666667,-8.3333333333333ᴇ-2,0.375][1.0833333333333,1.6666666666667ᴇ-1,-0.25][4.1666666666667ᴇ-2,-8.3333333333333ᴇ-2,4.1666666666667ᴇ-2]]"); + assert_parsed_expression_evaluates_to("inverse([[𝐢,23-2𝐢,3×𝐢][4+𝐢,5×𝐢,6][7,8×𝐢+2,9]])", "[[-0.0118-0.0455×𝐢,-0.5-0.727×𝐢,0.318+0.489×𝐢][0.0409+0.00364×𝐢,0.04-0.0218×𝐢,-0.0255+0.00091×𝐢][0.00334-0.00182×𝐢,0.361+0.535×𝐢,-0.13-0.358×𝐢]]", System, Degree, Cartesian, 3); // inverse is not precise enough to display 7 significative digits + assert_parsed_expression_evaluates_to("inverse([[𝐢,23-2𝐢,3×𝐢][4+𝐢,5×𝐢,6][7,8×𝐢+2,9]])", "[[-0.0118289353958-0.0454959053685×𝐢,-0.500454959054-0.727024567789×𝐢,0.31847133758+0.488626023658×𝐢][0.0409463148317+3.63967242948ᴇ-3×𝐢,0.0400363967243-0.0218380345769×𝐢,-0.0254777070064+9.0991810737ᴇ-4×𝐢][3.33636639369ᴇ-3-1.81983621474ᴇ-3×𝐢,0.36093418259+0.534728541098×𝐢,-0.130118289354-0.357597816197×𝐢]]", System, Degree, Cartesian, 12); // FIXME: inverse is not precise enough to display 14 significative digits #endif assert_parsed_expression_evaluates_to("prediction(0.1, 100)", "[[0,0.2]]"); @@ -177,20 +179,20 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluates_to("prediction95(0.1, 100)", "[[0.0412,0.1588]]"); assert_parsed_expression_evaluates_to("prediction95(0.1, 100)", "[[0.0412,0.1588]]"); - assert_parsed_expression_evaluates_to("product(2+k*I,k, 1, 5)", "-100-540*I"); - assert_parsed_expression_evaluates_to("product(2+o*I,o, 1, 5)", "-100-540*I"); + assert_parsed_expression_evaluates_to("product(2+k×𝐢,k, 1, 5)", "-100-540×𝐢"); + assert_parsed_expression_evaluates_to("product(2+o×𝐢,o, 1, 5)", "-100-540×𝐢"); - assert_parsed_expression_evaluates_to("root(3+I, 3)", "1.459366+0.1571201*I"); - assert_parsed_expression_evaluates_to("root(3+I, 3)", "1.4593656008684+1.5712012294394E-1*I"); + assert_parsed_expression_evaluates_to("root(3+𝐢, 3)", "1.459366+0.1571201×𝐢"); + assert_parsed_expression_evaluates_to("root(3+𝐢, 3)", "1.4593656008684+1.5712012294394ᴇ-1×𝐢"); - assert_parsed_expression_evaluates_to("root(3, 3+I)", "1.382007-0.1524428*I"); - assert_parsed_expression_evaluates_to("root(3, 3+I)", "1.3820069623326-0.1524427794159*I"); + assert_parsed_expression_evaluates_to("root(3, 3+𝐢)", "1.382007-0.1524428×𝐢"); + assert_parsed_expression_evaluates_to("root(3, 3+𝐢)", "1.3820069623326-0.1524427794159×𝐢"); - assert_parsed_expression_evaluates_to("root(5^((-I)3^9),I)", "3.504", System, Degree, Cartesian, 4); - assert_parsed_expression_evaluates_to("root(5^((-I)3^9),I)", "3.5039410843", System, Degree, Cartesian, 11); + assert_parsed_expression_evaluates_to("root(5^((-𝐢)3^9),𝐢)", "3.504", System, Degree, Cartesian, 4); + assert_parsed_expression_evaluates_to("root(5^((-𝐢)3^9),𝐢)", "3.5039410843", System, Degree, Cartesian, 11); - assert_parsed_expression_evaluates_to("R(3+I)", "1.755317+0.2848488*I"); - assert_parsed_expression_evaluates_to("R(3+I)", "1.7553173018244+2.8484878459314E-1*I"); + assert_parsed_expression_evaluates_to("√(3+𝐢)", "1.755317+0.2848488×𝐢"); + assert_parsed_expression_evaluates_to("√(3+𝐢)", "1.7553173018244+2.8484878459314ᴇ-1×𝐢"); assert_parsed_expression_evaluates_to("sign(-23+1)", "-1"); assert_parsed_expression_evaluates_to("sign(inf)", "1"); @@ -198,11 +200,11 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluates_to("sign(0)", "0"); assert_parsed_expression_evaluates_to("sign(-0)", "0"); assert_parsed_expression_evaluates_to("sign(x)", "undef"); - assert_parsed_expression_evaluates_to("sign(2+I)", "undef"); + assert_parsed_expression_evaluates_to("sign(2+𝐢)", "undef"); assert_parsed_expression_evaluates_to("sign(undef)", "undef"); - assert_parsed_expression_evaluates_to("sum(2+n*I,n,1,5)", "10+15*I"); - assert_parsed_expression_evaluates_to("sum(2+n*I,n,1,5)", "10+15*I"); + assert_parsed_expression_evaluates_to("sum(2+n×𝐢,n,1,5)", "10+15×𝐢"); + assert_parsed_expression_evaluates_to("sum(2+n×𝐢,n,1,5)", "10+15×𝐢"); #if MATRICES_ARE_DEFINED assert_parsed_expression_evaluates_to("transpose([[1,2,3][4,5,-6][7,8,9]])", "[[1,4,7][2,5,8][3,-6,9]]"); @@ -219,14 +221,14 @@ QUIZ_CASE(poincare_function_evaluate) { assert_parsed_expression_evaluates_to("6!", "720"); assert_parsed_expression_evaluates_to("6!", "720"); - assert_parsed_expression_evaluates_to("R(-1)", "I"); - assert_parsed_expression_evaluates_to("R(-1)", "I"); + assert_parsed_expression_evaluates_to("√(-1)", "𝐢"); + assert_parsed_expression_evaluates_to("√(-1)", "𝐢"); - assert_parsed_expression_evaluates_to("root(-1,3)", "0.5+0.8660254*I"); - assert_parsed_expression_evaluates_to("root(-1,3)", "0.5+8.6602540378444E-1*I"); + assert_parsed_expression_evaluates_to("root(-1,3)", "0.5+0.8660254×𝐢"); + assert_parsed_expression_evaluates_to("root(-1,3)", "0.5+8.6602540378444ᴇ-1×𝐢"); - assert_parsed_expression_evaluates_to("int(int(x*x,x,0,x),x,0,4)", "21.33333"); - assert_parsed_expression_evaluates_to("int(int(x*x,x,0,x),x,0,4)", "21.333333333333"); + assert_parsed_expression_evaluates_to("int(int(x×x,x,0,x),x,0,4)", "21.33333"); + assert_parsed_expression_evaluates_to("int(int(x×x,x,0,x),x,0,4)", "21.333333333333"); assert_parsed_expression_evaluates_to("int(1+cos(e),e, 0, 180)", "180"); assert_parsed_expression_evaluates_to("int(1+cos(e),e, 0, 180)", "180"); @@ -241,11 +243,11 @@ QUIZ_CASE(poincare_function_evaluate) { } QUIZ_CASE(poincare_function_simplify) { - assert_parsed_expression_simplify_to("abs(P)", "P"); - assert_parsed_expression_simplify_to("abs(-P)", "P"); - assert_parsed_expression_simplify_to("abs(1+I)", "R(2)"); + assert_parsed_expression_simplify_to("abs(π)", "π"); + assert_parsed_expression_simplify_to("abs(-π)", "π"); + assert_parsed_expression_simplify_to("abs(1+𝐢)", "√(2)"); assert_parsed_expression_simplify_to("abs(0)", "0"); - assert_parsed_expression_simplify_to("arg(1+I)", "P/4"); + assert_parsed_expression_simplify_to("arg(1+𝐢)", "π/4"); assert_parsed_expression_simplify_to("binomial(20,3)", "1140"); assert_parsed_expression_simplify_to("binomial(20,10)", "184756"); assert_parsed_expression_simplify_to("ceil(-1.3)", "-1"); @@ -257,21 +259,21 @@ QUIZ_CASE(poincare_function_simplify) { assert_parsed_expression_simplify_to("rem(-19,3)", "2"); assert_parsed_expression_simplify_to("rem(19,0)", Infinity::Name()); assert_parsed_expression_simplify_to("99!", "933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272237582511852109168640000000000000000000000"); - assert_parsed_expression_simplify_to("factor(-10008/6895)", "-(2^3*3^2*139)/(5*7*197)"); - assert_parsed_expression_simplify_to("factor(1008/6895)", "(2^4*3^2)/(5*197)"); + assert_parsed_expression_simplify_to("factor(-10008/6895)", "-(2^3×3^2×139)/(5×7×197)"); + assert_parsed_expression_simplify_to("factor(1008/6895)", "(2^4×3^2)/(5×197)"); assert_parsed_expression_simplify_to("factor(10007)", "10007"); assert_parsed_expression_simplify_to("factor(10007^2)", Undefined::Name()); assert_parsed_expression_simplify_to("floor(-1.3)", "-2"); assert_parsed_expression_simplify_to("frac(-1.3)", "7/10"); assert_parsed_expression_simplify_to("gcd(123,278)", "1"); assert_parsed_expression_simplify_to("gcd(11,121)", "11"); - assert_parsed_expression_simplify_to("im(1+5*I)", "5"); + assert_parsed_expression_simplify_to("im(1+5×𝐢)", "5"); assert_parsed_expression_simplify_to("lcm(123,278)", "34194"); assert_parsed_expression_simplify_to("lcm(11,121)", "121"); - assert_parsed_expression_simplify_to("R(4)", "2"); - assert_parsed_expression_simplify_to("re(1+5*I)", "1"); + assert_parsed_expression_simplify_to("√(4)", "2"); + assert_parsed_expression_simplify_to("re(1+5×𝐢)", "1"); assert_parsed_expression_simplify_to("root(4,3)", "root(4,3)"); - assert_parsed_expression_simplify_to("root(4,P)", "4^(1/P)"); + assert_parsed_expression_simplify_to("root(4,π)", "4^(1/π)"); assert_parsed_expression_simplify_to("root(27,3)", "3"); assert_parsed_expression_simplify_to("round(4.235,2)", "106/25"); assert_parsed_expression_simplify_to("round(4.23,0)", "4"); @@ -279,16 +281,16 @@ QUIZ_CASE(poincare_function_simplify) { assert_parsed_expression_simplify_to("round(12.9,-1)", "10"); assert_parsed_expression_simplify_to("round(12.9,-2)", "0"); assert_parsed_expression_simplify_to("sign(-23)", "-1"); - assert_parsed_expression_simplify_to("sign(-I)", "sign(-I)"); + assert_parsed_expression_simplify_to("sign(-𝐢)", "sign(-𝐢)"); assert_parsed_expression_simplify_to("sign(0)", "0"); assert_parsed_expression_simplify_to("sign(inf)", "1"); assert_parsed_expression_simplify_to("sign(-inf)", "-1"); assert_parsed_expression_simplify_to("sign(undef)", "undef"); assert_parsed_expression_simplify_to("sign(23)", "1"); assert_parsed_expression_simplify_to("sign(log(18))", "1"); - assert_parsed_expression_simplify_to("sign(-R(2))", "-1"); + assert_parsed_expression_simplify_to("sign(-√(2))", "-1"); assert_parsed_expression_simplify_to("sign(x)", "sign(x)"); - assert_parsed_expression_simplify_to("sign(2+I)", "sign(2+I)"); + assert_parsed_expression_simplify_to("sign(2+𝐢)", "sign(2+𝐢)"); assert_parsed_expression_simplify_to("permute(99,4)", "90345024"); assert_parsed_expression_simplify_to("permute(20,-10)", Undefined::Name()); assert_parsed_expression_simplify_to("re(1/2)", "1/2"); diff --git a/poincare/test/infinity.cpp b/poincare/test/infinity.cpp index c84e8765f..bd11f2500 100644 --- a/poincare/test/infinity.cpp +++ b/poincare/test/infinity.cpp @@ -16,28 +16,28 @@ QUIZ_CASE(poincare_infinity) { assert_parsed_expression_simplify_to("0/0", Undefined::Name()); assert_parsed_expression_simplify_to("0/inf", "0"); assert_parsed_expression_simplify_to("inf/0", Undefined::Name()); - assert_parsed_expression_simplify_to("0*inf", Undefined::Name()); - assert_parsed_expression_simplify_to("3*inf/inf", "undef"); - assert_parsed_expression_simplify_to("1E1000", "inf"); - assert_parsed_expression_simplify_to("-1E1000", "-inf"); - assert_parsed_expression_simplify_to("-1E-1000", "0"); - assert_parsed_expression_simplify_to("1E-1000", "0"); - assert_parsed_expression_evaluates_to("1*10^1000", "inf"); + assert_parsed_expression_simplify_to("0×inf", Undefined::Name()); + assert_parsed_expression_simplify_to("3×inf/inf", "undef"); + assert_parsed_expression_simplify_to("1ᴇ1000", "inf"); + assert_parsed_expression_simplify_to("-1ᴇ1000", "-inf"); + assert_parsed_expression_simplify_to("-1ᴇ-1000", "0"); + assert_parsed_expression_simplify_to("1ᴇ-1000", "0"); + assert_parsed_expression_evaluates_to("1×10^1000", "inf"); assert_parsed_expression_simplify_to("inf^0", "undef"); assert_parsed_expression_simplify_to("1^inf", "1^inf"); assert_parsed_expression_simplify_to("1^(X^inf)", "1^(X^inf)"); assert_parsed_expression_simplify_to("inf^(-1)", "0"); assert_parsed_expression_simplify_to("(-inf)^(-1)", "0"); - assert_parsed_expression_simplify_to("inf^(-R(2))", "0"); - assert_parsed_expression_simplify_to("(-inf)^(-R(2))", "0"); + assert_parsed_expression_simplify_to("inf^(-√(2))", "0"); + assert_parsed_expression_simplify_to("(-inf)^(-√(2))", "0"); assert_parsed_expression_simplify_to("inf^2", "inf"); assert_parsed_expression_simplify_to("(-inf)^2", "inf"); - assert_parsed_expression_simplify_to("inf^R(2)", "inf"); - assert_parsed_expression_simplify_to("(-inf)^R(2)", "inf*(-1)^R(2)"); + assert_parsed_expression_simplify_to("inf^√(2)", "inf"); + assert_parsed_expression_simplify_to("(-inf)^√(2)", "inf×(-1)^√(2)"); assert_parsed_expression_simplify_to("inf^x", "inf^x"); assert_parsed_expression_simplify_to("1/inf+24", "24"); - assert_parsed_expression_simplify_to("X^(inf)/inf", "0*X^inf"); + assert_parsed_expression_simplify_to("ℯ^(inf)/inf", "0×ℯ^inf"); // Logarithm assert_parsed_expression_simplify_to("log(inf,0)", "undef"); diff --git a/poincare/test/layouts.cpp b/poincare/test/layouts.cpp index 05886d548..27b7c272f 100644 --- a/poincare/test/layouts.cpp +++ b/poincare/test/layouts.cpp @@ -270,6 +270,6 @@ QUIZ_CASE(poincare_parse_layouts) { CodePointLayout::Builder('3'), VerticalOffsetLayoutNode::Type::Superscript)); e = Multiplication::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(KDCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3)))); - assert_parsed_expression_is("2X^(3)", Multiplication::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(KDCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3))))); + assert_parsed_expression_is("2ℯ^(3)", Multiplication::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(KDCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3))))); assert_parsed_layout_is(l, e); } diff --git a/poincare/test/logarithm.cpp b/poincare/test/logarithm.cpp index 8354a4bec..a9df86dc0 100644 --- a/poincare/test/logarithm.cpp +++ b/poincare/test/logarithm.cpp @@ -10,16 +10,16 @@ QUIZ_CASE(poincare_logarithm_evaluate) { assert_parsed_expression_evaluates_to("log(6,7)", "0.9207822211616"); assert_parsed_expression_evaluates_to("log(5)", "0.69897"); assert_parsed_expression_evaluates_to("ln(5)", "1.6094379124341"); - assert_parsed_expression_evaluates_to("log(2+5*I,64)", "0.4048317+0.2862042*I"); - assert_parsed_expression_evaluates_to("log(6,7+4*I)", "8.0843880717528E-1-2.0108238082167E-1*I"); - assert_parsed_expression_evaluates_to("log(5+2*I)", "0.731199+0.1652518*I"); - assert_parsed_expression_evaluates_to("ln(5+2*I)", "1.6836479149932+3.8050637711236E-1*I"); + assert_parsed_expression_evaluates_to("log(2+5×𝐢,64)", "0.4048317+0.2862042×𝐢"); + assert_parsed_expression_evaluates_to("log(6,7+4×𝐢)", "8.0843880717528ᴇ-1-2.0108238082167ᴇ-1×𝐢"); + assert_parsed_expression_evaluates_to("log(5+2×𝐢)", "0.731199+0.1652518×𝐢"); + assert_parsed_expression_evaluates_to("ln(5+2×𝐢)", "1.6836479149932+3.8050637711236ᴇ-1×𝐢"); assert_parsed_expression_evaluates_to("log(0,0)", Undefined::Name()); assert_parsed_expression_evaluates_to("log(0)", "-inf"); assert_parsed_expression_evaluates_to("log(2,0)", "0"); // WARNING: evaluate on branch cut can be multivalued - assert_parsed_expression_evaluates_to("ln(-4)", "1.3862943611199+3.1415926535898*I"); + assert_parsed_expression_evaluates_to("ln(-4)", "1.3862943611199+3.1415926535898×𝐢"); } QUIZ_CASE(poincare_logarithm_simplify) { @@ -29,35 +29,35 @@ QUIZ_CASE(poincare_logarithm_simplify) { assert_parsed_expression_simplify_to("log(2,0)", "0"); assert_parsed_expression_simplify_to("log(0,14)", "-inf"); assert_parsed_expression_simplify_to("log(0,0.14)", Infinity::Name()); - assert_parsed_expression_simplify_to("log(0,0.14+I)", Undefined::Name()); + assert_parsed_expression_simplify_to("log(0,0.14+𝐢)", Undefined::Name()); assert_parsed_expression_simplify_to("log(2,1)", Undefined::Name()); assert_parsed_expression_simplify_to("log(x,1)", Undefined::Name()); - assert_parsed_expression_simplify_to("log(12925)", "log(47)+log(11)+2*log(5)"); - assert_parsed_expression_simplify_to("ln(12925)", "ln(47)+ln(11)+2*ln(5)"); - assert_parsed_expression_simplify_to("log(1742279/12925, 6)", "-log(47,6)+log(17,6)+3*log(11,6)+log(7,6)-2*log(5,6)"); + assert_parsed_expression_simplify_to("log(12925)", "log(47)+log(11)+2×log(5)"); + assert_parsed_expression_simplify_to("ln(12925)", "ln(47)+ln(11)+2×ln(5)"); + assert_parsed_expression_simplify_to("log(1742279/12925, 6)", "-log(47,6)+log(17,6)+3×log(11,6)+log(7,6)-2×log(5,6)"); assert_parsed_expression_simplify_to("ln(2/3)", "-ln(3)+ln(2)"); assert_parsed_expression_simplify_to("log(1742279/12925, -6)", "log(158389/1175,-6)"); - assert_parsed_expression_simplify_to("ln(R(2))", "ln(2)/2"); - assert_parsed_expression_simplify_to("ln(X^3)", "3"); + assert_parsed_expression_simplify_to("ln(√(2))", "ln(2)/2"); + assert_parsed_expression_simplify_to("ln(ℯ^3)", "3"); assert_parsed_expression_simplify_to("log(10)", "1"); - assert_parsed_expression_simplify_to("log(R(3),R(3))", "1"); - assert_parsed_expression_simplify_to("log(1/R(2))", "-log(2)/2"); - assert_parsed_expression_simplify_to("log(-I)", "log(-I)"); - assert_parsed_expression_simplify_to("ln(X^(IP/7))", "P/7*I"); + assert_parsed_expression_simplify_to("log(√(3),√(3))", "1"); + assert_parsed_expression_simplify_to("log(1/√(2))", "-log(2)/2"); + assert_parsed_expression_simplify_to("log(-𝐢)", "log(-𝐢)"); + assert_parsed_expression_simplify_to("ln(ℯ^(𝐢π/7))", "π/7×𝐢"); assert_parsed_expression_simplify_to("log(10^24)", "24"); - assert_parsed_expression_simplify_to("log((23P)^4,23P)", "4"); - assert_parsed_expression_simplify_to("log(10^(2+P))", "P+2"); + assert_parsed_expression_simplify_to("log((23π)^4,23π)", "4"); + assert_parsed_expression_simplify_to("log(10^(2+π))", "π+2"); assert_parsed_expression_simplify_to("ln(1881676377434183981909562699940347954480361860897069)", "ln(1881676377434183981909562699940347954480361860897069)"); - /* log(1002101470343) does no reduce to 3*log(10007) because it involves + /* log(1002101470343) does no reduce to 3×log(10007) because it involves * prime factors above k_biggestPrimeFactor */ assert_parsed_expression_simplify_to("log(1002101470343)", "log(1002101470343)"); assert_parsed_expression_simplify_to("log(64,2)", "6"); assert_parsed_expression_simplify_to("log(2,64)", "log(2,64)"); - assert_parsed_expression_simplify_to("log(1476225,5)", "10*log(3,5)+2"); + assert_parsed_expression_simplify_to("log(1476225,5)", "10×log(3,5)+2"); assert_parsed_expression_simplify_to("log(100)", "2"); assert_parsed_expression_simplify_to("log(1000000)", "6"); - assert_parsed_expression_simplify_to("log(70992768,14)", "log(11,14)+log(3,14)+2*log(2,14)+5"); + assert_parsed_expression_simplify_to("log(70992768,14)", "log(11,14)+log(3,14)+2×log(2,14)+5"); assert_parsed_expression_simplify_to("log(1/6991712,14)", "-log(13,14)-5"); - assert_parsed_expression_simplify_to("log(4,10)", "2*log(2)"); + assert_parsed_expression_simplify_to("log(4,10)", "2×log(2)"); } diff --git a/poincare/test/multiplication.cpp b/poincare/test/multiplication.cpp index 41d4fd816..cb6acc0ff 100644 --- a/poincare/test/multiplication.cpp +++ b/poincare/test/multiplication.cpp @@ -6,69 +6,69 @@ using namespace Poincare; QUIZ_CASE(poincare_multiplication_evaluate) { - assert_parsed_expression_evaluates_to("1*2", "2"); - assert_parsed_expression_evaluates_to("(3+I)*(4+I)", "11+7*I"); + assert_parsed_expression_evaluates_to("1×2", "2"); + assert_parsed_expression_evaluates_to("(3+𝐢)×(4+𝐢)", "11+7×𝐢"); #if MATRICES_ARE_DEFINED - assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]*2", "[[2,4][6,8][10,12]]"); - assert_parsed_expression_evaluates_to("[[1,2+I][3,4][5,6]]*(3+I)", "[[3+I,5+5*I][9+3*I,12+4*I][15+5*I,18+6*I]]"); - assert_parsed_expression_evaluates_to("2*[[1,2][3,4][5,6]]", "[[2,4][6,8][10,12]]"); - assert_parsed_expression_evaluates_to("(3+I)*[[1,2+I][3,4][5,6]]", "[[3+I,5+5*I][9+3*I,12+4*I][15+5*I,18+6*I]]"); - assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]*[[1,2,3,4][5,6,7,8]]", "[[11,14,17,20][23,30,37,44][35,46,57,68]]"); - assert_parsed_expression_evaluates_to("[[1,2+I][3,4][5,6]]*[[1,2+I,3,4][5,6+I,7,8]]", "[[11+5*I,13+9*I,17+7*I,20+8*I][23,30+7*I,37,44][35,46+11*I,57,68]]"); + assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]×2", "[[2,4][6,8][10,12]]"); + assert_parsed_expression_evaluates_to("[[1,2+𝐢][3,4][5,6]]×(3+𝐢)", "[[3+𝐢,5+5×𝐢][9+3×𝐢,12+4×𝐢][15+5×𝐢,18+6×𝐢]]"); + assert_parsed_expression_evaluates_to("2×[[1,2][3,4][5,6]]", "[[2,4][6,8][10,12]]"); + assert_parsed_expression_evaluates_to("(3+𝐢)×[[1,2+𝐢][3,4][5,6]]", "[[3+𝐢,5+5×𝐢][9+3×𝐢,12+4×𝐢][15+5×𝐢,18+6×𝐢]]"); + assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]×[[1,2,3,4][5,6,7,8]]", "[[11,14,17,20][23,30,37,44][35,46,57,68]]"); + assert_parsed_expression_evaluates_to("[[1,2+𝐢][3,4][5,6]]×[[1,2+𝐢,3,4][5,6+𝐢,7,8]]", "[[11+5×𝐢,13+9×𝐢,17+7×𝐢,20+8×𝐢][23,30+7×𝐢,37,44][35,46+11×𝐢,57,68]]"); #endif } QUIZ_CASE(poincare_multiplication_simplify) { - assert_parsed_expression_simplify_to("undef*x", "undef"); - assert_parsed_expression_simplify_to("0*x+B", "B"); - assert_parsed_expression_simplify_to("0*x*0*32*cos(3)", "0"); - assert_parsed_expression_simplify_to("3*A^4*B^x*B^2*(A^2+2)*2*1.2", "(36*A^6*B^(x+2)+72*A^4*B^(x+2))/5"); - assert_parsed_expression_simplify_to("A*(B+C)*(D+3)", "3*A*B+3*A*C+A*B*D+A*C*D"); + assert_parsed_expression_simplify_to("undef×x", "undef"); + assert_parsed_expression_simplify_to("0×x+B", "B"); + assert_parsed_expression_simplify_to("0×x×0×32×cos(3)", "0"); + assert_parsed_expression_simplify_to("3×A^4×B^x×B^2×(A^2+2)×2×1.2", "(36×A^6×B^(x+2)+72×A^4×B^(x+2))/5"); + assert_parsed_expression_simplify_to("A×(B+C)×(D+3)", "3×A×B+3×A×C+A×B×D+A×C×D"); assert_parsed_expression_simplify_to("A/B", "A/B"); - assert_parsed_expression_simplify_to("(A*B)^2", "A^2*B^2"); - assert_parsed_expression_simplify_to("(1/2)*A/B", "A/(2*B)"); + assert_parsed_expression_simplify_to("(A×B)^2", "A^2×B^2"); + assert_parsed_expression_simplify_to("(1/2)×A/B", "A/(2×B)"); assert_parsed_expression_simplify_to("1+2+3+4+5+6", "21"); assert_parsed_expression_simplify_to("1-2+3-4+5-6", "-3"); - assert_parsed_expression_simplify_to("987654321123456789*998877665544332211", "986545842648570754445552922919330479"); + assert_parsed_expression_simplify_to("987654321123456789×998877665544332211", "986545842648570754445552922919330479"); assert_parsed_expression_simplify_to("2/3", "2/3"); assert_parsed_expression_simplify_to("9/17+5/4", "121/68"); - assert_parsed_expression_simplify_to("1/2*3/4", "3/8"); - assert_parsed_expression_simplify_to("0*2/3", "0"); + assert_parsed_expression_simplify_to("1/2×3/4", "3/8"); + assert_parsed_expression_simplify_to("0×2/3", "0"); assert_parsed_expression_simplify_to("1+(1/(1+1/(1+1/(1+1))))", "8/5"); assert_parsed_expression_simplify_to("1+2/(3+4/(5+6/(7+8)))", "155/101"); - assert_parsed_expression_simplify_to("3/4*16/12", "1"); - assert_parsed_expression_simplify_to("3/4*(8+8)/12", "1"); + assert_parsed_expression_simplify_to("3/4×16/12", "1"); + assert_parsed_expression_simplify_to("3/4×(8+8)/12", "1"); assert_parsed_expression_simplify_to("916791/794976477", "305597/264992159"); assert_parsed_expression_simplify_to("321654987123456789/112233445566778899", "3249040273974311/1133671167341201"); assert_parsed_expression_simplify_to("0.1+0.2", "3/10"); assert_parsed_expression_simplify_to("2^3", "8"); - assert_parsed_expression_simplify_to("(-1)*(-1)", "1"); + assert_parsed_expression_simplify_to("(-1)×(-1)", "1"); assert_parsed_expression_simplify_to("(-2)^2", "4"); assert_parsed_expression_simplify_to("(-3)^3", "-27"); assert_parsed_expression_simplify_to("(1/2)^-1", "2"); - assert_parsed_expression_simplify_to("R(2)*R(3)", "R(6)"); - assert_parsed_expression_simplify_to("2*2^P", "2*2^P"); - assert_parsed_expression_simplify_to("A^3*B*A^(-3)", "B"); - assert_parsed_expression_simplify_to("A^3*A^(-3)", "1"); - assert_parsed_expression_simplify_to("2^P*(1/2)^P", "1"); - assert_parsed_expression_simplify_to("A^3*A^(-3)", "1"); - assert_parsed_expression_simplify_to("(x+1)*(x+2)", "x^2+3*x+2"); - assert_parsed_expression_simplify_to("(x+1)*(x-1)", "x^2-1"); - assert_parsed_expression_simplify_to("11P/(22P+11P)", "1/3"); - assert_parsed_expression_simplify_to("11/(22P+11P)", "1/(3*P)"); - assert_parsed_expression_simplify_to("-11/(22P+11P)", "-1/(3*P)"); - assert_parsed_expression_simplify_to("A^2*B*A^(-2)*B^(-2)", "1/B"); - assert_parsed_expression_simplify_to("A^(-1)*B^(-1)", "1/(A*B)"); - assert_parsed_expression_simplify_to("x+x", "2*x"); - assert_parsed_expression_simplify_to("2*x+x", "3*x"); - assert_parsed_expression_simplify_to("x*2+x", "3*x"); - assert_parsed_expression_simplify_to("2*x+2*x", "4*x"); - assert_parsed_expression_simplify_to("x*2+2*n", "2*n+2*x"); - assert_parsed_expression_simplify_to("x+x+n+n", "2*n+2*x"); + assert_parsed_expression_simplify_to("√(2)×√(3)", "√(6)"); + assert_parsed_expression_simplify_to("2×2^π", "2×2^π"); + assert_parsed_expression_simplify_to("A^3×B×A^(-3)", "B"); + assert_parsed_expression_simplify_to("A^3×A^(-3)", "1"); + assert_parsed_expression_simplify_to("2^π×(1/2)^π", "1"); + assert_parsed_expression_simplify_to("A^3×A^(-3)", "1"); + assert_parsed_expression_simplify_to("(x+1)×(x+2)", "x^2+3×x+2"); + assert_parsed_expression_simplify_to("(x+1)×(x-1)", "x^2-1"); + assert_parsed_expression_simplify_to("11π/(22π+11π)", "1/3"); + assert_parsed_expression_simplify_to("11/(22π+11π)", "1/(3×π)"); + assert_parsed_expression_simplify_to("-11/(22π+11π)", "-1/(3×π)"); + assert_parsed_expression_simplify_to("A^2×B×A^(-2)×B^(-2)", "1/B"); + assert_parsed_expression_simplify_to("A^(-1)×B^(-1)", "1/(A×B)"); + assert_parsed_expression_simplify_to("x+x", "2×x"); + assert_parsed_expression_simplify_to("2×x+x", "3×x"); + assert_parsed_expression_simplify_to("x×2+x", "3×x"); + assert_parsed_expression_simplify_to("2×x+2×x", "4×x"); + assert_parsed_expression_simplify_to("x×2+2×n", "2×n+2×x"); + assert_parsed_expression_simplify_to("x+x+n+n", "2×n+2×x"); assert_parsed_expression_simplify_to("x-x-n+n", "0"); assert_parsed_expression_simplify_to("x+n-x-n", "0"); assert_parsed_expression_simplify_to("x-x", "0"); - assert_parsed_expression_simplify_to("P*3^(1/2)*(5P)^(1/2)*(4/5)^(1/2)", "2*R(3)*P^(3/2)"); - assert_parsed_expression_simplify_to("12^(1/4)*(P/6)*(12*P)^(1/4)", "(R(3)*P^(5/4))/3"); + assert_parsed_expression_simplify_to("π×3^(1/2)×(5π)^(1/2)×(4/5)^(1/2)", "2×√(3)×π^(3/2)"); + assert_parsed_expression_simplify_to("12^(1/4)×(π/6)×(12×π)^(1/4)", "(√(3)×π^(5/4))/3"); } diff --git a/poincare/test/number.cpp b/poincare/test/number.cpp index 078ced52d..8bb30e4b2 100644 --- a/poincare/test/number.cpp +++ b/poincare/test/number.cpp @@ -29,10 +29,10 @@ QUIZ_CASE(poincare_number_parser) { assert_parsed_expression_is("12.34567", Decimal::Builder(Integer("1234567"), 1)); // Infinity - assert_parsed_expression_is("23E1000", Infinity::Builder(false)); - assert_parsed_expression_is("2.3E1000", Decimal::Builder(Integer(23), 1000)); + assert_parsed_expression_is("23ᴇ1000", Infinity::Builder(false)); + assert_parsed_expression_is("2.3ᴇ1000", Decimal::Builder(Integer(23), 1000)); // Zero - assert_parsed_expression_is("0.23E-1000", Decimal::Builder(Integer(0), 0)); - assert_parsed_expression_is("0.23E-999", Decimal::Builder(Integer(23), -1000)); + assert_parsed_expression_is("0.23ᴇ-1000", Decimal::Builder(Integer(0), 0)); + assert_parsed_expression_is("0.23ᴇ-999", Decimal::Builder(Integer(23), -1000)); } diff --git a/poincare/test/parser.cpp b/poincare/test/parser.cpp index 762100eae..c7d7b9f08 100644 --- a/poincare/test/parser.cpp +++ b/poincare/test/parser.cpp @@ -50,23 +50,23 @@ QUIZ_CASE(poincare_parser_tokenize_numbers) { assert_tokenizes_as_number("123"); assert_tokenizes_as_number("1.3"); assert_tokenizes_as_number(".3"); - assert_tokenizes_as_number("1.3E3"); - assert_tokenizes_as_number("12.34E56"); - assert_tokenizes_as_number(".3E-32"); + assert_tokenizes_as_number("1.3ᴇ3"); + assert_tokenizes_as_number("12.34ᴇ56"); + assert_tokenizes_as_number(".3ᴇ-32"); assert_tokenizes_as_number("12."); assert_tokenizes_as_number(".999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"); assert_tokenizes_as_number("0."); - assert_tokenizes_as_number("1.E-4"); - assert_tokenizes_as_number("1.E9999"); + assert_tokenizes_as_number("1.ᴇ-4"); + assert_tokenizes_as_number("1.ᴇ9999"); - assert_tokenizes_as_undefined_token("1E"); + assert_tokenizes_as_undefined_token("1ᴇ"); assert_tokenizes_as_undefined_token("1.."); assert_tokenizes_as_undefined_token(".."); - assert_tokenizes_as_undefined_token("1.EE"); - assert_tokenizes_as_undefined_token("1.E"); - assert_tokenizes_as_undefined_token("1E--4"); - assert_tokenizes_as_undefined_token("1.EE4"); - assert_tokenizes_as_undefined_token("1E2E4"); + assert_tokenizes_as_undefined_token("1.ᴇᴇ"); + assert_tokenizes_as_undefined_token("1.ᴇ"); + assert_tokenizes_as_undefined_token("1ᴇ--4"); + assert_tokenizes_as_undefined_token("1.ᴇᴇ4"); + assert_tokenizes_as_undefined_token("1ᴇ2ᴇ4"); } QUIZ_CASE(poincare_parser_parse_numbers) { @@ -79,14 +79,14 @@ QUIZ_CASE(poincare_parser_parse_numbers) { assert_parsed_expression_is("0.1", Decimal::Builder(0.1)); assert_parsed_expression_is("1.", Rational::Builder(1)); assert_parsed_expression_is(".1", Decimal::Builder(0.1)); - assert_parsed_expression_is("0E2", Decimal::Builder(0.0)); - assert_parsed_expression_is("0.1E2", Decimal::Builder(10.0)); - assert_parsed_expression_is("1.E2", Decimal::Builder(100.0)); - assert_parsed_expression_is(".1E2", Decimal::Builder(10.0)); - assert_parsed_expression_is("0E-2", Decimal::Builder(0.0)); - assert_parsed_expression_is("0.1E-2", Decimal::Builder(0.001)); - assert_parsed_expression_is("1.E-2", Decimal::Builder(0.01)); - assert_parsed_expression_is(".1E-2", Decimal::Builder(0.001)); + assert_parsed_expression_is("0ᴇ2", Decimal::Builder(0.0)); + assert_parsed_expression_is("0.1ᴇ2", Decimal::Builder(10.0)); + assert_parsed_expression_is("1.ᴇ2", Decimal::Builder(100.0)); + assert_parsed_expression_is(".1ᴇ2", Decimal::Builder(10.0)); + assert_parsed_expression_is("0ᴇ-2", Decimal::Builder(0.0)); + assert_parsed_expression_is("0.1ᴇ-2", Decimal::Builder(0.001)); + assert_parsed_expression_is("1.ᴇ-2", Decimal::Builder(0.01)); + assert_parsed_expression_is(".1ᴇ-2", Decimal::Builder(0.001)); } QUIZ_CASE(poincare_parser_memory_exhaustion) { @@ -122,16 +122,16 @@ QUIZ_CASE(poincare_parser_parse) { assert_parsed_expression_is("(1+2)", Parenthesis::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2)))); assert_parsed_expression_is("1+2+3", Addition::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); assert_parsed_expression_is("1+2+(3+4)", Addition::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2)),Parenthesis::Builder(Addition::Builder(Rational::Builder(3),Rational::Builder(4))))); - assert_parsed_expression_is("1*2", Multiplication::Builder(Rational::Builder(1),Rational::Builder(2))); - assert_parsed_expression_is("1*2*3", Multiplication::Builder(Multiplication::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); - assert_parsed_expression_is("1+2*3", Addition::Builder(Rational::Builder(1), Multiplication::Builder(Rational::Builder(2), Rational::Builder(3)))); + assert_parsed_expression_is("1×2", Multiplication::Builder(Rational::Builder(1),Rational::Builder(2))); + assert_parsed_expression_is("1×2×3", Multiplication::Builder(Multiplication::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); + assert_parsed_expression_is("1+2×3", Addition::Builder(Rational::Builder(1), Multiplication::Builder(Rational::Builder(2), Rational::Builder(3)))); assert_parsed_expression_is("1/2", Division::Builder(Rational::Builder(1),Rational::Builder(2))); assert_parsed_expression_is("(1/2)", Parenthesis::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)))); assert_parsed_expression_is("1/2/3", Division::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); - assert_parsed_expression_is("1/2*3", Multiplication::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); - assert_parsed_expression_is("(1/2*3)", Parenthesis::Builder(Multiplication::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)))); - assert_parsed_expression_is("1*2/3", Multiplication::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3)))); - assert_parsed_expression_is("(1*2/3)", Parenthesis::Builder(Multiplication::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3))))); + assert_parsed_expression_is("1/2×3", Multiplication::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); + assert_parsed_expression_is("(1/2×3)", Parenthesis::Builder(Multiplication::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)))); + assert_parsed_expression_is("1×2/3", Multiplication::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3)))); + assert_parsed_expression_is("(1×2/3)", Parenthesis::Builder(Multiplication::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3))))); assert_parsed_expression_is("(1/2/3)", Parenthesis::Builder(Division::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)))); assert_parsed_expression_is("1^2", Power::Builder(Rational::Builder(1),Rational::Builder(2))); assert_parsed_expression_is("1^2^3", Power::Builder(Rational::Builder(1),Power::Builder(Rational::Builder(2),Rational::Builder(3)))); @@ -147,23 +147,23 @@ QUIZ_CASE(poincare_parser_parse) { assert_parsed_expression_is("1+-2", Addition::Builder(Rational::Builder(1),Opposite::Builder(Rational::Builder(2)))); assert_parsed_expression_is("--1", Opposite::Builder((Expression)Opposite::Builder(Rational::Builder(1)))); assert_parsed_expression_is("(1+2)-3", Subtraction::Builder(Parenthesis::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2))),Rational::Builder(3))); - assert_parsed_expression_is("(2*-3)", Parenthesis::Builder(Multiplication::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))))); + assert_parsed_expression_is("(2×-3)", Parenthesis::Builder(Multiplication::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))))); assert_parsed_expression_is("1^(2)-3", Subtraction::Builder(Power::Builder(Rational::Builder(1),Parenthesis::Builder(Rational::Builder(2))),Rational::Builder(3))); assert_parsed_expression_is("1^2-3", Subtraction::Builder(Power::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); assert_parsed_expression_is("2^-3", Power::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3)))); assert_parsed_expression_is("2--2+-1", Addition::Builder(Subtraction::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(2))),Opposite::Builder(Rational::Builder(1)))); - assert_parsed_expression_is("2--2*-1", Subtraction::Builder(Rational::Builder(2),Opposite::Builder(Multiplication::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(1)))))); + assert_parsed_expression_is("2--2×-1", Subtraction::Builder(Rational::Builder(2),Opposite::Builder(Multiplication::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(1)))))); assert_parsed_expression_is("-1^2", Opposite::Builder(Power::Builder(Rational::Builder(1),Rational::Builder(2)))); assert_parsed_expression_is("2/-3/-4", Division::Builder(Division::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))),Opposite::Builder(Rational::Builder(4)))); - assert_parsed_expression_is("1*2-3*4", Subtraction::Builder(Multiplication::Builder(Rational::Builder(1),Rational::Builder(2)),Multiplication::Builder(Rational::Builder(3),Rational::Builder(4)))); - assert_parsed_expression_is("-1*2", Opposite::Builder(Multiplication::Builder(Rational::Builder(1), Rational::Builder(2)))); + assert_parsed_expression_is("1×2-3×4", Subtraction::Builder(Multiplication::Builder(Rational::Builder(1),Rational::Builder(2)),Multiplication::Builder(Rational::Builder(3),Rational::Builder(4)))); + assert_parsed_expression_is("-1×2", Opposite::Builder(Multiplication::Builder(Rational::Builder(1), Rational::Builder(2)))); assert_parsed_expression_is("1!", Factorial::Builder(Rational::Builder(1))); assert_parsed_expression_is("1+2!", Addition::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2)))); assert_parsed_expression_is("1!+2", Addition::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); assert_parsed_expression_is("1!+2!", Addition::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2)))); - assert_parsed_expression_is("1*2!", Multiplication::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2)))); - assert_parsed_expression_is("1!*2", Multiplication::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); - assert_parsed_expression_is("1!*2!", Multiplication::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2)))); + assert_parsed_expression_is("1×2!", Multiplication::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2)))); + assert_parsed_expression_is("1!×2", Multiplication::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); + assert_parsed_expression_is("1!×2!", Multiplication::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2)))); assert_parsed_expression_is("1-2!", Subtraction::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2)))); assert_parsed_expression_is("1!-2", Subtraction::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); assert_parsed_expression_is("1!-2!", Subtraction::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2)))); @@ -182,14 +182,14 @@ QUIZ_CASE(poincare_parser_parse) { assert_raises_parsing_error("1)"); assert_raises_parsing_error("1++2"); assert_raises_parsing_error("1//2"); - assert_raises_parsing_error("*1"); + assert_raises_parsing_error("×1"); assert_raises_parsing_error("1^^2"); assert_raises_parsing_error("^1"); assert_raises_parsing_error("t0000000"); assert_raises_parsing_error("[[t0000000["); - assert_raises_parsing_error("0>x=0"); - assert_raises_parsing_error("0=0>x"); - assert_raises_parsing_error("1E2E3"); + assert_raises_parsing_error("0→x=0"); + assert_raises_parsing_error("0=0→x"); + assert_raises_parsing_error("1ᴇ2ᴇ3"); } Matrix BuildMatrix(int rows, int columns, Expression entries[]) { @@ -257,9 +257,9 @@ QUIZ_CASE(poincare_parser_symbols_and_functions) { // Reserved symbols assert_parsed_expression_is("ans", Symbol::Builder("ans", 3)); - assert_parsed_expression_is("I", Constant::Builder(KDCodePointMathematicalBoldSmallI)); - assert_parsed_expression_is("P", Constant::Builder(KDCodePointGreekSmallLetterPi)); - assert_parsed_expression_is("X", Constant::Builder(KDCodePointScriptSmallE)); + assert_parsed_expression_is("𝐢", Constant::Builder(KDCodePointMathematicalBoldSmallI)); + assert_parsed_expression_is("π", Constant::Builder(KDCodePointGreekSmallLetterPi)); + assert_parsed_expression_is("ℯ", Constant::Builder(KDCodePointScriptSmallE)); assert_parsed_expression_is(Infinity::Name(), Infinity::Builder(false)); assert_parsed_expression_is(Undefined::Name(), Undefined::Builder()); @@ -318,43 +318,43 @@ QUIZ_CASE(poincare_parser_symbols_and_functions) { assert_parsed_expression_is("tanh(1)", HyperbolicTangent::Builder(Rational::Builder(1))); assert_parsed_expression_is("trace(1)", MatrixTrace::Builder(Rational::Builder(1))); assert_parsed_expression_is("transpose(1)", MatrixTranspose::Builder(Rational::Builder(1))); - assert_parsed_expression_is("\x91(1)", SquareRoot::Builder(Rational::Builder(1))); + assert_parsed_expression_is("√(1)", SquareRoot::Builder(Rational::Builder(1))); assert_raises_parsing_error("cos(1,2)"); assert_raises_parsing_error("log(1,2,3)"); } QUIZ_CASE(poincare_parser_parse_store) { - assert_parsed_expression_is("1>a", Store::Builder(Rational::Builder(1),Symbol::Builder("a",1))); - assert_parsed_expression_is("1>e", Store::Builder(Rational::Builder(1),Symbol::Builder("e",1))); - assert_parsed_expression_is("1>f(x)", Store::Builder(Rational::Builder(1),Function::Builder("f",1,Symbol::Builder("x",1)))); - assert_parsed_expression_is("x>f(x)", Store::Builder(Symbol::Builder("x",1),Function::Builder("f",1,Symbol::Builder("x",1)))); - assert_parsed_expression_is("n>f(x)", Store::Builder(Symbol::Builder("n",1),Function::Builder("f",1,Symbol::Builder("x",1)))); + assert_parsed_expression_is("1→a", Store::Builder(Rational::Builder(1),Symbol::Builder("a",1))); + assert_parsed_expression_is("1→e", Store::Builder(Rational::Builder(1),Symbol::Builder("e",1))); + assert_parsed_expression_is("1→f(x)", Store::Builder(Rational::Builder(1),Function::Builder("f",1,Symbol::Builder("x",1)))); + assert_parsed_expression_is("x→f(x)", Store::Builder(Symbol::Builder("x",1),Function::Builder("f",1,Symbol::Builder("x",1)))); + assert_parsed_expression_is("n→f(x)", Store::Builder(Symbol::Builder("n",1),Function::Builder("f",1,Symbol::Builder("x",1)))); Expression m0[] = {Symbol::Builder('x')}; - assert_parsed_expression_is("[[x]]>f(x)", Store::Builder(BuildMatrix(1,1,m0), Function::Builder("f", 1, Symbol::Builder('x')))); - assert_raises_parsing_error("a>b>c"); - assert_raises_parsing_error("1>2"); - assert_raises_parsing_error("1>"); - assert_raises_parsing_error(">2"); - assert_raises_parsing_error("(1>a)"); - assert_raises_parsing_error("1>u(n)"); - assert_raises_parsing_error("1>u(n+1)"); - assert_raises_parsing_error("1>v(n)"); - assert_raises_parsing_error("1>v(n+1)"); - assert_raises_parsing_error("1>u_{n}"); - assert_raises_parsing_error("1>u_{n+1}"); - assert_raises_parsing_error("1>v_{n}"); - assert_raises_parsing_error("1>v_{n+1}"); - assert_raises_parsing_error("1>inf"); - assert_raises_parsing_error("1>undef"); - assert_raises_parsing_error("1>P"); - assert_raises_parsing_error("1>I"); - assert_raises_parsing_error("1>X"); - assert_raises_parsing_error("1>\1"); // UnknownX - assert_raises_parsing_error("1>acos"); - assert_raises_parsing_error("1>f(2)"); - assert_raises_parsing_error("1>f(f)"); - assert_raises_parsing_error("1>ans"); - assert_raises_parsing_error("ans>ans"); + assert_parsed_expression_is("[[x]]→f(x)", Store::Builder(BuildMatrix(1,1,m0), Function::Builder("f", 1, Symbol::Builder('x')))); + assert_raises_parsing_error("a→b→c"); + assert_raises_parsing_error("1→2"); + assert_raises_parsing_error("1→"); + assert_raises_parsing_error("→2"); + assert_raises_parsing_error("(1→a)"); + assert_raises_parsing_error("1→u(n)"); + assert_raises_parsing_error("1→u(n+1)"); + assert_raises_parsing_error("1→v(n)"); + assert_raises_parsing_error("1→v(n+1)"); + assert_raises_parsing_error("1→u_{n}"); + assert_raises_parsing_error("1→u_{n+1}"); + assert_raises_parsing_error("1→v_{n}"); + assert_raises_parsing_error("1→v_{n+1}"); + assert_raises_parsing_error("1→inf"); + assert_raises_parsing_error("1→undef"); + assert_raises_parsing_error("1→π"); + assert_raises_parsing_error("1→𝐢"); + assert_raises_parsing_error("1→ℯ"); + assert_raises_parsing_error("1→\1"); // UnknownX + assert_raises_parsing_error("1→acos"); + assert_raises_parsing_error("1→f(2)"); + assert_raises_parsing_error("1→f(f)"); + assert_raises_parsing_error("1→ans"); + assert_raises_parsing_error("ans→ans"); } QUIZ_CASE(poincare_parser_implicit_multiplication) { @@ -364,10 +364,10 @@ QUIZ_CASE(poincare_parser_implicit_multiplication) { assert_parsed_expression_is("1ans", Multiplication::Builder(Rational::Builder(1),Symbol::Builder("ans", 3))); assert_parsed_expression_is("x1", Symbol::Builder("x1", 2)); assert_parsed_expression_is("1x+2", Addition::Builder(Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2))); - assert_parsed_expression_is("1P", Multiplication::Builder(Rational::Builder(1),Constant::Builder(KDCodePointGreekSmallLetterPi))); + assert_parsed_expression_is("1π", Multiplication::Builder(Rational::Builder(1),Constant::Builder(KDCodePointGreekSmallLetterPi))); assert_parsed_expression_is("1x-2", Subtraction::Builder(Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2))); assert_parsed_expression_is("-1x", Opposite::Builder(Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); - assert_parsed_expression_is("2*1x", Multiplication::Builder(Rational::Builder(2),Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); + assert_parsed_expression_is("2×1x", Multiplication::Builder(Rational::Builder(2),Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); assert_parsed_expression_is("2^1x", Multiplication::Builder(Power::Builder(Rational::Builder(2),Rational::Builder(1)),Symbol::Builder("x", 1))); assert_parsed_expression_is("1x^2", Multiplication::Builder(Rational::Builder(1),Power::Builder(Symbol::Builder("x", 1),Rational::Builder(2)))); assert_parsed_expression_is("2/1x", Division::Builder(Rational::Builder(2),Multiplication::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); @@ -377,7 +377,7 @@ QUIZ_CASE(poincare_parser_implicit_multiplication) { assert_parsed_expression_is("sin(1)2", Multiplication::Builder(Sine::Builder(Rational::Builder(1)),Rational::Builder(2))); assert_parsed_expression_is("1cos(2)", Multiplication::Builder(Rational::Builder(1),Cosine::Builder(Rational::Builder(2)))); assert_parsed_expression_is("1!2", Multiplication::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); - assert_parsed_expression_is("2X^(3)", Multiplication::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(KDCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3))))); + assert_parsed_expression_is("2ℯ^(3)", Multiplication::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(KDCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3))))); Expression m1[] = {Rational::Builder(1)}; Matrix M1 = BuildMatrix(1,1,m1); Expression m2[] = {Rational::Builder(2)}; Matrix M2 = BuildMatrix(1,1,m2); assert_parsed_expression_is("[[1]][[2]]", Multiplication::Builder(M1,M2)); @@ -388,29 +388,29 @@ QUIZ_CASE(poincare_parser_expression_evaluation) { assert_parsed_expression_evaluates_to("-0.1", "-0.1"); assert_parsed_expression_evaluates_to("-1.", "-1"); assert_parsed_expression_evaluates_to("-.1", "-0.1"); - assert_parsed_expression_evaluates_to("-0E2", "0"); - assert_parsed_expression_evaluates_to("-0.1E2", "-10"); - assert_parsed_expression_evaluates_to("-1.E2", "-100"); - assert_parsed_expression_evaluates_to("-.1E2", "-10"); - assert_parsed_expression_evaluates_to("-0E-2", "0"); - assert_parsed_expression_evaluates_to("-0.1E-2", "-0.001"); - assert_parsed_expression_evaluates_to("-1.E-2", "-0.01"); - assert_parsed_expression_evaluates_to("-.1E-2", "-0.001"); + assert_parsed_expression_evaluates_to("-0ᴇ2", "0"); + assert_parsed_expression_evaluates_to("-0.1ᴇ2", "-10"); + assert_parsed_expression_evaluates_to("-1.ᴇ2", "-100"); + assert_parsed_expression_evaluates_to("-.1ᴇ2", "-10"); + assert_parsed_expression_evaluates_to("-0ᴇ-2", "0"); + assert_parsed_expression_evaluates_to("-0.1ᴇ-2", "-0.001"); + assert_parsed_expression_evaluates_to("-1.ᴇ-2", "-0.01"); + assert_parsed_expression_evaluates_to("-.1ᴇ-2", "-0.001"); assert_parsed_expression_evaluates_to("-2-3", "-5"); - assert_parsed_expression_evaluates_to("1.2*X^(1)", "3.261938"); - assert_parsed_expression_evaluates_to("2X^(3)", "40.1711", System, Radian, Cartesian, 6); // WARNING: the 7th significant digit is wrong on blackbos simulator - assert_parsed_expression_evaluates_to("X^2*X^(1)", "20.0855", System, Radian, Cartesian, 6); // WARNING: the 7th significant digit is wrong on simulator - assert_parsed_expression_evaluates_to("X^2*X^(1)", "20.085536923188"); - assert_parsed_expression_evaluates_to("2*3^4+2", "164"); - assert_parsed_expression_evaluates_to("-2*3^4+2", "-160"); - assert_parsed_expression_evaluates_to("-sin(3)*2-3", "-3.2822400161197", System, Radian); + assert_parsed_expression_evaluates_to("1.2×ℯ^(1)", "3.261938"); + assert_parsed_expression_evaluates_to("2ℯ^(3)", "40.1711", System, Radian, Cartesian, 6); // WARNING: the 7th significant digit is wrong on blackbos simulator + assert_parsed_expression_evaluates_to("ℯ^2×ℯ^(1)", "20.0855", System, Radian, Cartesian, 6); // WARNING: the 7th significant digit is wrong on simulator + assert_parsed_expression_evaluates_to("ℯ^2×ℯ^(1)", "20.085536923188"); + assert_parsed_expression_evaluates_to("2×3^4+2", "164"); + assert_parsed_expression_evaluates_to("-2×3^4+2", "-160"); + assert_parsed_expression_evaluates_to("-sin(3)×2-3", "-3.2822400161197", System, Radian); assert_parsed_expression_evaluates_to("-.003", "-0.003"); - assert_parsed_expression_evaluates_to(".02E2", "2"); + assert_parsed_expression_evaluates_to(".02ᴇ2", "2"); assert_parsed_expression_evaluates_to("5-2/3", "4.333333"); assert_parsed_expression_evaluates_to("2/3-5", "-4.3333333333333"); assert_parsed_expression_evaluates_to("-2/3-5", "-5.666667"); assert_parsed_expression_evaluates_to("sin(3)2(4+2)", "1.6934400967184", System, Radian); - assert_parsed_expression_evaluates_to("4/2*(2+3)", "10"); - assert_parsed_expression_evaluates_to("4/2*(2+3)", "10"); + assert_parsed_expression_evaluates_to("4/2×(2+3)", "10"); + assert_parsed_expression_evaluates_to("4/2×(2+3)", "10"); } diff --git a/poincare/test/power.cpp b/poincare/test/power.cpp index 99f86e06c..bf0a91b56 100644 --- a/poincare/test/power.cpp +++ b/poincare/test/power.cpp @@ -8,41 +8,43 @@ using namespace Poincare; QUIZ_CASE(poincare_power_evaluate) { assert_parsed_expression_evaluates_to("2^3", "8"); - assert_parsed_expression_evaluates_to("(3+I)^4", "28+96*I"); - assert_parsed_expression_evaluates_to("4^(3+I)", "11.74125+62.91378*I"); - assert_parsed_expression_evaluates_to("(3+I)^(3+I)", "-11.898191759852+19.592921596609*I"); + assert_parsed_expression_evaluates_to("(3+𝐢)^4", "28+96×𝐢"); + assert_parsed_expression_evaluates_to("4^(3+𝐢)", "11.74125+62.91378×𝐢"); + assert_parsed_expression_evaluates_to("(3+𝐢)^(3+𝐢)", "-11.898191759852+19.592921596609×𝐢"); assert_parsed_expression_evaluates_to("0^0", Undefined::Name()); assert_parsed_expression_evaluates_to("0^2", "0"); assert_parsed_expression_evaluates_to("0^(-2)", Undefined::Name()); - assert_parsed_expression_evaluates_to("(-2)^4.2", "14.8690638497+10.8030072384*I", System, Radian, Cartesian, 12); + + assert_parsed_expression_evaluates_to("(-2)^4.2", "14.8690638497+10.8030072384×𝐢", System, Radian, Cartesian, 12); assert_parsed_expression_evaluates_to("(-0.1)^4", "0.0001", System, Radian, Cartesian, 12); + #if MATRICES_ARE_DEFINED assert_parsed_expression_evaluates_to("[[1,2][3,4]]^(-3)", "[[-14.75,6.75][10.125,-4.625]]", System, Degree, Cartesian, 6); assert_parsed_expression_evaluates_to("[[1,2][3,4]]^3", "[[37,54][81,118]]"); #endif assert_parsed_expression_evaluates_to("0^2", "0"); - assert_parsed_expression_evaluates_to("I^I", "2.0787957635076E-1"); + assert_parsed_expression_evaluates_to("𝐢^𝐢", "2.0787957635076ᴇ-1"); assert_parsed_expression_evaluates_to("1.0066666666667^60", "1.48985", System, Radian, Cartesian, 6); assert_parsed_expression_evaluates_to("1.0066666666667^60", "1.4898457083046"); - assert_parsed_expression_evaluates_to("X^(I*P)", "-1"); - assert_parsed_expression_evaluates_to("X^(I*P)", "-1"); - assert_parsed_expression_evaluates_to("X^(I*P+2)", "-7.38906", System, Radian, Cartesian, 6); - assert_parsed_expression_evaluates_to("X^(I*P+2)", "-7.3890560989307"); - assert_parsed_expression_evaluates_to("(-1)^(1/3)", "0.5+0.8660254*I"); - assert_parsed_expression_evaluates_to("(-1)^(1/3)", "0.5+8.6602540378444E-1*I"); - assert_parsed_expression_evaluates_to("X^(I*P/3)", "0.5+0.8660254*I"); - assert_parsed_expression_evaluates_to("X^(I*P/3)", "0.5+8.6602540378444E-1*I"); - assert_parsed_expression_evaluates_to("I^(2/3)", "0.5+0.8660254*I"); - assert_parsed_expression_evaluates_to("I^(2/3)", "0.5+8.6602540378444E-1*I"); + assert_parsed_expression_evaluates_to("ℯ^(𝐢×π)", "-1"); + assert_parsed_expression_evaluates_to("ℯ^(𝐢×π)", "-1"); + assert_parsed_expression_evaluates_to("ℯ^(𝐢×π+2)", "-7.38906", System, Radian, Cartesian, 6); + assert_parsed_expression_evaluates_to("ℯ^(𝐢×π+2)", "-7.3890560989307"); + assert_parsed_expression_evaluates_to("(-1)^(1/3)", "0.5+0.8660254×𝐢"); + assert_parsed_expression_evaluates_to("(-1)^(1/3)", "0.5+8.6602540378444ᴇ-1×𝐢"); + assert_parsed_expression_evaluates_to("ℯ^(𝐢×π/3)", "0.5+0.8660254×𝐢"); + assert_parsed_expression_evaluates_to("ℯ^(𝐢×π/3)", "0.5+8.6602540378444ᴇ-1×𝐢"); + assert_parsed_expression_evaluates_to("𝐢^(2/3)", "0.5+0.8660254×𝐢"); + assert_parsed_expression_evaluates_to("𝐢^(2/3)", "0.5+8.6602540378444ᴇ-1×𝐢"); } QUIZ_CASE(poincare_power_simplify) { assert_parsed_expression_simplify_to("3^4", "81"); assert_parsed_expression_simplify_to("3^(-4)", "1/81"); assert_parsed_expression_simplify_to("(-3)^3", "-27"); - assert_parsed_expression_simplify_to("1256^(1/3)*x", "2*root(157,3)*x"); - assert_parsed_expression_simplify_to("1256^(-1/3)", "1/(2*root(157,3))"); + assert_parsed_expression_simplify_to("1256^(1/3)×x", "2×root(157,3)×x"); + assert_parsed_expression_simplify_to("1256^(-1/3)", "1/(2×root(157,3))"); assert_parsed_expression_simplify_to("32^(-1/5)", "1/2"); assert_parsed_expression_simplify_to("(2+3-4)^(x)", "1"); assert_parsed_expression_simplify_to("1^x", "1"); @@ -51,38 +53,38 @@ QUIZ_CASE(poincare_power_simplify) { assert_parsed_expression_simplify_to("0^0", Undefined::Name()); assert_parsed_expression_simplify_to("0^(-3)", Undefined::Name()); assert_parsed_expression_simplify_to("4^0.5", "2"); - assert_parsed_expression_simplify_to("8^0.5", "2*R(2)"); - assert_parsed_expression_simplify_to("(12^4*3)^(0.5)", "144*R(3)"); - assert_parsed_expression_simplify_to("(2^A)^B", "2^(A*B)"); - assert_parsed_expression_simplify_to("(2*A)^B", "2^B*A^B"); - assert_parsed_expression_simplify_to("(12^4*x)^(0.5)", "144*R(x)"); - assert_parsed_expression_simplify_to("R(32)", "4*R(2)"); - assert_parsed_expression_simplify_to("R(-1)", "I"); - assert_parsed_expression_simplify_to("R(-1*R(-1))", "R(2)/2-R(2)/2*I"); - assert_parsed_expression_simplify_to("R(3^2)", "3"); - assert_parsed_expression_simplify_to("2^(2+P)", "4*2^P"); - assert_parsed_expression_simplify_to("R(5513219850886344455940081)", "2348024669991"); - assert_parsed_expression_simplify_to("R(154355776)", "12424"); - assert_parsed_expression_simplify_to("R(P)^2", "P"); - assert_parsed_expression_simplify_to("R(P^2)", "P"); - assert_parsed_expression_simplify_to("R((-P)^2)", "P"); - assert_parsed_expression_simplify_to("R(x*144)", "12*R(x)"); - assert_parsed_expression_simplify_to("R(x*144*P^2)", "12*P*R(x)"); - assert_parsed_expression_simplify_to("R(x*144*P)", "12*R(P)*R(x)"); - assert_parsed_expression_simplify_to("(-1)*(2+(-4*R(2)))", "4*R(2)-2"); - assert_parsed_expression_simplify_to("x^(1/2)", "R(x)"); - assert_parsed_expression_simplify_to("x^(-1/2)", "1/R(x)"); + assert_parsed_expression_simplify_to("8^0.5", "2×√(2)"); + assert_parsed_expression_simplify_to("(12^4×3)^(0.5)", "144×√(3)"); + assert_parsed_expression_simplify_to("(2^A)^B", "2^(A×B)"); + assert_parsed_expression_simplify_to("(2×A)^B", "2^B×A^B"); + assert_parsed_expression_simplify_to("(12^4×x)^(0.5)", "144×√(x)"); + assert_parsed_expression_simplify_to("√(32)", "4×√(2)"); + assert_parsed_expression_simplify_to("√(-1)", "𝐢"); + assert_parsed_expression_simplify_to("√(-1×√(-1))", "√(2)/2-√(2)/2×𝐢"); + assert_parsed_expression_simplify_to("√(3^2)", "3"); + assert_parsed_expression_simplify_to("2^(2+π)", "4×2^π"); + assert_parsed_expression_simplify_to("√(5513219850886344455940081)", "2348024669991"); + assert_parsed_expression_simplify_to("√(154355776)", "12424"); + assert_parsed_expression_simplify_to("√(π)^2", "π"); + assert_parsed_expression_simplify_to("√(π^2)", "π"); + assert_parsed_expression_simplify_to("√((-π)^2)", "π"); + assert_parsed_expression_simplify_to("√(x×144)", "12×√(x)"); + assert_parsed_expression_simplify_to("√(x×144×π^2)", "12×π×√(x)"); + assert_parsed_expression_simplify_to("√(x×144×π)", "12×√(π)×√(x)"); + assert_parsed_expression_simplify_to("(-1)×(2+(-4×√(2)))", "4×√(2)-2"); + assert_parsed_expression_simplify_to("x^(1/2)", "√(x)"); + assert_parsed_expression_simplify_to("x^(-1/2)", "1/√(x)"); assert_parsed_expression_simplify_to("x^(1/7)", "root(x,7)"); assert_parsed_expression_simplify_to("x^(-1/7)", "1/root(x,7)"); - assert_parsed_expression_simplify_to("1/(3R(2))", "R(2)/6"); - assert_parsed_expression_simplify_to("X^ln(3)", "3"); - assert_parsed_expression_simplify_to("X^ln(R(3))", "R(3)"); - assert_parsed_expression_simplify_to("P^log(R(3),P)", "R(3)"); - assert_parsed_expression_simplify_to("10^log(P)", "P"); - assert_parsed_expression_simplify_to("X^ln(65)", "65"); - assert_parsed_expression_simplify_to("X^ln(PX)", "P*X"); - assert_parsed_expression_simplify_to("X^log(PX)", "X^(log(X)+log(P))"); - assert_parsed_expression_simplify_to("R(X^2)", "X"); + assert_parsed_expression_simplify_to("1/(3√(2))", "√(2)/6"); + assert_parsed_expression_simplify_to("ℯ^ln(3)", "3"); + assert_parsed_expression_simplify_to("ℯ^ln(√(3))", "√(3)"); + assert_parsed_expression_simplify_to("π^log(√(3),π)", "√(3)"); + assert_parsed_expression_simplify_to("10^log(π)", "π"); + assert_parsed_expression_simplify_to("ℯ^ln(65)", "65"); + assert_parsed_expression_simplify_to("ℯ^ln(πℯ)", "π×ℯ"); + assert_parsed_expression_simplify_to("ℯ^log(πℯ)", "ℯ^(log(ℯ)+log(π))"); + assert_parsed_expression_simplify_to("√(ℯ^2)", "ℯ"); assert_parsed_expression_simplify_to("999^(10000/3)", "999^(10000/3)"); /* This does not reduce but should not as the integer is above * k_maxNumberOfPrimeFactors and thus it prime decomposition might overflow @@ -91,18 +93,18 @@ QUIZ_CASE(poincare_power_simplify) { /* This does not reduce but should not as the prime decomposition involves * factors above k_maxNumberOfPrimeFactors. */ assert_parsed_expression_simplify_to("1002101470343^(1/3)", "root(1002101470343,3)"); - assert_parsed_expression_simplify_to("P*P*P", "P^3"); - assert_parsed_expression_simplify_to("(x+P)^(3)", "x^3+3*P*x^2+3*P^2*x+P^3"); - assert_parsed_expression_simplify_to("(5+R(2))^(-8)", "(-1003320*R(2)+1446241)/78310985281"); - assert_parsed_expression_simplify_to("(5*P+R(2))^(-5)", "1/(3125*P^5+3125*R(2)*P^4+2500*P^3+500*R(2)*P^2+100*P+4*R(2))"); - assert_parsed_expression_simplify_to("(1+R(2)+R(3))^5", "120*R(6)+184*R(3)+224*R(2)+296"); - assert_parsed_expression_simplify_to("(P+R(2)+R(3)+x)^(-3)", "1/(x^3+3*P*x^2+3*R(3)*x^2+3*R(2)*x^2+3*P^2*x+6*R(3)*P*x+6*R(2)*P*x+6*R(6)*x+15*x+P^3+3*R(3)*P^2+3*R(2)*P^2+6*R(6)*P+15*P+9*R(3)+11*R(2))"); + assert_parsed_expression_simplify_to("π×π×π", "π^3"); + assert_parsed_expression_simplify_to("(x+π)^(3)", "x^3+3×π×x^2+3×π^2×x+π^3"); + assert_parsed_expression_simplify_to("(5+√(2))^(-8)", "(-1003320×√(2)+1446241)/78310985281"); + assert_parsed_expression_simplify_to("(5×π+√(2))^(-5)", "1/(3125×π^5+3125×√(2)×π^4+2500×π^3+500×√(2)×π^2+100×π+4×√(2))"); + assert_parsed_expression_simplify_to("(1+√(2)+√(3))^5", "120×√(6)+184×√(3)+224×√(2)+296"); + assert_parsed_expression_simplify_to("(π+√(2)+√(3)+x)^(-3)", "1/(x^3+3×π×x^2+3×√(3)×x^2+3×√(2)×x^2+3×π^2×x+6×√(3)×π×x+6×√(2)×π×x+6×√(6)×x+15×x+π^3+3×√(3)×π^2+3×√(2)×π^2+6×√(6)×π+15×π+9×√(3)+11×√(2))"); assert_parsed_expression_simplify_to("1.0066666666667^60", "(10066666666667/10000000000000)^60"); - assert_parsed_expression_simplify_to("2^(6+P+x)", "64*2^(x+P)"); - assert_parsed_expression_simplify_to("I^(2/3)", "1/2+R(3)/2*I"); - assert_parsed_expression_simplify_to("X^(I*P/3)", "1/2+R(3)/2*I"); - assert_parsed_expression_simplify_to("(-1)^(1/3)", "1/2+R(3)/2*I"); + assert_parsed_expression_simplify_to("2^(6+π+x)", "64×2^(x+π)"); + assert_parsed_expression_simplify_to("𝐢^(2/3)", "1/2+√(3)/2×𝐢"); + assert_parsed_expression_simplify_to("ℯ^(𝐢×π/3)", "1/2+√(3)/2×𝐢"); + assert_parsed_expression_simplify_to("(-1)^(1/3)", "1/2+√(3)/2×𝐢"); assert_parsed_expression_simplify_to("R(-x)", "R(-x)"); - assert_parsed_expression_simplify_to("R(x)^2", "x", User, Radian, Cartesian); - assert_parsed_expression_simplify_to("R(x)^2", "R(x)^2", User, Radian, Real); + assert_parsed_expression_simplify_to("√(x)^2", "x", User, Radian, Cartesian); + assert_parsed_expression_simplify_to("√(x)^2", "√(x)^2", User, Radian, Real); } diff --git a/poincare/test/properties.cpp b/poincare/test/properties.cpp index e36b93fb2..c122a1020 100644 --- a/poincare/test/properties.cpp +++ b/poincare/test/properties.cpp @@ -21,10 +21,10 @@ void assert_parsed_expression_sign(const char * expression, Poincare::Expression QUIZ_CASE(poincare_sign) { assert_parsed_expression_sign("abs(-cos(2)+I)", Positive); - assert_parsed_expression_sign("2.345E-23", Positive); - assert_parsed_expression_sign("-2.345E-23", Negative); - assert_parsed_expression_sign("2*(-3)*abs(-32)", Negative); - assert_parsed_expression_sign("2*(-3)*abs(-32)*cos(3)", Unknown); + assert_parsed_expression_sign("2.345ᴇ-23", Positive); + assert_parsed_expression_sign("-2.345ᴇ-23", Negative); + assert_parsed_expression_sign("2×(-3)×abs(-32)", Negative); + assert_parsed_expression_sign("2×(-3)×abs(-32)×cos(3)", Unknown); assert_parsed_expression_sign("x", Unknown); assert_parsed_expression_sign("2^(-abs(3))", Positive); assert_parsed_expression_sign("(-2)^4", Positive); @@ -32,35 +32,35 @@ QUIZ_CASE(poincare_sign) { assert_parsed_expression_sign("random()", Positive); assert_parsed_expression_sign("42/3", Positive); assert_parsed_expression_sign("-23/32", Negative); - assert_parsed_expression_sign("P", Positive); - assert_parsed_expression_sign("X", Positive); + assert_parsed_expression_sign("π", Positive); + assert_parsed_expression_sign("ℯ", Positive); assert_parsed_expression_sign("0", Positive); assert_parsed_expression_sign("cos(90)", Positive); - assert_parsed_expression_sign("R(-1)", Unknown); - assert_parsed_expression_sign("R(-1)", Unknown, Real); + assert_parsed_expression_sign("√(-1)", Unknown); + assert_parsed_expression_sign("√(-1)", Unknown, Real); } QUIZ_CASE(poincare_polynomial_degree) { assert_parsed_expression_polynomial_degree("x+1", 1); assert_parsed_expression_polynomial_degree("cos(2)+1", 0); assert_parsed_expression_polynomial_degree("confidence(0.2,10)+1", -1); - assert_parsed_expression_polynomial_degree("diff(3*x+x,x,2)", -1); - assert_parsed_expression_polynomial_degree("diff(3*x+x,x,x)", -1); - assert_parsed_expression_polynomial_degree("diff(3*x+x,x,x)", 0, "a"); - assert_parsed_expression_polynomial_degree("(3*x+2)/3", 1); - assert_parsed_expression_polynomial_degree("(3*x+2)/x", -1); - assert_parsed_expression_polynomial_degree("int(2*x,x, 0, 1)", -1); - assert_parsed_expression_polynomial_degree("int(2*x,x, 0, 1)", 0, "a"); + assert_parsed_expression_polynomial_degree("diff(3×x+x,x,2)", -1); + assert_parsed_expression_polynomial_degree("diff(3×x+x,x,x)", -1); + assert_parsed_expression_polynomial_degree("diff(3×x+x,x,x)", 0, "a"); + assert_parsed_expression_polynomial_degree("(3×x+2)/3", 1); + assert_parsed_expression_polynomial_degree("(3×x+2)/x", -1); + assert_parsed_expression_polynomial_degree("int(2×x,x, 0, 1)", -1); + assert_parsed_expression_polynomial_degree("int(2×x,x, 0, 1)", 0, "a"); assert_parsed_expression_polynomial_degree("[[1,2][3,4]]", -1); - assert_parsed_expression_polynomial_degree("(x^2+2)*(x+1)", 3); + assert_parsed_expression_polynomial_degree("(x^2+2)×(x+1)", 3); assert_parsed_expression_polynomial_degree("-(x+1)", 1); assert_parsed_expression_polynomial_degree("(x^2+2)^(3)", 6); assert_parsed_expression_polynomial_degree("prediction(0.2,10)+1", -1); assert_parsed_expression_polynomial_degree("2-x-x^3", 3); - assert_parsed_expression_polynomial_degree("P*x", 1); - assert_parsed_expression_polynomial_degree("R(-1)*x", -1, "x", Real); - // f: x->x^2+Px+1 - assert_simplify("1+P*x+x^2>f(x)"); + assert_parsed_expression_polynomial_degree("π×x", 1); + assert_parsed_expression_polynomial_degree("√(-1)×x", -1, "x", Real); + // f: x→x^2+πx+1 + assert_simplify("1+π×x+x^2→f(x)"); assert_parsed_expression_polynomial_degree("f(x)", 2); } @@ -87,7 +87,7 @@ QUIZ_CASE(poincare_characteristic_range) { assert_expression_has_characteristic_range(Addition::Builder(Cosine::Builder(Rational::Builder(3)),Rational::Builder(2)), 0.0f); assert_expression_has_characteristic_range(CommonLogarithm::Builder(Cosine::Builder(Multiplication::Builder(Rational::Builder(40),Symbol::Builder(Poincare::Symbol::SpecialSymbols::UnknownX)))), 9.0f); assert_expression_has_characteristic_range(Cosine::Builder((Expression)Cosine::Builder(Symbol::Builder(Poincare::Symbol::SpecialSymbols::UnknownX))), 360.0f); - assert_simplify("cos(x)>f(x)"); + assert_simplify("cos(x)→f(x)"); assert_expression_has_characteristic_range(Function::Builder("f",1,Symbol::Builder(Poincare::Symbol::SpecialSymbols::UnknownX)), 360.0f); } @@ -114,17 +114,17 @@ QUIZ_CASE(poincare_get_variables) { const char * variableBuffer1[] = {"x","y",""}; assert_parsed_expression_has_variables("x+y", variableBuffer1, 2); const char * variableBuffer2[] = {"x","y","z","t",""}; - assert_parsed_expression_has_variables("x+y+z+2*t", variableBuffer2, 4); + assert_parsed_expression_has_variables("x+y+z+2×t", variableBuffer2, 4); const char * variableBuffer3[] = {"a","x","y","k","A", ""}; - assert_parsed_expression_has_variables("a+x^2+2*y+k!*A", variableBuffer3, 5); + assert_parsed_expression_has_variables("a+x^2+2×y+k!×A", variableBuffer3, 5); const char * variableBuffer4[] = {"BABA","abab", ""}; assert_parsed_expression_has_variables("BABA+abab", variableBuffer4, 2); const char * variableBuffer5[] = {"BBBBBB", ""}; assert_parsed_expression_has_variables("BBBBBB", variableBuffer5, 1); const char * variableBuffer6[] = {""}; assert_parsed_expression_has_variables("a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+aa+bb+cc+dd+ee+ff+gg+hh+ii+jj+kk+ll+mm+nn+oo", variableBuffer6, -1); - // f: x->1+Px+x^2+toto - assert_simplify("1+P*x+x^2+toto>f(x)"); + // f: x→1+πx+x^2+toto + assert_simplify("1+π×x+x^2+toto→f(x)"); const char * variableBuffer7[] = {"tata","toto", ""}; assert_parsed_expression_has_variables("f(tata)", variableBuffer7, 2); } @@ -149,19 +149,19 @@ void assert_parsed_expression_has_polynomial_coefficient(const char * expression QUIZ_CASE(poincare_get_polynomial_coefficients) { const char * coefficient0[] = {"2", "1", "1", 0}; assert_parsed_expression_has_polynomial_coefficient("x^2+x+2", "x", coefficient0); - const char * coefficient1[] = {"12+(-6)*P", "12", "3", 0}; //3*x^2+12*x-6*π+12 - assert_parsed_expression_has_polynomial_coefficient("3*(x+2)^2-6*P", "x", coefficient1); + const char * coefficient1[] = {"12+(-6)×π", "12", "3", 0}; //3×x^2+12×x-6×π+12 + assert_parsed_expression_has_polynomial_coefficient("3×(x+2)^2-6×π", "x", coefficient1); // TODO: decomment when enable 3-degree polynomes - //const char * coefficient2[] = {"2+32*x", "2", "6", "2", 0}; //2*n^3+6*n^2+2*n+2+32*x - //assert_parsed_expression_has_polynomial_coefficient("2*(n+1)^3-4n+32*x", "n", coefficient2); - const char * coefficient3[] = {"1", "-P", "1", 0}; //x^2-Pi*x+1 - assert_parsed_expression_has_polynomial_coefficient("x^2-P*x+1", "x", coefficient3); - // f: x->x^2+Px+1 - const char * coefficient4[] = {"1", "P", "1", 0}; //x^2+Pi*x+1 - assert_simplify("1+P*x+x^2>f(x)"); + //const char * coefficient2[] = {"2+32×x", "2", "6", "2", 0}; //2×n^3+6×n^2+2×n+2+32×x + //assert_parsed_expression_has_polynomial_coefficient("2×(n+1)^3-4n+32×x", "n", coefficient2); + const char * coefficient3[] = {"1", "-π", "1", 0}; //x^2-π×x+1 + assert_parsed_expression_has_polynomial_coefficient("x^2-π×x+1", "x", coefficient3); + // f: x→x^2+Px+1 + const char * coefficient4[] = {"1", "π", "1", 0}; //x^2+π×x+1 + assert_simplify("1+π×x+x^2→f(x)"); assert_parsed_expression_has_polynomial_coefficient("f(x)", "x", coefficient4); - const char * coefficient5[] = {"0", "I", 0}; //R(-1)x - assert_parsed_expression_has_polynomial_coefficient("R(-1)x", "x", coefficient5); - const char * coefficient6[] = {0}; //R(-1)x - assert_parsed_expression_has_polynomial_coefficient("R(-1)x", "x", coefficient6, Real); + const char * coefficient5[] = {"0", "𝐢", 0}; //√(-1)x + assert_parsed_expression_has_polynomial_coefficient("√(-1)x", "x", coefficient5); + const char * coefficient6[] = {0}; //√(-1)x + assert_parsed_expression_has_polynomial_coefficient("√(-1)x", "x", coefficient6, Real); } diff --git a/poincare/test/rational.cpp b/poincare/test/rational.cpp index 66d42daaf..87baebe4f 100644 --- a/poincare/test/rational.cpp +++ b/poincare/test/rational.cpp @@ -111,8 +111,8 @@ QUIZ_CASE(poincare_rational_simplify) { assert_parsed_expression_simplify_to("0.1234", "617/5000"); assert_parsed_expression_simplify_to("0.1234000", "617/5000"); assert_parsed_expression_simplify_to("001234000", "1234000"); - assert_parsed_expression_simplify_to("001.234000E3", "1234"); - assert_parsed_expression_simplify_to("001234000E-4", "617/5"); + assert_parsed_expression_simplify_to("001.234000ᴇ3", "1234"); + assert_parsed_expression_simplify_to("001234000ᴇ-4", "617/5"); assert_parsed_expression_simplify_to("3/4+5/4-12+1/567", "-5669/567"); assert_parsed_expression_simplify_to("34/78+67^(-1)", "1178/2613"); assert_parsed_expression_simplify_to("12348/34564", "3087/8641"); @@ -123,14 +123,14 @@ QUIZ_CASE(poincare_rational_simplify) { assert_parsed_expression_simplify_to("999^-999", "1/999^999"); assert_parsed_expression_simplify_to("0^0", Undefined::Name()); assert_parsed_expression_simplify_to("x^0", "1"); - assert_parsed_expression_simplify_to("P^0", "1"); + assert_parsed_expression_simplify_to("π^0", "1"); assert_parsed_expression_simplify_to("A^0", "1"); assert_parsed_expression_simplify_to("(-3)^0", "1"); } QUIZ_CASE(poincare_rational_approximate) { assert_parsed_expression_evaluates_to("1/3", "0.3333333"); - assert_parsed_expression_evaluates_to("123456/1234567", "9.9999432999586E-2"); + assert_parsed_expression_evaluates_to("123456/1234567", "9.9999432999586ᴇ-2"); } diff --git a/poincare/test/simplify.cpp b/poincare/test/simplify.cpp index e6a5e6e2f..52f1f77f2 100644 --- a/poincare/test/simplify.cpp +++ b/poincare/test/simplify.cpp @@ -10,14 +10,14 @@ using namespace std; using namespace Poincare; QUIZ_CASE(poincare_reduction_target) { - assert_parsed_expression_simplify_to("1/P+1/x", "1/x+1/P", System); - assert_parsed_expression_simplify_to("1/P+1/x", "(x+P)/(P*x)", User); + assert_parsed_expression_simplify_to("1/π+1/x", "1/x+1/π", System); + assert_parsed_expression_simplify_to("1/π+1/x", "(x+π)/(π×x)", User); - assert_parsed_expression_simplify_to("1/(1+I)", "1/(I+1)", System); - assert_parsed_expression_simplify_to("1/(1+I)", "1/2-1/2*I", User); + assert_parsed_expression_simplify_to("1/(1+𝐢)", "1/(𝐢+1)", System); + assert_parsed_expression_simplify_to("1/(1+𝐢)", "1/2-1/2×𝐢", User); - assert_parsed_expression_simplify_to("sin(x)/(cos(x)*cos(x))", "sin(x)/cos(x)^2", System); - assert_parsed_expression_simplify_to("sin(x)/(cos(x)*cos(x))", "tan(x)/cos(x)", User); + assert_parsed_expression_simplify_to("sin(x)/(cos(x)×cos(x))", "sin(x)/cos(x)^2", System); + assert_parsed_expression_simplify_to("sin(x)/(cos(x)×cos(x))", "tan(x)/cos(x)", User); assert_parsed_expression_simplify_to("x^0", "x^0", System); assert_parsed_expression_simplify_to("x^0", "1", User); @@ -29,14 +29,14 @@ QUIZ_CASE(poincare_reduction_target) { assert_parsed_expression_simplify_to("x^2", "x^2", System); assert_parsed_expression_simplify_to("x^2", "x^2", User); - assert_parsed_expression_simplify_to("1/(R(2)+R(3))", "1/(R(3)+R(2))", System); - assert_parsed_expression_simplify_to("1/(R(2)+R(3))", "R(3)-R(2)", User); + assert_parsed_expression_simplify_to("1/(√(2)+√(3))", "1/(√(3)+√(2))", System); + assert_parsed_expression_simplify_to("1/(√(2)+√(3))", "√(3)-√(2)", User); assert_parsed_expression_simplify_to("sign(abs(x))", "sign(abs(x))", System); assert_parsed_expression_simplify_to("sign(abs(x))", "1", User); assert_parsed_expression_simplify_to("atan(1/x)", "atan(1/x)", System); - assert_parsed_expression_simplify_to("atan(1/x)", "(P*sign(x)-2*atan(x))/2", User); + assert_parsed_expression_simplify_to("atan(1/x)", "(π×sign(x)-2×atan(x))/2", User); assert_parsed_expression_simplify_to("(1+x)/(1+x)", "(x+1)^0", System); assert_parsed_expression_simplify_to("(1+x)/(1+x)", "1", User); @@ -44,47 +44,47 @@ QUIZ_CASE(poincare_reduction_target) { QUIZ_CASE(poincare_simplify_mix) { // Root at denominator - assert_parsed_expression_simplify_to("1/(R(2)+R(3))", "R(3)-R(2)"); - assert_parsed_expression_simplify_to("1/(5+R(3))", "(-R(3)+5)/22"); - assert_parsed_expression_simplify_to("1/(R(2)+4)", "(-R(2)+4)/14"); - assert_parsed_expression_simplify_to("1/(2R(2)-4)", "(-R(2)-2)/4"); - assert_parsed_expression_simplify_to("1/(-2R(2)+4)", "(R(2)+2)/4"); + assert_parsed_expression_simplify_to("1/(√(2)+√(3))", "√(3)-√(2)"); + assert_parsed_expression_simplify_to("1/(5+√(3))", "(-√(3)+5)/22"); + assert_parsed_expression_simplify_to("1/(√(2)+4)", "(-√(2)+4)/14"); + assert_parsed_expression_simplify_to("1/(2√(2)-4)", "(-√(2)-2)/4"); + assert_parsed_expression_simplify_to("1/(-2√(2)+4)", "(√(2)+2)/4"); assert_parsed_expression_simplify_to("45^2", "2025"); - assert_parsed_expression_simplify_to("1/(R(2)ln(3))", "R(2)/(2*ln(3))"); - assert_parsed_expression_simplify_to("R(3/2)", "R(6)/2"); + assert_parsed_expression_simplify_to("1/(√(2)ln(3))", "√(2)/(2×ln(3))"); + assert_parsed_expression_simplify_to("√(3/2)", "√(6)/2"); // Common operation mix - assert_parsed_expression_simplify_to("(R(2)*P + R(2)*X)/R(2)", "X+P"); - assert_parsed_expression_simplify_to("P+(3R(2)-2R(3))/25", "(25*P-2*R(3)+3*R(2))/25"); + assert_parsed_expression_simplify_to("(√(2)×π + √(2)×ℯ)/√(2)", "ℯ+π"); + assert_parsed_expression_simplify_to("π+(3√(2)-2√(3))/25", "(25×π-2×√(3)+3×√(2))/25"); assert_parsed_expression_simplify_to("ln(2+3)", "ln(5)"); - assert_parsed_expression_simplify_to("3*A*B*C+4*cos(2)-2*A*B*C+A*B*C+ln(3)+4*A*B-5*A*B*C+cos(3)*ln(5)+cos(2)-45*cos(2)", "cos(3)*ln(5)+ln(3)-40*cos(2)+4*A*B-3*A*B*C"); - assert_parsed_expression_simplify_to("2*A+3*cos(2)+3+4*ln(5)+5*A+2*ln(5)+1+0", "6*ln(5)+3*cos(2)+7*A+4"); - assert_parsed_expression_simplify_to("2.3*A+3*cos(2)+3+4*ln(5)+5*A+2*ln(5)+1.2+0.235", "(1200*ln(5)+600*cos(2)+1460*A+887)/200"); - assert_parsed_expression_simplify_to("2*A*B*C+2.3*A*B+3*A^2+5.2*A*B*C+4*A^2", "(70*A^2+23*A*B+72*A*B*C)/10"); - assert_parsed_expression_simplify_to("(A*B)^2*A+4*A^3", "4*A^3+A^3*B^2"); - assert_parsed_expression_simplify_to("(A*3)^2*A+4*A^3", "13*A^3"); - assert_parsed_expression_simplify_to("A^2^2*A+4*A^3", "A^5+4*A^3"); - assert_parsed_expression_simplify_to("0.5+4*A*B-2.3+2*A*B-2*B*A^C-cos(4)+2*A^C*B+A*B*C*D", "(-5*cos(4)+30*A*B+5*A*B*C*D-9)/5"); - assert_parsed_expression_simplify_to("(1+R(2))/5", "(R(2)+1)/5"); - assert_parsed_expression_simplify_to("(2+R(6))^2", "4*R(6)+10"); - assert_parsed_expression_simplify_to("tan(3)ln(2)+P", "tan(3)*ln(2)+P"); + assert_parsed_expression_simplify_to("3×A×B×C+4×cos(2)-2×A×B×C+A×B×C+ln(3)+4×A×B-5×A×B×C+cos(3)×ln(5)+cos(2)-45×cos(2)", "cos(3)×ln(5)+ln(3)-40×cos(2)+4×A×B-3×A×B×C"); + assert_parsed_expression_simplify_to("2×A+3×cos(2)+3+4×ln(5)+5×A+2×ln(5)+1+0", "6×ln(5)+3×cos(2)+7×A+4"); + assert_parsed_expression_simplify_to("2.3×A+3×cos(2)+3+4×ln(5)+5×A+2×ln(5)+1.2+0.235", "(1200×ln(5)+600×cos(2)+1460×A+887)/200"); + assert_parsed_expression_simplify_to("2×A×B×C+2.3×A×B+3×A^2+5.2×A×B×C+4×A^2", "(70×A^2+23×A×B+72×A×B×C)/10"); + assert_parsed_expression_simplify_to("(A×B)^2×A+4×A^3", "4×A^3+A^3×B^2"); + assert_parsed_expression_simplify_to("(A×3)^2×A+4×A^3", "13×A^3"); + assert_parsed_expression_simplify_to("A^2^2×A+4×A^3", "A^5+4×A^3"); + assert_parsed_expression_simplify_to("0.5+4×A×B-2.3+2×A×B-2×B×A^C-cos(4)+2×A^C×B+A×B×C×D", "(-5×cos(4)+30×A×B+5×A×B×C×D-9)/5"); + assert_parsed_expression_simplify_to("(1+√(2))/5", "(√(2)+1)/5"); + assert_parsed_expression_simplify_to("(2+√(6))^2", "4×√(6)+10"); + assert_parsed_expression_simplify_to("tan(3)ln(2)+π", "tan(3)×ln(2)+π"); // Complex - assert_parsed_expression_simplify_to("I", "I"); - assert_parsed_expression_simplify_to("R(-33)", "R(33)*I"); - assert_parsed_expression_simplify_to("I^(3/5)", "(R(2)*R(-R(5)+5))/4+(R(5)+1)/4*I"); - assert_parsed_expression_simplify_to("IIII", "1"); - assert_parsed_expression_simplify_to("R(-I)", "R(2)/2-R(2)/2*I"); - assert_parsed_expression_simplify_to("A*cos(9)IIln(2)", "-A*cos(9)*ln(2)"); - assert_parsed_expression_simplify_to("(R(2)+R(2)*I)/2(R(2)+R(2)*I)/2(R(2)+R(2)*I)/2", "R(2)/32-R(2)/32*I"); - assert_parsed_expression_simplify_to("root(5^((-I)3^9),I)", "1/X^atan(tan(19683*ln(5)))"); - assert_parsed_expression_simplify_to("I^I", "1/X^(P/2)"); - assert_parsed_expression_simplify_to("I/(1+I*R(x))", "I/(R(x)*I+1)"); - assert_parsed_expression_simplify_to("x+I/(1+I*R(x))", "(x^(3/2)*I+I+x)/(R(x)*I+1)"); + assert_parsed_expression_simplify_to("𝐢", "𝐢"); + assert_parsed_expression_simplify_to("√(-33)", "√(33)×𝐢"); + assert_parsed_expression_simplify_to("𝐢^(3/5)", "(√(2)×√(-√(5)+5))/4+(√(5)+1)/4×𝐢"); + assert_parsed_expression_simplify_to("𝐢𝐢𝐢𝐢", "1"); + assert_parsed_expression_simplify_to("√(-𝐢)", "√(2)/2-√(2)/2×𝐢"); + assert_parsed_expression_simplify_to("A×cos(9)𝐢𝐢ln(2)", "-A×cos(9)×ln(2)"); + assert_parsed_expression_simplify_to("(√(2)+√(2)×𝐢)/2(√(2)+√(2)×𝐢)/2(√(2)+√(2)×𝐢)/2", "√(2)/32-√(2)/32×𝐢"); + assert_parsed_expression_simplify_to("root(5^((-𝐢)3^9),𝐢)", "1/ℯ^atan(tan(19683×ln(5)))"); + assert_parsed_expression_simplify_to("𝐢^𝐢", "1/ℯ^(π/2)"); + assert_parsed_expression_simplify_to("𝐢/(1+𝐢×√(x))", "𝐢/(√(x)×𝐢+1)"); + assert_parsed_expression_simplify_to("x+𝐢/(1+𝐢×√(x))", "(x^(3/2)×𝐢+𝐢+x)/(√(x)×𝐢+1)"); //assert_parsed_expression_simplify_to("log(cos(9)^ln(6), cos(9))", "ln(2)+ln(3)"); // TODO: for this to work, we must know the sign of cos(9) - //assert_parsed_expression_simplify_to("log(cos(9)^ln(6), 9)", "ln(6)*log(cos(9), 9)"); // TODO: for this to work, we must know the sign of cos(9) - assert_parsed_expression_simplify_to("(((R(6)-R(2))/4)/((R(6)+R(2))/4))+1", "-R(3)+3"); - //assert_parsed_expression_simplify_to("1/R(I) * (R(2)-I*R(2))", "-2I"); // TODO: get rid of complex at denominator? + //assert_parsed_expression_simplify_to("log(cos(9)^ln(6), 9)", "ln(6)×log(cos(9), 9)"); // TODO: for this to work, we must know the sign of cos(9) + assert_parsed_expression_simplify_to("(((√(6)-√(2))/4)/((√(6)+√(2))/4))+1", "-√(3)+3"); + //assert_parsed_expression_simplify_to("1/√(𝐢) × (√(2)-𝐢×√(2))", "-2𝐢"); // TODO: get rid of complex at denominator? } diff --git a/poincare/test/store.cpp b/poincare/test/store.cpp index deb1dc30d..17a447621 100644 --- a/poincare/test/store.cpp +++ b/poincare/test/store.cpp @@ -6,8 +6,8 @@ using namespace Poincare; QUIZ_CASE(poincare_store_evaluate) { - assert_parsed_expression_evaluates_to("1+42>A", "43"); - assert_parsed_expression_evaluates_to("0.123+I>B", "0.123+I"); + assert_parsed_expression_evaluates_to("1+42→A", "43"); + assert_parsed_expression_evaluates_to("0.123+𝐢→B", "0.123+𝐢"); // Clean the storage for other tests Ion::Storage::sharedStorage()->recordNamed("A.exp").destroy(); @@ -15,17 +15,17 @@ QUIZ_CASE(poincare_store_evaluate) { } QUIZ_CASE(poincare_store_simplify) { - assert_parsed_expression_simplify_to("1+2>x", "3"); - assert_parsed_expression_simplify_to("0.1+0.2>x", "3/10"); - assert_parsed_expression_simplify_to("a+a>x", "2*a"); + assert_parsed_expression_simplify_to("1+2→x", "3"); + assert_parsed_expression_simplify_to("0.1+0.2→x", "3/10"); + assert_parsed_expression_simplify_to("a+a→x", "2×a"); // Clean the storage for other tests Ion::Storage::sharedStorage()->recordNamed("x.exp").destroy(); } QUIZ_CASE(poincare_store_matrix) { - assert_parsed_expression_evaluates_to("[[7]]>a", "[[7]]"); - assert_parsed_expression_simplify_to("1+1>a", "2"); + assert_parsed_expression_evaluates_to("[[7]]→a", "[[7]]"); + assert_parsed_expression_simplify_to("1+1→a", "2"); // Clean the storage for other tests Ion::Storage::sharedStorage()->recordNamed("a.exp").destroy(); @@ -33,19 +33,19 @@ QUIZ_CASE(poincare_store_matrix) { QUIZ_CASE(poincare_store_that_should_fail) { // Create a helper function - assert_parsed_expression_simplify_to("1>g(x)", "1"); + assert_parsed_expression_simplify_to("1→g(x)", "1"); // Store only works on variables or functions - assert_expression_not_parsable("2>f(2)"); - assert_expression_not_parsable("3>f(g(4))"); + assert_expression_not_parsable("2→f(2)"); + assert_expression_not_parsable("3→f(g(4))"); // Clean the storage for other tests Ion::Storage::sharedStorage()->recordNamed("g.func").destroy(); } QUIZ_CASE(poincare_store_overwrite) { - assert_parsed_expression_simplify_to("2>g", "2"); - assert_parsed_expression_simplify_to("-1>g(x)", "-1"); + assert_parsed_expression_simplify_to("2→g", "2"); + assert_parsed_expression_simplify_to("-1→g(x)", "-1"); assert_parsed_expression_evaluates_to("g(4)", "-1"); // Clean the storage for other tests @@ -53,9 +53,9 @@ QUIZ_CASE(poincare_store_overwrite) { } QUIZ_CASE(poincare_store_do_not_overwrite) { - assert_parsed_expression_simplify_to("-1>g(x)", "-1"); - assert_parsed_expression_simplify_to("1+g(x)>f(x)", "0"); - assert_parsed_expression_simplify_to("2>g", Undefined::Name()); + assert_parsed_expression_simplify_to("-1→g(x)", "-1"); + assert_parsed_expression_simplify_to("1+g(x)→f(x)", "0"); + assert_parsed_expression_simplify_to("2→g", Undefined::Name()); assert_parsed_expression_evaluates_to("g(4)", "-1"); assert_parsed_expression_evaluates_to("f(4)", "0"); diff --git a/poincare/test/subtraction.cpp b/poincare/test/subtraction.cpp index 905e54b7c..80b218aa1 100644 --- a/poincare/test/subtraction.cpp +++ b/poincare/test/subtraction.cpp @@ -7,14 +7,14 @@ using namespace Poincare; QUIZ_CASE(poincare_subtraction_evaluate) { assert_parsed_expression_evaluates_to("1-2", "-1"); - assert_parsed_expression_evaluates_to("3+I-(4+I)", "-1"); + assert_parsed_expression_evaluates_to("3+𝐢-(4+𝐢)", "-1"); #if MATRICES_ARE_DEFINED assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]-3", "[[-2,-1][0,1][2,3]]"); - assert_parsed_expression_evaluates_to("[[1,2+I][3,4][5,6]]-(4+I)", "[[-3-I,-2][-1-I,-I][1-I,2-I]]"); + assert_parsed_expression_evaluates_to("[[1,2+𝐢][3,4][5,6]]-(4+𝐢)", "[[-3-𝐢,-2][-1-𝐢,-𝐢][1-𝐢,2-𝐢]]"); assert_parsed_expression_evaluates_to("3-[[1,2][3,4][5,6]]", "[[2,1][0,-1][-2,-3]]"); - assert_parsed_expression_evaluates_to("3+I-[[1,2+I][3,4][5,6]]", "[[2+I,1][I,-1+I][-2+I,-3+I]]"); + assert_parsed_expression_evaluates_to("3+𝐢-[[1,2+𝐢][3,4][5,6]]", "[[2+𝐢,1][𝐢,-1+𝐢][-2+𝐢,-3+𝐢]]"); assert_parsed_expression_evaluates_to("[[1,2][3,4][5,6]]-[[6,5][4,3][2,1]]", "[[-5,-3][-1,1][3,5]]"); - assert_parsed_expression_evaluates_to("[[1,2+I][3,4][5,6]]-[[1,2+I][3,4][5,6]]", "[[0,0][0,0][0,0]]"); + assert_parsed_expression_evaluates_to("[[1,2+𝐢][3,4][5,6]]-[[1,2+𝐢][3,4][5,6]]", "[[0,0][0,0][0,0]]"); #endif } diff --git a/poincare/test/symbol.cpp b/poincare/test/symbol.cpp index 2484f36fe..f2532e52f 100644 --- a/poincare/test/symbol.cpp +++ b/poincare/test/symbol.cpp @@ -8,17 +8,17 @@ using namespace Poincare; QUIZ_CASE(poincare_parse_symbol) { - assert_parsed_expression_type("P", ExpressionNode::Type::Constant); - assert_parsed_expression_type("X", ExpressionNode::Type::Constant); - assert_parsed_expression_type("I", ExpressionNode::Type::Constant); - assert_parsed_expression_type("1.2E3", ExpressionNode::Type::Decimal); + assert_parsed_expression_type("π", ExpressionNode::Type::Constant); + assert_parsed_expression_type("ℯ", ExpressionNode::Type::Constant); + assert_parsed_expression_type("𝐢", ExpressionNode::Type::Constant); + assert_parsed_expression_type("1.2ᴇ3", ExpressionNode::Type::Decimal); assert_parsed_expression_type("ans", ExpressionNode::Type::Symbol); } QUIZ_CASE(poincare_symbol_approximate) { - assert_parsed_expression_evaluates_to("P", "3.1415926535898"); - assert_parsed_expression_evaluates_to("X", "2.718282"); - assert_parsed_expression_evaluates_to("1.2E3", "1200"); + assert_parsed_expression_evaluates_to("π", "3.1415926535898"); + assert_parsed_expression_evaluates_to("ℯ", "2.718282"); + assert_parsed_expression_evaluates_to("1.2ᴇ3", "1200"); } diff --git a/poincare/test/trigo.cpp b/poincare/test/trigo.cpp index bef58efdc..50fed6eea 100644 --- a/poincare/test/trigo.cpp +++ b/poincare/test/trigo.cpp @@ -26,162 +26,162 @@ QUIZ_CASE(poincare_trigo_evaluate) { * Ri -> R (even) */ // On R - assert_parsed_expression_evaluates_to("cos(2)", "-4.1614683654714E-1", System, Radian); + assert_parsed_expression_evaluates_to("cos(2)", "-4.1614683654714ᴇ-1", System, Radian); assert_parsed_expression_evaluates_to("cos(2)", "0.9993908270191", System, Degree); // Oscillator - assert_parsed_expression_evaluates_to("cos(P/2)", "0", System, Radian); - assert_parsed_expression_evaluates_to("cos(3*P/2)", "0", System, Radian); - assert_parsed_expression_evaluates_to("cos(3*P)", "-1", System, Radian); + assert_parsed_expression_evaluates_to("cos(π/2)", "0", System, Radian); + assert_parsed_expression_evaluates_to("cos(3×π/2)", "0", System, Radian); + assert_parsed_expression_evaluates_to("cos(3×π)", "-1", System, Radian); assert_parsed_expression_evaluates_to("cos(-540)", "-1", System, Degree); - // On R*i - assert_parsed_expression_evaluates_to("cos(-2*I)", "3.7621956910836", System, Radian); - assert_parsed_expression_evaluates_to("cos(-2*I)", "1.0006092967033", System, Degree); + // On R×i + assert_parsed_expression_evaluates_to("cos(-2×𝐢)", "3.7621956910836", System, Radian); + assert_parsed_expression_evaluates_to("cos(-2×𝐢)", "1.0006092967033", System, Degree); // Symmetry: even - assert_parsed_expression_evaluates_to("cos(2*I)", "3.7621956910836", System, Radian); - assert_parsed_expression_evaluates_to("cos(2*I)", "1.0006092967033", System, Degree); + assert_parsed_expression_evaluates_to("cos(2×𝐢)", "3.7621956910836", System, Radian); + assert_parsed_expression_evaluates_to("cos(2×𝐢)", "1.0006092967033", System, Degree); // On C - assert_parsed_expression_evaluates_to("cos(I-4)", "-1.008625-0.8893952*I", System, Radian); - assert_parsed_expression_evaluates_to("cos(I-4)", "0.997716+0.00121754*I", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("cos(𝐢-4)", "-1.008625-0.8893952×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("cos(𝐢-4)", "0.997716+0.00121754×𝐢", System, Degree, Cartesian, 6); /* sin: R -> R (oscillator) * Ri -> Ri (odd) */ // On R - assert_parsed_expression_evaluates_to("sin(2)", "9.0929742682568E-1", System, Radian); - assert_parsed_expression_evaluates_to("sin(2)", "3.4899496702501E-2", System, Degree); + assert_parsed_expression_evaluates_to("sin(2)", "9.0929742682568ᴇ-1", System, Radian); + assert_parsed_expression_evaluates_to("sin(2)", "3.4899496702501ᴇ-2", System, Degree); // Oscillator - assert_parsed_expression_evaluates_to("sin(P/2)", "1", System, Radian); - assert_parsed_expression_evaluates_to("sin(3*P/2)", "-1", System, Radian); - assert_parsed_expression_evaluates_to("sin(3*P)", "0", System, Radian); + assert_parsed_expression_evaluates_to("sin(π/2)", "1", System, Radian); + assert_parsed_expression_evaluates_to("sin(3×π/2)", "-1", System, Radian); + assert_parsed_expression_evaluates_to("sin(3×π)", "0", System, Radian); assert_parsed_expression_evaluates_to("sin(-540)", "0", System, Degree); - // On R*i - assert_parsed_expression_evaluates_to("sin(3*I)", "10.01787492741*I", System, Radian); - assert_parsed_expression_evaluates_to("sin(3*I)", "0.05238381*I", System, Degree); + // On R×i + assert_parsed_expression_evaluates_to("sin(3×𝐢)", "10.01787492741×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("sin(3×𝐢)", "0.05238381×𝐢", System, Degree); // Symmetry: odd - assert_parsed_expression_evaluates_to("sin(-3*I)", "-10.01787492741*I", System, Radian); - assert_parsed_expression_evaluates_to("sin(-3*I)", "-0.05238381*I", System, Degree); + assert_parsed_expression_evaluates_to("sin(-3×𝐢)", "-10.01787492741×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("sin(-3×𝐢)", "-0.05238381×𝐢", System, Degree); // On: C - assert_parsed_expression_evaluates_to("sin(I-4)", "1.16781-0.768163*I", System, Radian, Cartesian, 6); - assert_parsed_expression_evaluates_to("sin(I-4)", "-0.0697671+0.0174117*I", System, Degree, Cartesian, 6); - assert_parsed_expression_evaluates_to("sin(1.234567890123456E-15)", "1.23457E-15", System, Radian, Cartesian, 6); + assert_parsed_expression_evaluates_to("sin(𝐢-4)", "1.16781-0.768163×𝐢", System, Radian, Cartesian, 6); + assert_parsed_expression_evaluates_to("sin(𝐢-4)", "-0.0697671+0.0174117×𝐢", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("sin(1.234567890123456ᴇ-15)", "1.23457ᴇ-15", System, Radian, Cartesian, 6); /* tan: R -> R (tangent-style) * Ri -> Ri (odd) */ // On R assert_parsed_expression_evaluates_to("tan(2)", "-2.1850398632615", System, Radian); - assert_parsed_expression_evaluates_to("tan(2)", "3.4920769491748E-2", System, Degree); + assert_parsed_expression_evaluates_to("tan(2)", "3.4920769491748ᴇ-2", System, Degree); // Tangent-style - assert_parsed_expression_evaluates_to("tan(P/2)", Undefined::Name(), System, Radian); - assert_parsed_expression_evaluates_to("tan(3*P/2)", Undefined::Name(), System, Radian); - assert_parsed_expression_evaluates_to("tan(3*P)", "0", System, Radian); + assert_parsed_expression_evaluates_to("tan(π/2)", Undefined::Name(), System, Radian); + assert_parsed_expression_evaluates_to("tan(3×π/2)", Undefined::Name(), System, Radian); + assert_parsed_expression_evaluates_to("tan(3×π)", "0", System, Radian); assert_parsed_expression_evaluates_to("tan(-540)", "0", System, Degree); - // On R*i - assert_parsed_expression_evaluates_to("tan(-2*I)", "-9.6402758007582E-1*I", System, Radian); - assert_parsed_expression_evaluates_to("tan(-2*I)", "-0.03489241*I", System, Degree); + // On R×i + assert_parsed_expression_evaluates_to("tan(-2×𝐢)", "-9.6402758007582ᴇ-1×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("tan(-2×𝐢)", "-0.03489241×𝐢", System, Degree); // Symmetry: odd - assert_parsed_expression_evaluates_to("tan(2*I)", "9.6402758007582E-1*I", System, Radian); - assert_parsed_expression_evaluates_to("tan(2*I)", "0.03489241*I", System, Degree); + assert_parsed_expression_evaluates_to("tan(2×𝐢)", "9.6402758007582ᴇ-1×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("tan(2×𝐢)", "0.03489241×𝐢", System, Degree); // On C - assert_parsed_expression_evaluates_to("tan(I-4)", "-0.273553+1.00281*I", System, Radian, Cartesian, 6); - assert_parsed_expression_evaluates_to("tan(I-4)", "-0.0699054+0.0175368*I", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("tan(𝐢-4)", "-0.273553+1.00281×𝐢", System, Radian, Cartesian, 6); + assert_parsed_expression_evaluates_to("tan(𝐢-4)", "-0.0699054+0.0175368×𝐢", System, Degree, Cartesian, 6); - /* acos: [-1,1] -> R - * ]-inf,-1[ -> Pi+R*i (odd imaginary) - * ]1, inf[ -> R*i (odd imaginary) - * R*i -> Pi/2+R*i (odd imaginary) + /* acos: [-1,1] -> R + * ]-inf,-1[ -> π+R×i (odd imaginary) + * ]1, inf[ -> R×i (odd imaginary) + * R×i -> π/2+R×i (odd imaginary) */ // On [-1, 1] assert_parsed_expression_evaluates_to("acos(0.5)", "1.0471975511966", System, Radian); assert_parsed_expression_evaluates_to("acos(0.03)", "1.5407918249714", System, Radian); assert_parsed_expression_evaluates_to("acos(0.5)", "60", System, Degree); // On [1, inf[ - assert_parsed_expression_evaluates_to("acos(2)", "1.3169578969248*I", System, Radian); - assert_parsed_expression_evaluates_to("acos(2)", "75.456129290217*I", System, Degree); + assert_parsed_expression_evaluates_to("acos(2)", "1.3169578969248×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("acos(2)", "75.456129290217×𝐢", System, Degree); // Symmetry: odd on imaginary - assert_parsed_expression_evaluates_to("acos(-2)", "3.1415926535898-1.3169578969248*I", System, Radian); - assert_parsed_expression_evaluates_to("acos(-2)", "180-75.456129290217*I", System, Degree); + assert_parsed_expression_evaluates_to("acos(-2)", "3.1415926535898-1.3169578969248×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("acos(-2)", "180-75.456129290217×𝐢", System, Degree); // On ]-inf, -1[ - assert_parsed_expression_evaluates_to("acos(-32)", "3.1415926535898-4.1586388532792*I", System, Radian); - assert_parsed_expression_evaluates_to("acos(-32)", "180-238.2725*I", System, Degree); - // On R*i - assert_parsed_expression_evaluates_to("acos(3*I)", "1.5708-1.8184*I", System, Radian, Cartesian, 5); - assert_parsed_expression_evaluates_to("acos(3*I)", "90-104.19*I", System, Degree, Cartesian, 5); + assert_parsed_expression_evaluates_to("acos(-32)", "3.1415926535898-4.1586388532792×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("acos(-32)", "180-238.2725×𝐢", System, Degree); + // On R×i + assert_parsed_expression_evaluates_to("acos(3×𝐢)", "1.5708-1.8184×𝐢", System, Radian, Cartesian, 5); + assert_parsed_expression_evaluates_to("acos(3×𝐢)", "90-104.19×𝐢", System, Degree, Cartesian, 5); // Symmetry: odd on imaginary - assert_parsed_expression_evaluates_to("acos(-3*I)", "1.5708+1.8184*I", System, Radian, Cartesian, 5); - assert_parsed_expression_evaluates_to("acos(-3*I)", "90+104.19*I", System, Degree, Cartesian, 5); + assert_parsed_expression_evaluates_to("acos(-3×𝐢)", "1.5708+1.8184×𝐢", System, Radian, Cartesian, 5); + assert_parsed_expression_evaluates_to("acos(-3×𝐢)", "90+104.19×𝐢", System, Degree, Cartesian, 5); // On C - assert_parsed_expression_evaluates_to("acos(I-4)", "2.8894-2.0966*I", System, Radian, Cartesian, 5); - assert_parsed_expression_evaluates_to("acos(I-4)", "165.551-120.126*I", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("acos(𝐢-4)", "2.8894-2.0966×𝐢", System, Radian, Cartesian, 5); + assert_parsed_expression_evaluates_to("acos(𝐢-4)", "165.551-120.126×𝐢", System, Degree, Cartesian, 6); // Key values assert_parsed_expression_evaluates_to("acos(0)", "90", System, Degree); assert_parsed_expression_evaluates_to("acos(-1)", "180", System, Degree); assert_parsed_expression_evaluates_to("acos(1)", "0", System, Degree); - /* asin: [-1,1] -> R - * ]-inf,-1[ -> -Pi/2+R*i (odd) - * ]1, inf[ -> Pi/2+R*i (odd) - * R*i -> R*i (odd) + /* asin: [-1,1] -> R + * ]-inf,-1[ -> -π/2+R×i (odd) + * ]1, inf[ -> π/2+R×i (odd) + * R×i -> R×i (odd) */ // On [-1, 1] assert_parsed_expression_evaluates_to("asin(0.5)", "0.5235987755983", System, Radian); - assert_parsed_expression_evaluates_to("asin(0.03)", "3.0004501823477E-2", System, Radian); + assert_parsed_expression_evaluates_to("asin(0.03)", "3.0004501823477ᴇ-2", System, Radian); assert_parsed_expression_evaluates_to("asin(0.5)", "30", System, Degree); // On [1, inf[ - assert_parsed_expression_evaluates_to("asin(2)", "1.5707963267949-1.3169578969248*I", System, Radian); - assert_parsed_expression_evaluates_to("asin(2)", "90-75.456129290217*I", System, Degree); + assert_parsed_expression_evaluates_to("asin(2)", "1.5707963267949-1.3169578969248×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("asin(2)", "90-75.456129290217×𝐢", System, Degree); // Symmetry: odd - assert_parsed_expression_evaluates_to("asin(-2)", "-1.5707963267949+1.3169578969248*I", System, Radian); - assert_parsed_expression_evaluates_to("asin(-2)", "-90+75.456129290217*I", System, Degree); + assert_parsed_expression_evaluates_to("asin(-2)", "-1.5707963267949+1.3169578969248×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("asin(-2)", "-90+75.456129290217×𝐢", System, Degree); // On ]-inf, -1[ - assert_parsed_expression_evaluates_to("asin(-32)", "-1.571+4.159*I", System, Radian, Cartesian, 4); - assert_parsed_expression_evaluates_to("asin(-32)", "-90+238*I", System, Degree, Cartesian, 3); - // On R*i - assert_parsed_expression_evaluates_to("asin(3*I)", "1.8184464592321*I", System, Radian); + assert_parsed_expression_evaluates_to("asin(-32)", "-1.571+4.159×𝐢", System, Radian, Cartesian, 4); + assert_parsed_expression_evaluates_to("asin(-32)", "-90+238×𝐢", System, Degree, Cartesian, 3); + // On R×i + assert_parsed_expression_evaluates_to("asin(3×𝐢)", "1.8184464592321×𝐢", System, Radian); // Symmetry: odd - assert_parsed_expression_evaluates_to("asin(-3*I)", "-1.8184464592321*I", System, Radian); + assert_parsed_expression_evaluates_to("asin(-3×𝐢)", "-1.8184464592321×𝐢", System, Radian); // On C - assert_parsed_expression_evaluates_to("asin(I-4)", "-1.3186+2.0966*I", System, Radian, Cartesian, 5); - assert_parsed_expression_evaluates_to("asin(I-4)", "-75.551+120.13*I", System, Degree, Cartesian, 5); + assert_parsed_expression_evaluates_to("asin(𝐢-4)", "-1.3186+2.0966×𝐢", System, Radian, Cartesian, 5); + assert_parsed_expression_evaluates_to("asin(𝐢-4)", "-75.551+120.13×𝐢", System, Degree, Cartesian, 5); // Key values assert_parsed_expression_evaluates_to("asin(0)", "0", System, Degree); assert_parsed_expression_evaluates_to("asin(-1)", "-90", System, Degree); assert_parsed_expression_evaluates_to("asin(1)", "90", System, Degree); /* atan: R -> R (odd) - * [-i,i] -> R*i (odd) - * ]-inf*i,-i[ -> -Pi/2+R*i (odd) - * ]i, inf*i[ -> Pi/2+R*i (odd) + * [-𝐢,𝐢] -> R×𝐢 (odd) + * ]-inf×𝐢,-𝐢[ -> -π/2+R×𝐢 (odd) + * ]𝐢, inf×𝐢[ -> π/2+R×𝐢 (odd) */ // On R assert_parsed_expression_evaluates_to("atan(2)", "1.1071487177941", System, Radian); - assert_parsed_expression_evaluates_to("atan(0.01)", "9.9996666866652E-3", System, Radian); + assert_parsed_expression_evaluates_to("atan(0.01)", "9.9996666866652ᴇ-3", System, Radian); assert_parsed_expression_evaluates_to("atan(2)", "63.434948822922", System, Degree); assert_parsed_expression_evaluates_to("atan(0.5)", "0.4636476", System, Radian); // Symmetry: odd assert_parsed_expression_evaluates_to("atan(-2)", "-1.1071487177941", System, Radian); - // On [-i, i] - assert_parsed_expression_evaluates_to("atan(0.2*I)", "0.202733*I", System, Radian, Cartesian, 6); + // On [-𝐢, 𝐢] + assert_parsed_expression_evaluates_to("atan(0.2×𝐢)", "0.202733×𝐢", System, Radian, Cartesian, 6); // Symmetry: odd - assert_parsed_expression_evaluates_to("atan(-0.2*I)", "-0.202733*I", System, Radian, Cartesian, 6); - // On [i, inf*i[ - assert_parsed_expression_evaluates_to("atan(26*I)", "1.5707963267949+3.8480520568064E-2*I", System, Radian); - assert_parsed_expression_evaluates_to("atan(26*I)", "90+2.2047714220164*I", System, Degree); + assert_parsed_expression_evaluates_to("atan(-0.2×𝐢)", "-0.202733×𝐢", System, Radian, Cartesian, 6); + // On [𝐢, inf×𝐢[ + assert_parsed_expression_evaluates_to("atan(26×𝐢)", "1.5707963267949+3.8480520568064ᴇ-2×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atan(26×𝐢)", "90+2.2047714220164×𝐢", System, Degree); // Symmetry: odd - assert_parsed_expression_evaluates_to("atan(-26*I)", "-1.5707963267949-3.8480520568064E-2*I", System, Radian); - // On ]-inf*i, -i[ - assert_parsed_expression_evaluates_to("atan(-3.4*I)", "-1.570796-0.3030679*I", System, Radian); - assert_parsed_expression_evaluates_to("atan(-3.4*I)", "-90-17.3645*I", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("atan(-26×𝐢)", "-1.5707963267949-3.8480520568064ᴇ-2×𝐢", System, Radian); + // On ]-inf×𝐢, -𝐢[ + assert_parsed_expression_evaluates_to("atan(-3.4×𝐢)", "-1.570796-0.3030679×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atan(-3.4×𝐢)", "-90-17.3645×𝐢", System, Degree, Cartesian, 6); // On C - assert_parsed_expression_evaluates_to("atan(I-4)", "-1.338973+0.05578589*I", System, Radian); - assert_parsed_expression_evaluates_to("atan(I-4)", "-76.7175+3.1963*I", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("atan(𝐢-4)", "-1.338973+0.05578589×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atan(𝐢-4)", "-76.7175+3.1963×𝐢", System, Degree, Cartesian, 6); // Key values assert_parsed_expression_evaluates_to("atan(0)", "0", System, Degree); - assert_parsed_expression_evaluates_to("atan(-I)", "-inf*I", System, Radian); - assert_parsed_expression_evaluates_to("atan(I)", "inf*I", System, Radian); + assert_parsed_expression_evaluates_to("atan(-𝐢)", "-inf×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atan(𝐢)", "inf×𝐢", System, Radian); /* cosh: R -> R (even) - * R*i -> R (oscillator) + * R×𝐢 -> R (oscillator) */ // On R assert_parsed_expression_evaluates_to("cosh(2)", "3.7621956910836", System, Radian); @@ -189,90 +189,90 @@ QUIZ_CASE(poincare_trigo_evaluate) { // Symmetry: even assert_parsed_expression_evaluates_to("cosh(-2)", "3.7621956910836", System, Radian); assert_parsed_expression_evaluates_to("cosh(-2)", "3.7621956910836", System, Degree); - // On R*i - assert_parsed_expression_evaluates_to("cosh(43*I)", "5.5511330152063E-1", System, Radian); + // On R×𝐢 + assert_parsed_expression_evaluates_to("cosh(43×𝐢)", "5.5511330152063ᴇ-1", System, Radian); // Oscillator - assert_parsed_expression_evaluates_to("cosh(P*I/2)", "0", System, Radian); - assert_parsed_expression_evaluates_to("cosh(5*P*I/2)", "0", System, Radian); - assert_parsed_expression_evaluates_to("cosh(8*P*I/2)", "1", System, Radian); - assert_parsed_expression_evaluates_to("cosh(9*P*I/2)", "0", System, Radian); + assert_parsed_expression_evaluates_to("cosh(π×𝐢/2)", "0", System, Radian); + assert_parsed_expression_evaluates_to("cosh(5×π×𝐢/2)", "0", System, Radian); + assert_parsed_expression_evaluates_to("cosh(8×π×𝐢/2)", "1", System, Radian); + assert_parsed_expression_evaluates_to("cosh(9×π×𝐢/2)", "0", System, Radian); // On C - assert_parsed_expression_evaluates_to("cosh(I-4)", "14.7547-22.9637*I", System, Radian, Cartesian, 6); - assert_parsed_expression_evaluates_to("cosh(I-4)", "14.7547-22.9637*I", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("cosh(𝐢-4)", "14.7547-22.9637×𝐢", System, Radian, Cartesian, 6); + assert_parsed_expression_evaluates_to("cosh(𝐢-4)", "14.7547-22.9637×𝐢", System, Degree, Cartesian, 6); /* sinh: R -> R (odd) - * R*i -> R*i (oscillator) + * R×𝐢 -> R×𝐢 (oscillator) */ // On R assert_parsed_expression_evaluates_to("sinh(2)", "3.626860407847", System, Radian); assert_parsed_expression_evaluates_to("sinh(2)", "3.626860407847", System, Degree); // Symmetry: odd assert_parsed_expression_evaluates_to("sinh(-2)", "-3.626860407847", System, Radian); - // On R*i - assert_parsed_expression_evaluates_to("sinh(43*I)", "-0.8317747426286*I", System, Radian); + // On R×𝐢 + assert_parsed_expression_evaluates_to("sinh(43×𝐢)", "-0.8317747426286×𝐢", System, Radian); // Oscillator - assert_parsed_expression_evaluates_to("sinh(P*I/2)", "I", System, Radian); - assert_parsed_expression_evaluates_to("sinh(5*P*I/2)", "I", System, Radian); - assert_parsed_expression_evaluates_to("sinh(7*P*I/2)", "-I", System, Radian); - assert_parsed_expression_evaluates_to("sinh(8*P*I/2)", "0", System, Radian); - assert_parsed_expression_evaluates_to("sinh(9*P*I/2)", "I", System, Radian); + assert_parsed_expression_evaluates_to("sinh(π×𝐢/2)", "𝐢", System, Radian); + assert_parsed_expression_evaluates_to("sinh(5×π×𝐢/2)", "𝐢", System, Radian); + assert_parsed_expression_evaluates_to("sinh(7×π×𝐢/2)", "-𝐢", System, Radian); + assert_parsed_expression_evaluates_to("sinh(8×π×𝐢/2)", "0", System, Radian); + assert_parsed_expression_evaluates_to("sinh(9×π×𝐢/2)", "𝐢", System, Radian); // On C - assert_parsed_expression_evaluates_to("sinh(I-4)", "-14.7448+22.9791*I", System, Radian, Cartesian, 6); - assert_parsed_expression_evaluates_to("sinh(I-4)", "-14.7448+22.9791*I", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("sinh(𝐢-4)", "-14.7448+22.9791×𝐢", System, Radian, Cartesian, 6); + assert_parsed_expression_evaluates_to("sinh(𝐢-4)", "-14.7448+22.9791×𝐢", System, Degree, Cartesian, 6); /* tanh: R -> R (odd) - * R*i -> R*i (tangent-style) + * R×𝐢 -> R×𝐢 (tangent-style) */ // On R - assert_parsed_expression_evaluates_to("tanh(2)", "9.6402758007582E-1", System, Radian); + assert_parsed_expression_evaluates_to("tanh(2)", "9.6402758007582ᴇ-1", System, Radian); // Symmetry: odd - assert_parsed_expression_evaluates_to("tanh(-2)", "-9.6402758007582E-1", System, Degree); - // On R*i - assert_parsed_expression_evaluates_to("tanh(43*I)", "-1.4983873388552*I", System, Radian); + assert_parsed_expression_evaluates_to("tanh(-2)", "-9.6402758007582ᴇ-1", System, Degree); + // On R×i + assert_parsed_expression_evaluates_to("tanh(43×𝐢)", "-1.4983873388552×𝐢", System, Radian); // Tangent-style // FIXME: this depends on the libm implementation and does not work on travis/appveyor servers - /*assert_parsed_expression_evaluates_to("tanh(P*I/2)", Undefined::Name(), System, Radian); - assert_parsed_expression_evaluates_to("tanh(5*P*I/2)", Undefined::Name(), System, Radian); - assert_parsed_expression_evaluates_to("tanh(7*P*I/2)", Undefined::Name(), System, Radian); - assert_parsed_expression_evaluates_to("tanh(8*P*I/2)", "0", System, Radian); - assert_parsed_expression_evaluates_to("tanh(9*P*I/2)", Undefined::Name(), System, Radian);*/ + /*assert_parsed_expression_evaluates_to("tanh(π×𝐢/2)", Undefined::Name(), System, Radian); + assert_parsed_expression_evaluates_to("tanh(5×π×𝐢/2)", Undefined::Name(), System, Radian); + assert_parsed_expression_evaluates_to("tanh(7×π×𝐢/2)", Undefined::Name(), System, Radian); + assert_parsed_expression_evaluates_to("tanh(8×π×𝐢/2)", "0", System, Radian); + assert_parsed_expression_evaluates_to("tanh(9×π×𝐢/2)", Undefined::Name(), System, Radian);*/ // On C - assert_parsed_expression_evaluates_to("tanh(I-4)", "-1.00028+0.000610241*I", System, Radian, Cartesian, 6); - assert_parsed_expression_evaluates_to("tanh(I-4)", "-1.00028+0.000610241*I", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("tanh(𝐢-4)", "-1.00028+0.000610241×𝐢", System, Radian, Cartesian, 6); + assert_parsed_expression_evaluates_to("tanh(𝐢-4)", "-1.00028+0.000610241×𝐢", System, Degree, Cartesian, 6); - /* acosh: [-1,1] -> R*i - * ]-inf,-1[ -> Pi*i+R (even on real) + /* acosh: [-1,1] -> R×𝐢 + * ]-inf,-1[ -> π×𝐢+R (even on real) * ]1, inf[ -> R (even on real) - * ]-inf*i, 0[ -> -Pi/2*i+R (even on real) - * ]0, inf*i[ -> Pi/2*i+R (even on real) + * ]-inf×𝐢, 0[ -> -π/2×𝐢+R (even on real) + * ]0, inf*𝐢[ -> π/2×𝐢+R (even on real) */ // On [-1,1] assert_parsed_expression_evaluates_to("acosh(2)", "1.3169578969248", System, Radian); assert_parsed_expression_evaluates_to("acosh(2)", "1.3169578969248", System, Degree); // On ]-inf, -1[ - assert_parsed_expression_evaluates_to("acosh(-4)", "2.0634370688956+3.1415926535898*I", System, Radian); - assert_parsed_expression_evaluates_to("acosh(-4)", "2.06344+3.14159*I", System, Radian, Cartesian, 6); + assert_parsed_expression_evaluates_to("acosh(-4)", "2.0634370688956+3.1415926535898×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("acosh(-4)", "2.06344+3.14159×𝐢", System, Radian, Cartesian, 6); // On ]1,inf[: Symmetry: even on real assert_parsed_expression_evaluates_to("acosh(4)", "2.0634370688956", System, Radian); assert_parsed_expression_evaluates_to("acosh(4)", "2.063437", System, Radian); - // On ]-inf*i, 0[ - assert_parsed_expression_evaluates_to("acosh(-42*I)", "4.4309584920805-1.5707963267949*I", System, Radian); - assert_parsed_expression_evaluates_to("acosh(-42*I)", "4.431-1.571*I", System, Radian, Cartesian, 4); - // On ]0, i*inf[: Symmetry: even on real - assert_parsed_expression_evaluates_to("acosh(42*I)", "4.4309584920805+1.5707963267949*I", System, Radian); - assert_parsed_expression_evaluates_to("acosh(42*I)", "4.431+1.571*I", System, Radian, Cartesian, 4); + // On ]-inf×𝐢, 0[ + assert_parsed_expression_evaluates_to("acosh(-42×𝐢)", "4.4309584920805-1.5707963267949×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("acosh(-42×𝐢)", "4.431-1.571×𝐢", System, Radian, Cartesian, 4); + // On ]0, 𝐢×inf[: Symmetry: even on real + assert_parsed_expression_evaluates_to("acosh(42×𝐢)", "4.4309584920805+1.5707963267949×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("acosh(42×𝐢)", "4.431+1.571×𝐢", System, Radian, Cartesian, 4); // On C - assert_parsed_expression_evaluates_to("acosh(I-4)", "2.0966+2.8894*I", System, Radian, Cartesian, 5); - assert_parsed_expression_evaluates_to("acosh(I-4)", "2.0966+2.8894*I", System, Degree, Cartesian, 5); + assert_parsed_expression_evaluates_to("acosh(𝐢-4)", "2.0966+2.8894×𝐢", System, Radian, Cartesian, 5); + assert_parsed_expression_evaluates_to("acosh(𝐢-4)", "2.0966+2.8894×𝐢", System, Degree, Cartesian, 5); // Key values - //assert_parsed_expression_evaluates_to("acosh(-1)", "3.1415926535898*I", System, Radian); + //assert_parsed_expression_evaluates_to("acosh(-1)", "3.1415926535898×𝐢", System, Radian); assert_parsed_expression_evaluates_to("acosh(1)", "0", System, Radian); - assert_parsed_expression_evaluates_to("acosh(0)", "1.570796*I", System, Radian); + assert_parsed_expression_evaluates_to("acosh(0)", "1.570796×𝐢", System, Radian); /* asinh: R -> R (odd) - * [-i,i] -> R*i (odd) - * ]-inf*i,-i[ -> -Pi/2*i+R (odd) - * ]i, inf*I[ -> Pi/2*I+R (odd) + * [-𝐢,𝐢] -> R*𝐢 (odd) + * ]-inf×𝐢,-𝐢[ -> -π/2×𝐢+R (odd) + * ]𝐢, inf×𝐢[ -> π/2×𝐢+R (odd) */ // On R assert_parsed_expression_evaluates_to("asinh(2)", "1.4436354751788", System, Radian); @@ -280,26 +280,26 @@ QUIZ_CASE(poincare_trigo_evaluate) { // Symmetry: odd assert_parsed_expression_evaluates_to("asinh(-2)", "-1.4436354751788", System, Radian); assert_parsed_expression_evaluates_to("asinh(-2)", "-1.4436354751788", System, Degree); - // On [-i,i] - assert_parsed_expression_evaluates_to("asinh(0.2*I)", "2.0135792079033E-1*I", System, Radian); - assert_parsed_expression_evaluates_to("asinh(0.2*I)", "0.2013579*I", System, Degree); + // On [-𝐢,𝐢] + assert_parsed_expression_evaluates_to("asinh(0.2×𝐢)", "2.0135792079033ᴇ-1×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("asinh(0.2×𝐢)", "0.2013579×𝐢", System, Degree); // Symmetry: odd - assert_parsed_expression_evaluates_to("asinh(-0.2*I)", "-2.0135792079033E-1*I", System, Radian); - assert_parsed_expression_evaluates_to("asinh(-0.2*I)", "-0.2013579*I", System, Degree); - // On ]-inf*i, -i[ - assert_parsed_expression_evaluates_to("asinh(-22*I)", "-3.7836727043295-1.5707963267949*I", System, Radian); - assert_parsed_expression_evaluates_to("asinh(-22*I)", "-3.784-1.571*I", System, Degree, Cartesian, 4); - // On ]i, inf*i[, Symmetry: odd - assert_parsed_expression_evaluates_to("asinh(22*I)", "3.7836727043295+1.5707963267949*I", System, Radian); - assert_parsed_expression_evaluates_to("asinh(22*I)", "3.784+1.571*I", System, Degree, Cartesian, 4); + assert_parsed_expression_evaluates_to("asinh(-0.2×𝐢)", "-2.0135792079033ᴇ-1×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("asinh(-0.2×𝐢)", "-0.2013579×𝐢", System, Degree); + // On ]-inf×𝐢, -𝐢[ + assert_parsed_expression_evaluates_to("asinh(-22×𝐢)", "-3.7836727043295-1.5707963267949×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("asinh(-22×𝐢)", "-3.784-1.571×𝐢", System, Degree, Cartesian, 4); + // On ]𝐢, inf×𝐢[, Symmetry: odd + assert_parsed_expression_evaluates_to("asinh(22×𝐢)", "3.7836727043295+1.5707963267949×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("asinh(22×𝐢)", "3.784+1.571×𝐢", System, Degree, Cartesian, 4); // On C - assert_parsed_expression_evaluates_to("asinh(I-4)", "-2.123+0.2383*I", System, Radian, Cartesian, 4); - assert_parsed_expression_evaluates_to("asinh(I-4)", "-2.123+0.2383*I", System, Degree, Cartesian, 4); + assert_parsed_expression_evaluates_to("asinh(𝐢-4)", "-2.123+0.2383×𝐢", System, Radian, Cartesian, 4); + assert_parsed_expression_evaluates_to("asinh(𝐢-4)", "-2.123+0.2383×𝐢", System, Degree, Cartesian, 4); /* atanh: [-1,1] -> R (odd) - * ]-inf,-1[ -> Pi/2*i+R (odd) - * ]1, inf[ -> -Pi/2*i+R (odd) - * R*i -> R*i (odd) + * ]-inf,-1[ -> π/2*𝐢+R (odd) + * ]1, inf[ -> -π/2×𝐢+R (odd) + * R×𝐢 -> R×𝐢 (odd) */ // On [-1,1] assert_parsed_expression_evaluates_to("atanh(0.4)", "0.4236489301936", System, Radian); @@ -308,66 +308,66 @@ QUIZ_CASE(poincare_trigo_evaluate) { assert_parsed_expression_evaluates_to("atanh(-0.4)", "-0.4236489301936", System, Radian); assert_parsed_expression_evaluates_to("atanh(-0.4)", "-0.4236489301936", System, Degree); // On ]1, inf[ - assert_parsed_expression_evaluates_to("atanh(4)", "0.255412811883-1.5707963267949*I", System, Radian); - assert_parsed_expression_evaluates_to("atanh(4)", "0.2554128-1.570796*I", System, Degree); + assert_parsed_expression_evaluates_to("atanh(4)", "0.255412811883-1.5707963267949×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atanh(4)", "0.2554128-1.570796×𝐢", System, Degree); // On ]-inf,-1[, Symmetry: odd - assert_parsed_expression_evaluates_to("atanh(-4)", "-0.255412811883+1.5707963267949*I", System, Radian); - assert_parsed_expression_evaluates_to("atanh(-4)", "-0.2554128+1.570796*I", System, Degree); - // On R*i - assert_parsed_expression_evaluates_to("atanh(4*I)", "1.325817663668*I", System, Radian); - assert_parsed_expression_evaluates_to("atanh(4*I)", "1.325818*I", System, Radian); + assert_parsed_expression_evaluates_to("atanh(-4)", "-0.255412811883+1.5707963267949×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atanh(-4)", "-0.2554128+1.570796×𝐢", System, Degree); + // On R×𝐢 + assert_parsed_expression_evaluates_to("atanh(4×𝐢)", "1.325817663668×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atanh(4×𝐢)", "1.325818×𝐢", System, Radian); // Symmetry: odd - assert_parsed_expression_evaluates_to("atanh(-4*I)", "-1.325817663668*I", System, Radian); - assert_parsed_expression_evaluates_to("atanh(-4*I)", "-1.325818*I", System, Radian); + assert_parsed_expression_evaluates_to("atanh(-4×𝐢)", "-1.325817663668×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atanh(-4×𝐢)", "-1.325818×𝐢", System, Radian); // On C - assert_parsed_expression_evaluates_to("atanh(I-4)", "-0.238878+1.50862*I", System, Radian, Cartesian, 6); - assert_parsed_expression_evaluates_to("atanh(I-4)", "-0.238878+1.50862*I", System, Degree, Cartesian, 6); + assert_parsed_expression_evaluates_to("atanh(𝐢-4)", "-0.238878+1.50862×𝐢", System, Radian, Cartesian, 6); + assert_parsed_expression_evaluates_to("atanh(𝐢-4)", "-0.238878+1.50862×𝐢", System, Degree, Cartesian, 6); // WARNING: evaluate on branch cut can be multivalued - assert_parsed_expression_evaluates_to("acos(2)", "1.3169578969248*I", System, Radian); - assert_parsed_expression_evaluates_to("acos(2)", "75.456129290217*I", System, Degree); - assert_parsed_expression_evaluates_to("asin(2)", "1.5707963267949-1.3169578969248*I", System, Radian); - assert_parsed_expression_evaluates_to("asin(2)", "90-75.456129290217*I", System, Degree); - assert_parsed_expression_evaluates_to("atanh(2)", "5.4930614433405E-1-1.5707963267949*I", System, Radian); - assert_parsed_expression_evaluates_to("atan(2I)", "1.5707963267949+5.4930614433405E-1*I", System, Radian); - assert_parsed_expression_evaluates_to("atan(2I)", "90+31.472923730945*I", System, Degree); - assert_parsed_expression_evaluates_to("asinh(2I)", "1.3169578969248+1.5707963267949*I", System, Radian); - assert_parsed_expression_evaluates_to("acosh(-2)", "1.3169578969248+3.1415926535898*I", System, Radian); + assert_parsed_expression_evaluates_to("acos(2)", "1.3169578969248×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("acos(2)", "75.456129290217×𝐢", System, Degree); + assert_parsed_expression_evaluates_to("asin(2)", "1.5707963267949-1.3169578969248×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("asin(2)", "90-75.456129290217×𝐢", System, Degree); + assert_parsed_expression_evaluates_to("atanh(2)", "5.4930614433405ᴇ-1-1.5707963267949×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atan(2𝐢)", "1.5707963267949+5.4930614433405ᴇ-1×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("atan(2𝐢)", "90+31.472923730945×𝐢", System, Degree); + assert_parsed_expression_evaluates_to("asinh(2𝐢)", "1.3169578969248+1.5707963267949×𝐢", System, Radian); + assert_parsed_expression_evaluates_to("acosh(-2)", "1.3169578969248+3.1415926535898×𝐢", System, Radian); } QUIZ_CASE(poincare_trigo_simplify) { // -- sin/cos -> tan assert_parsed_expression_simplify_to("sin(x)/cos(x)", "tan(x)"); assert_parsed_expression_simplify_to("cos(x)/sin(x)", "1/tan(x)"); - assert_parsed_expression_simplify_to("sin(x)*P/cos(x)", "P*tan(x)"); - assert_parsed_expression_simplify_to("sin(x)/(P*cos(x))", "tan(x)/P"); - assert_parsed_expression_simplify_to("1*tan(2)*tan(5)", "tan(2)*tan(5)"); - assert_parsed_expression_simplify_to("tan(62P/21)", "-tan(P/21)"); - assert_parsed_expression_simplify_to("cos(26P/21)/sin(25P/17)", "cos((5*P)/21)/sin((8*P)/17)"); - assert_parsed_expression_simplify_to("cos(62P/21)*P*3/sin(62P/21)", "-(3*P)/tan(P/21)"); - assert_parsed_expression_simplify_to("cos(62P/21)/(P*3*sin(62P/21))", "-1/(3*P*tan(P/21))"); - assert_parsed_expression_simplify_to("sin(62P/21)*P*3/cos(62P/21)", "-3*P*tan(P/21)"); - assert_parsed_expression_simplify_to("sin(62P/21)/(P*3cos(62P/21))", "-tan(P/21)/(3*P)"); - assert_parsed_expression_simplify_to("-cos(P/62)ln(3)/(sin(P/62)P)", "-ln(3)/(P*tan(P/62))"); - assert_parsed_expression_simplify_to("-2cos(P/62)ln(3)/(sin(P/62)P)", "-(2*ln(3))/(P*tan(P/62))"); + assert_parsed_expression_simplify_to("sin(x)×π/cos(x)", "π×tan(x)"); + assert_parsed_expression_simplify_to("sin(x)/(π×cos(x))", "tan(x)/π"); + assert_parsed_expression_simplify_to("1×tan(2)×tan(5)", "tan(2)×tan(5)"); + assert_parsed_expression_simplify_to("tan(62π/21)", "-tan(π/21)"); + assert_parsed_expression_simplify_to("cos(26π/21)/sin(25π/17)", "cos((5×π)/21)/sin((8×π)/17)"); + assert_parsed_expression_simplify_to("cos(62π/21)×π×3/sin(62π/21)", "-(3×π)/tan(π/21)"); + assert_parsed_expression_simplify_to("cos(62π/21)/(π×3×sin(62π/21))", "-1/(3×π×tan(π/21))"); + assert_parsed_expression_simplify_to("sin(62π/21)×π×3/cos(62π/21)", "-3×π×tan(π/21)"); + assert_parsed_expression_simplify_to("sin(62π/21)/(π×3cos(62π/21))", "-tan(π/21)/(3×π)"); + assert_parsed_expression_simplify_to("-cos(π/62)ln(3)/(sin(π/62)π)", "-ln(3)/(π×tan(π/62))"); + assert_parsed_expression_simplify_to("-2cos(π/62)ln(3)/(sin(π/62)π)", "-(2×ln(3))/(π×tan(π/62))"); // -- cos assert_parsed_expression_simplify_to("cos(0)", "1"); - assert_parsed_expression_simplify_to("cos(P)", "-1"); - assert_parsed_expression_simplify_to("cos(P*4/7)", "-cos((3*P)/7)"); - assert_parsed_expression_simplify_to("cos(P*35/29)", "-cos((6*P)/29)"); - assert_parsed_expression_simplify_to("cos(-P*35/29)", "-cos((6*P)/29)"); - assert_parsed_expression_simplify_to("cos(P*340000)", "1"); - assert_parsed_expression_simplify_to("cos(-P*340001)", "-1"); - assert_parsed_expression_simplify_to("cos(-P*R(2))", "cos(R(2)*P)"); - assert_parsed_expression_simplify_to("cos(1311P/6)", "0"); - assert_parsed_expression_simplify_to("cos(P/12)", "(R(6)+R(2))/4"); - assert_parsed_expression_simplify_to("cos(-P/12)", "(R(6)+R(2))/4"); - assert_parsed_expression_simplify_to("cos(-P17/8)", "R(R(2)+2)/2"); - assert_parsed_expression_simplify_to("cos(41P/6)", "-R(3)/2"); - assert_parsed_expression_simplify_to("cos(P/4+1000P)", "R(2)/2"); - assert_parsed_expression_simplify_to("cos(-P/3)", "1/2"); - assert_parsed_expression_simplify_to("cos(41P/5)", "(R(5)+1)/4"); - assert_parsed_expression_simplify_to("cos(7P/10)", "-(R(2)*R(-R(5)+5))/4"); + assert_parsed_expression_simplify_to("cos(π)", "-1"); + assert_parsed_expression_simplify_to("cos(π×4/7)", "-cos((3×π)/7)"); + assert_parsed_expression_simplify_to("cos(π×35/29)", "-cos((6×π)/29)"); + assert_parsed_expression_simplify_to("cos(-π×35/29)", "-cos((6×π)/29)"); + assert_parsed_expression_simplify_to("cos(π×340000)", "1"); + assert_parsed_expression_simplify_to("cos(-π×340001)", "-1"); + assert_parsed_expression_simplify_to("cos(-π×√(2))", "cos(√(2)×π)"); + assert_parsed_expression_simplify_to("cos(1311π/6)", "0"); + assert_parsed_expression_simplify_to("cos(π/12)", "(√(6)+√(2))/4"); + assert_parsed_expression_simplify_to("cos(-π/12)", "(√(6)+√(2))/4"); + assert_parsed_expression_simplify_to("cos(-π17/8)", "√(√(2)+2)/2"); + assert_parsed_expression_simplify_to("cos(41π/6)", "-√(3)/2"); + assert_parsed_expression_simplify_to("cos(π/4+1000π)", "√(2)/2"); + assert_parsed_expression_simplify_to("cos(-π/3)", "1/2"); + assert_parsed_expression_simplify_to("cos(41π/5)", "(√(5)+1)/4"); + assert_parsed_expression_simplify_to("cos(7π/10)", "-(√(2)×√(-√(5)+5))/4"); assert_parsed_expression_simplify_to("cos(0)", "1", User, Degree); assert_parsed_expression_simplify_to("cos(180)", "-1", User, Degree); assert_parsed_expression_simplify_to("cos(720/7)", "-cos(540/7)", User, Degree); @@ -375,35 +375,35 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("cos(-6300/29)", "-cos(1080/29)", User, Degree); assert_parsed_expression_simplify_to("cos(61200000)", "1", User, Degree); assert_parsed_expression_simplify_to("cos(-61200180)", "-1", User, Degree); - assert_parsed_expression_simplify_to("cos(-180*R(2))", "cos(180*R(2))", User, Degree); + assert_parsed_expression_simplify_to("cos(-180×√(2))", "cos(180×√(2))", User, Degree); assert_parsed_expression_simplify_to("cos(39330)", "0", User, Degree); - assert_parsed_expression_simplify_to("cos(15)", "(R(6)+R(2))/4", User, Degree); - assert_parsed_expression_simplify_to("cos(-15)", "(R(6)+R(2))/4", User, Degree); - assert_parsed_expression_simplify_to("cos(-765/2)", "R(R(2)+2)/2", User, Degree); - assert_parsed_expression_simplify_to("cos(7380/6)", "-R(3)/2", User, Degree); - assert_parsed_expression_simplify_to("cos(180045)", "R(2)/2", User, Degree); + assert_parsed_expression_simplify_to("cos(15)", "(√(6)+√(2))/4", User, Degree); + assert_parsed_expression_simplify_to("cos(-15)", "(√(6)+√(2))/4", User, Degree); + assert_parsed_expression_simplify_to("cos(-765/2)", "√(√(2)+2)/2", User, Degree); + assert_parsed_expression_simplify_to("cos(7380/6)", "-√(3)/2", User, Degree); + assert_parsed_expression_simplify_to("cos(180045)", "√(2)/2", User, Degree); assert_parsed_expression_simplify_to("cos(-60)", "1/2", User, Degree); - assert_parsed_expression_simplify_to("cos(7380/5)", "(R(5)+1)/4", User, Degree); - assert_parsed_expression_simplify_to("cos(112.5)", "-R(-R(2)+2)/2", User, Degree); + assert_parsed_expression_simplify_to("cos(7380/5)", "(√(5)+1)/4", User, Degree); + assert_parsed_expression_simplify_to("cos(112.5)", "-√(-√(2)+2)/2", User, Degree); // -- sin assert_parsed_expression_simplify_to("sin(0)", "0"); - assert_parsed_expression_simplify_to("sin(P)", "0"); - assert_parsed_expression_simplify_to("sin(P*35/29)", "-sin((6*P)/29)"); - assert_parsed_expression_simplify_to("sin(-P*35/29)", "sin((6*P)/29)"); - assert_parsed_expression_simplify_to("sin(P*340000)", "0"); - assert_parsed_expression_simplify_to("sin(P*340001)", "0"); - assert_parsed_expression_simplify_to("sin(-P*340001)", "0"); - assert_parsed_expression_simplify_to("sin(P/12)", "(R(6)-R(2))/4"); - assert_parsed_expression_simplify_to("sin(-P/12)", "(-R(6)+R(2))/4"); - assert_parsed_expression_simplify_to("sin(-P*R(2))", "-sin(R(2)*P)"); - assert_parsed_expression_simplify_to("sin(1311P/6)", "1"); - assert_parsed_expression_simplify_to("sin(-P17/8)", "-R(-R(2)+2)/2"); - assert_parsed_expression_simplify_to("sin(41P/6)", "1/2"); - assert_parsed_expression_simplify_to("sin(-3P/10)", "(-R(5)-1)/4"); - assert_parsed_expression_simplify_to("sin(P/4+1000P)", "R(2)/2"); - assert_parsed_expression_simplify_to("sin(-P/3)", "-R(3)/2"); - assert_parsed_expression_simplify_to("sin(17P/5)", "-(R(2)*R(R(5)+5))/4"); - assert_parsed_expression_simplify_to("sin(P/5)", "(R(2)*R(-R(5)+5))/4"); + assert_parsed_expression_simplify_to("sin(π)", "0"); + assert_parsed_expression_simplify_to("sin(π×35/29)", "-sin((6×π)/29)"); + assert_parsed_expression_simplify_to("sin(-π×35/29)", "sin((6×π)/29)"); + assert_parsed_expression_simplify_to("sin(π×340000)", "0"); + assert_parsed_expression_simplify_to("sin(π×340001)", "0"); + assert_parsed_expression_simplify_to("sin(-π×340001)", "0"); + assert_parsed_expression_simplify_to("sin(π/12)", "(√(6)-√(2))/4"); + assert_parsed_expression_simplify_to("sin(-π/12)", "(-√(6)+√(2))/4"); + assert_parsed_expression_simplify_to("sin(-π×√(2))", "-sin(√(2)×π)"); + assert_parsed_expression_simplify_to("sin(1311π/6)", "1"); + assert_parsed_expression_simplify_to("sin(-π17/8)", "-√(-√(2)+2)/2"); + assert_parsed_expression_simplify_to("sin(41π/6)", "1/2"); + assert_parsed_expression_simplify_to("sin(-3π/10)", "(-√(5)-1)/4"); + assert_parsed_expression_simplify_to("sin(π/4+1000π)", "√(2)/2"); + assert_parsed_expression_simplify_to("sin(-π/3)", "-√(3)/2"); + assert_parsed_expression_simplify_to("sin(17π/5)", "-(√(2)×√(√(5)+5))/4"); + assert_parsed_expression_simplify_to("sin(π/5)", "(√(2)×√(-√(5)+5))/4"); assert_parsed_expression_simplify_to("sin(0)", "0", User, Degree); assert_parsed_expression_simplify_to("sin(180)", "0", User, Degree); assert_parsed_expression_simplify_to("sin(6300/29)", "-sin(1080/29)", User, Degree); @@ -411,33 +411,33 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("sin(61200000)", "0", User, Degree); assert_parsed_expression_simplify_to("sin(61200180)", "0", User, Degree); assert_parsed_expression_simplify_to("sin(-61200180)", "0", User, Degree); - assert_parsed_expression_simplify_to("sin(15)", "(R(6)-R(2))/4", User, Degree); - assert_parsed_expression_simplify_to("sin(-15)", "(-R(6)+R(2))/4", User, Degree); - assert_parsed_expression_simplify_to("sin(-180*R(2))", "-sin(180*R(2))", User, Degree); + assert_parsed_expression_simplify_to("sin(15)", "(√(6)-√(2))/4", User, Degree); + assert_parsed_expression_simplify_to("sin(-15)", "(-√(6)+√(2))/4", User, Degree); + assert_parsed_expression_simplify_to("sin(-180×√(2))", "-sin(180×√(2))", User, Degree); assert_parsed_expression_simplify_to("sin(39330)", "1", User, Degree); - assert_parsed_expression_simplify_to("sin(-765/2)", "-R(-R(2)+2)/2", User, Degree); + assert_parsed_expression_simplify_to("sin(-765/2)", "-√(-√(2)+2)/2", User, Degree); assert_parsed_expression_simplify_to("sin(1230)", "1/2", User, Degree); - assert_parsed_expression_simplify_to("sin(180045)", "R(2)/2", User, Degree); - assert_parsed_expression_simplify_to("sin(-60)", "-R(3)/2", User, Degree); - assert_parsed_expression_simplify_to("sin(612)", "-(R(2)*R(R(5)+5))/4", User, Degree); - assert_parsed_expression_simplify_to("sin(36)", "(R(2)*R(-R(5)+5))/4", User, Degree); + assert_parsed_expression_simplify_to("sin(180045)", "√(2)/2", User, Degree); + assert_parsed_expression_simplify_to("sin(-60)", "-√(3)/2", User, Degree); + assert_parsed_expression_simplify_to("sin(612)", "-(√(2)×√(√(5)+5))/4", User, Degree); + assert_parsed_expression_simplify_to("sin(36)", "(√(2)×√(-√(5)+5))/4", User, Degree); // -- tan assert_parsed_expression_simplify_to("tan(0)", "0"); - assert_parsed_expression_simplify_to("tan(P)", "0"); - assert_parsed_expression_simplify_to("tan(P*35/29)", "tan((6*P)/29)"); - assert_parsed_expression_simplify_to("tan(-P*35/29)", "-tan((6*P)/29)"); - assert_parsed_expression_simplify_to("tan(P*340000)", "0"); - assert_parsed_expression_simplify_to("tan(P*340001)", "0"); - assert_parsed_expression_simplify_to("tan(-P*340001)", "0"); - assert_parsed_expression_simplify_to("tan(P/12)", "-R(3)+2"); - assert_parsed_expression_simplify_to("tan(-P/12)", "R(3)-2"); - assert_parsed_expression_simplify_to("tan(-P*R(2))", "-tan(R(2)*P)"); - assert_parsed_expression_simplify_to("tan(1311P/6)", Undefined::Name()); - assert_parsed_expression_simplify_to("tan(-P17/8)", "-R(2)+1"); - assert_parsed_expression_simplify_to("tan(41P/6)", "-R(3)/3"); - assert_parsed_expression_simplify_to("tan(P/4+1000P)", "1"); - assert_parsed_expression_simplify_to("tan(-P/3)", "-R(3)"); - assert_parsed_expression_simplify_to("tan(-P/10)", "-(R(5)*R(-2*R(5)+5))/5"); + assert_parsed_expression_simplify_to("tan(π)", "0"); + assert_parsed_expression_simplify_to("tan(π×35/29)", "tan((6×π)/29)"); + assert_parsed_expression_simplify_to("tan(-π×35/29)", "-tan((6×π)/29)"); + assert_parsed_expression_simplify_to("tan(π×340000)", "0"); + assert_parsed_expression_simplify_to("tan(π×340001)", "0"); + assert_parsed_expression_simplify_to("tan(-π×340001)", "0"); + assert_parsed_expression_simplify_to("tan(π/12)", "-√(3)+2"); + assert_parsed_expression_simplify_to("tan(-π/12)", "√(3)-2"); + assert_parsed_expression_simplify_to("tan(-π×√(2))", "-tan(√(2)×π)"); + assert_parsed_expression_simplify_to("tan(1311π/6)", Undefined::Name()); + assert_parsed_expression_simplify_to("tan(-π17/8)", "-√(2)+1"); + assert_parsed_expression_simplify_to("tan(41π/6)", "-√(3)/3"); + assert_parsed_expression_simplify_to("tan(π/4+1000π)", "1"); + assert_parsed_expression_simplify_to("tan(-π/3)", "-√(3)"); + assert_parsed_expression_simplify_to("tan(-π/10)", "-(√(5)×√(-2×√(5)+5))/5"); assert_parsed_expression_simplify_to("tan(0)", "0", User, Degree); assert_parsed_expression_simplify_to("tan(180)", "0", User, Degree); assert_parsed_expression_simplify_to("tan(6300/29)", "tan(1080/29)", User, Degree); @@ -445,25 +445,25 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("tan(61200000)", "0", User, Degree); assert_parsed_expression_simplify_to("tan(61200180)", "0", User, Degree); assert_parsed_expression_simplify_to("tan(-61200180)", "0", User, Degree); - assert_parsed_expression_simplify_to("tan(15)", "-R(3)+2", User, Degree); - assert_parsed_expression_simplify_to("tan(-15)", "R(3)-2", User, Degree); - assert_parsed_expression_simplify_to("tan(-180*R(2))", "-tan(180*R(2))", User, Degree); + assert_parsed_expression_simplify_to("tan(15)", "-√(3)+2", User, Degree); + assert_parsed_expression_simplify_to("tan(-15)", "√(3)-2", User, Degree); + assert_parsed_expression_simplify_to("tan(-180×√(2))", "-tan(180×√(2))", User, Degree); assert_parsed_expression_simplify_to("tan(39330)", Undefined::Name(), User, Degree); - assert_parsed_expression_simplify_to("tan(-382.5)", "-R(2)+1", User, Degree); - assert_parsed_expression_simplify_to("tan(1230)", "-R(3)/3", User, Degree); + assert_parsed_expression_simplify_to("tan(-382.5)", "-√(2)+1", User, Degree); + assert_parsed_expression_simplify_to("tan(1230)", "-√(3)/3", User, Degree); assert_parsed_expression_simplify_to("tan(180045)", "1", User, Degree); - assert_parsed_expression_simplify_to("tan(-60)", "-R(3)", User, Degree); + assert_parsed_expression_simplify_to("tan(-60)", "-√(3)", User, Degree); assert_parsed_expression_simplify_to("tan(tan(tan(tan(9))))", "tan(tan(tan(tan(9))))"); // -- acos - assert_parsed_expression_simplify_to("acos(-1/2)", "(2*P)/3"); - assert_parsed_expression_simplify_to("acos(-1.2)", "-acos(6/5)+P"); + assert_parsed_expression_simplify_to("acos(-1/2)", "(2×π)/3"); + assert_parsed_expression_simplify_to("acos(-1.2)", "-acos(6/5)+π"); assert_parsed_expression_simplify_to("acos(cos(2/3))", "2/3"); assert_parsed_expression_simplify_to("acos(cos(3/2))", "3/2"); assert_parsed_expression_simplify_to("cos(acos(3/2))", "3/2"); assert_parsed_expression_simplify_to("cos(acos(2/3))", "2/3"); assert_parsed_expression_simplify_to("acos(cos(12))", "acos(cos(12))"); - assert_parsed_expression_simplify_to("acos(cos(4P/7))", "(4*P)/7"); - assert_parsed_expression_simplify_to("acos(-cos(2))", "P-2"); + assert_parsed_expression_simplify_to("acos(cos(4π/7))", "(4×π)/7"); + assert_parsed_expression_simplify_to("acos(-cos(2))", "π-2"); assert_parsed_expression_simplify_to("acos(-1/2)", "120", User, Degree); assert_parsed_expression_simplify_to("acos(-1.2)", "-acos(6/5)+180", User, Degree); assert_parsed_expression_simplify_to("acos(cos(2/3))", "2/3", User, Degree); @@ -474,15 +474,15 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("acos(cos(12))", "12", User, Degree); assert_parsed_expression_simplify_to("acos(cos(720/7))", "720/7", User, Degree); // -- asin - assert_parsed_expression_simplify_to("asin(-1/2)", "-P/6"); + assert_parsed_expression_simplify_to("asin(-1/2)", "-π/6"); assert_parsed_expression_simplify_to("asin(-1.2)", "-asin(6/5)"); assert_parsed_expression_simplify_to("asin(sin(2/3))", "2/3"); assert_parsed_expression_simplify_to("sin(asin(2/3))", "2/3"); assert_parsed_expression_simplify_to("sin(asin(3/2))", "3/2"); assert_parsed_expression_simplify_to("asin(sin(3/2))", "3/2"); assert_parsed_expression_simplify_to("asin(sin(12))", "asin(sin(12))"); - assert_parsed_expression_simplify_to("asin(sin(-P/7))", "-P/7"); - assert_parsed_expression_simplify_to("asin(sin(-R(2)))", "-R(2)"); + assert_parsed_expression_simplify_to("asin(sin(-π/7))", "-π/7"); + assert_parsed_expression_simplify_to("asin(sin(-√(2)))", "-√(2)"); assert_parsed_expression_simplify_to("asin(-1/2)", "-30", User, Degree); assert_parsed_expression_simplify_to("asin(-1.2)", "-asin(6/5)", User, Degree); assert_parsed_expression_simplify_to("asin(sin(75))", "75", User, Degree); @@ -492,16 +492,16 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("asin(sin(400))", "40", User, Degree); assert_parsed_expression_simplify_to("asin(sin(-180/7))", "-180/7", User, Degree); // -- atan - assert_parsed_expression_simplify_to("atan(-1)", "-P/4"); + assert_parsed_expression_simplify_to("atan(-1)", "-π/4"); assert_parsed_expression_simplify_to("atan(-1.2)", "-atan(6/5)"); assert_parsed_expression_simplify_to("atan(tan(2/3))", "2/3"); assert_parsed_expression_simplify_to("tan(atan(2/3))", "2/3"); assert_parsed_expression_simplify_to("tan(atan(5/2))", "5/2"); assert_parsed_expression_simplify_to("atan(tan(5/2))", "atan(tan(5/2))"); assert_parsed_expression_simplify_to("atan(tan(5/2))", "atan(tan(5/2))"); - assert_parsed_expression_simplify_to("atan(tan(-P/7))", "-P/7"); - assert_parsed_expression_simplify_to("atan(R(3))", "P/3"); - assert_parsed_expression_simplify_to("atan(tan(-R(2)))", "-R(2)"); + assert_parsed_expression_simplify_to("atan(tan(-π/7))", "-π/7"); + assert_parsed_expression_simplify_to("atan(√(3))", "π/3"); + assert_parsed_expression_simplify_to("atan(tan(-√(2)))", "-√(2)"); assert_parsed_expression_simplify_to("atan(-1)", "-45", User, Degree); assert_parsed_expression_simplify_to("atan(-1.2)", "-atan(6/5)", User, Degree); assert_parsed_expression_simplify_to("atan(tan(-45))", "-45", User, Degree); @@ -510,25 +510,25 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("atan(tan(2293))", "-47", User, Degree); assert_parsed_expression_simplify_to("atan(tan(1808))", "8", User, Degree); assert_parsed_expression_simplify_to("atan(tan(-180/7))", "-180/7", User, Degree); - assert_parsed_expression_simplify_to("atan(R(3))", "60", User, Degree); - assert_parsed_expression_simplify_to("atan(1/x)", "(P*sign(x)-2*atan(x))/2", User, Degree); + assert_parsed_expression_simplify_to("atan(√(3))", "60", User, Degree); + assert_parsed_expression_simplify_to("atan(1/x)", "(π×sign(x)-2×atan(x))/2", User, Degree); // cos(arcsin) - assert_parsed_expression_simplify_to("cos(asin(x))", "R(-x^2+1)", User, Degree); - assert_parsed_expression_simplify_to("cos(asin(-x))", "R(-x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("cos(asin(x))", "√(-x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("cos(asin(-x))", "√(-x^2+1)", User, Degree); // cos(arctan) - assert_parsed_expression_simplify_to("cos(atan(x))", "1/R(x^2+1)", User, Degree); - assert_parsed_expression_simplify_to("cos(atan(-x))", "1/R(x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("cos(atan(x))", "1/√(x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("cos(atan(-x))", "1/√(x^2+1)", User, Degree); // sin(arccos) - assert_parsed_expression_simplify_to("sin(acos(x))", "R(-x^2+1)", User, Degree); - assert_parsed_expression_simplify_to("sin(acos(-x))", "R(-x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("sin(acos(x))", "√(-x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("sin(acos(-x))", "√(-x^2+1)", User, Degree); // sin(arctan) - assert_parsed_expression_simplify_to("sin(atan(x))", "x/R(x^2+1)", User, Degree); - assert_parsed_expression_simplify_to("sin(atan(-x))", "-x/R(x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("sin(atan(x))", "x/√(x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("sin(atan(-x))", "-x/√(x^2+1)", User, Degree); // tan(arccos) - assert_parsed_expression_simplify_to("tan(acos(x))", "R(-x^2+1)/x", User, Degree); - assert_parsed_expression_simplify_to("tan(acos(-x))", "-R(-x^2+1)/x", User, Degree); + assert_parsed_expression_simplify_to("tan(acos(x))", "√(-x^2+1)/x", User, Degree); + assert_parsed_expression_simplify_to("tan(acos(-x))", "-√(-x^2+1)/x", User, Degree); // tan(arcsin) - assert_parsed_expression_simplify_to("tan(asin(x))", "x/R(-x^2+1)", User, Degree); - assert_parsed_expression_simplify_to("tan(asin(-x))", "-x/R(-x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("tan(asin(x))", "x/√(-x^2+1)", User, Degree); + assert_parsed_expression_simplify_to("tan(asin(-x))", "-x/√(-x^2+1)", User, Degree); } diff --git a/poincare/test/user_variable.cpp b/poincare/test/user_variable.cpp index 8e336d245..7a235103c 100644 --- a/poincare/test/user_variable.cpp +++ b/poincare/test/user_variable.cpp @@ -8,26 +8,26 @@ using namespace Poincare; QUIZ_CASE(poincare_user_variable_simple) { // Fill variable - assert_parsed_expression_simplify_to("1+2>Adadas", "3"); + assert_parsed_expression_simplify_to("1+2→Adadas", "3"); assert_parsed_expression_simplify_to("Adadas", "3"); // Fill f1 - assert_parsed_expression_simplify_to("1+x>f1(x)", "x+1"); + assert_parsed_expression_simplify_to("1+x→f1(x)", "x+1"); assert_parsed_expression_simplify_to("f1(4)", "5"); assert_parsed_expression_simplify_to("f1(Adadas)", "4"); // Fill f2 - assert_parsed_expression_simplify_to("x-1>f2(x)", "x-1"); + assert_parsed_expression_simplify_to("x-1→f2(x)", "x-1"); assert_parsed_expression_simplify_to("f2(4)", "3"); assert_parsed_expression_simplify_to("f2(Adadas)", "2"); // Define fBoth with f1 and f2 - assert_parsed_expression_simplify_to("f1(x)+f2(x)>fBoth(x)", "2*x"); + assert_parsed_expression_simplify_to("f1(x)+f2(x)→fBoth(x)", "2×x"); assert_parsed_expression_simplify_to("fBoth(4)", "8"); assert_parsed_expression_simplify_to("fBoth(Adadas)", "6"); // Change f2 - assert_parsed_expression_simplify_to("x>f2(x)", "x"); + assert_parsed_expression_simplify_to("x→f2(x)", "x"); assert_parsed_expression_simplify_to("f2(4)", "4"); assert_parsed_expression_simplify_to("f2(Adadas)", "3"); @@ -43,8 +43,8 @@ QUIZ_CASE(poincare_user_variable_simple) { } QUIZ_CASE(poincare_user_variable_2_circular_variables) { - assert_simplify("a>b"); - assert_simplify("b>a"); + assert_simplify("a→b"); + assert_simplify("b→a"); assert_parsed_expression_evaluates_to("a", Undefined::Name()); assert_parsed_expression_evaluates_to("b", Undefined::Name()); @@ -54,9 +54,9 @@ QUIZ_CASE(poincare_user_variable_2_circular_variables) { } QUIZ_CASE(poincare_user_variable_3_circular_variables) { - assert_simplify("a>b"); - assert_simplify("b>c"); - assert_simplify("c>a"); + assert_simplify("a→b"); + assert_simplify("b→c"); + assert_simplify("c→a"); assert_parsed_expression_evaluates_to("a", Undefined::Name()); assert_parsed_expression_evaluates_to("b", Undefined::Name()); assert_parsed_expression_evaluates_to("c", Undefined::Name()); @@ -68,15 +68,15 @@ QUIZ_CASE(poincare_user_variable_3_circular_variables) { } QUIZ_CASE(poincare_user_variable_1_circular_function) { - // g: x -> f(x)+1 - assert_simplify("f(x)+1>g(x)"); + // g: x → f(x)+1 + assert_simplify("f(x)+1→g(x)"); assert_parsed_expression_evaluates_to("g(1)", Undefined::Name()); - // f: x -> x+1 - assert_simplify("x+1>f(x)"); + // f: x → x+1 + assert_simplify("x+1→f(x)"); assert_parsed_expression_evaluates_to("g(1)", "3"); assert_parsed_expression_evaluates_to("f(1)", "2"); - // h: x -> h(x) - assert_simplify("h(x)>h(x)"); + // h: x → h(x) + assert_simplify("h(x)→h(x)"); assert_parsed_expression_evaluates_to("f(1)", "2"); assert_parsed_expression_evaluates_to("g(1)", "3"); assert_parsed_expression_evaluates_to("h(1)", Undefined::Name()); @@ -88,8 +88,8 @@ QUIZ_CASE(poincare_user_variable_1_circular_function) { } QUIZ_CASE(poincare_user_variable_2_circular_functions) { - assert_simplify("f(x)>g(x)"); - assert_simplify("g(x)>f(x)"); + assert_simplify("f(x)→g(x)"); + assert_simplify("g(x)→f(x)"); assert_parsed_expression_evaluates_to("f(1)", Undefined::Name()); assert_parsed_expression_evaluates_to("g(1)", Undefined::Name()); @@ -99,9 +99,9 @@ QUIZ_CASE(poincare_user_variable_2_circular_functions) { } QUIZ_CASE(poincare_user_variable_3_circular_functions) { - assert_simplify("f(x)>g(x)"); - assert_simplify("g(x)>h(x)"); - assert_simplify("h(x)>f(x)"); + assert_simplify("f(x)→g(x)"); + assert_simplify("g(x)→h(x)"); + assert_simplify("h(x)→f(x)"); assert_parsed_expression_evaluates_to("f(1)", Undefined::Name()); assert_parsed_expression_evaluates_to("g(1)", Undefined::Name()); assert_parsed_expression_evaluates_to("h(1)", Undefined::Name()); @@ -113,9 +113,9 @@ QUIZ_CASE(poincare_user_variable_3_circular_functions) { } QUIZ_CASE(poincare_user_variable_circular_variables_and_functions) { - assert_simplify("a>b"); - assert_simplify("b>a"); - assert_simplify("a>f(x)"); + assert_simplify("a→b"); + assert_simplify("b→a"); + assert_simplify("a→f(x)"); assert_parsed_expression_evaluates_to("f(1)", Undefined::Name()); assert_parsed_expression_evaluates_to("a", Undefined::Name()); assert_parsed_expression_evaluates_to("b", Undefined::Name()); @@ -127,22 +127,22 @@ QUIZ_CASE(poincare_user_variable_circular_variables_and_functions) { } QUIZ_CASE(poincare_user_variable_composed_functions) { - // f: x->x^2 - assert_simplify("x^2>f(x)"); - // g: x->f(x-2) - assert_simplify("f(x-2)>g(x)"); + // f: x→x^2 + assert_simplify("x^2→f(x)"); + // g: x→f(x-2) + assert_simplify("f(x-2)→g(x)"); assert_parsed_expression_evaluates_to("f(2)", "4"); assert_parsed_expression_evaluates_to("g(3)", "1"); assert_parsed_expression_evaluates_to("g(5)", "9"); - // g: x->f(x-2)+f(x+1) - assert_simplify("f(x-2)+f(x+1)>g(x)"); + // g: x→f(x-2)+f(x+1) + assert_simplify("f(x-2)+f(x+1)→g(x)"); // Add a matrix to bypass simplification assert_parsed_expression_evaluates_to("g(3)+[[1]]", "[[18]]"); assert_parsed_expression_evaluates_to("g(5)", "45"); - // g: x->x+1 - assert_simplify("x+1>g(x)"); + // g: x→x+1 + assert_simplify("x+1→g(x)"); assert_parsed_expression_evaluates_to("f(g(4))", "25"); // Add a matrix to bypass simplification assert_parsed_expression_evaluates_to("f(g(4))+[[1]]", "[[26]]"); @@ -153,8 +153,8 @@ QUIZ_CASE(poincare_user_variable_composed_functions) { } QUIZ_CASE(poincare_user_variable_functions_with_context) { - // f: x->x^2 - assert_simplify("x^2>f(x)"); + // f : x→ x^2 + assert_simplify("x^2→f(x)"); // Approximate f(?-2) with ? = 5 const char x[] = {Symbol::SpecialSymbols::UnknownX, 0}; assert_parsed_expression_approximates_with_value_for_symbol(Function::Builder("f", 1, Subtraction::Builder(Symbol::Builder(Symbol::SpecialSymbols::UnknownX), Rational::Builder(2))), x, 5.0, 9.0); @@ -164,12 +164,12 @@ QUIZ_CASE(poincare_user_variable_functions_with_context) { // Clean the storage for other tests Ion::Storage::sharedStorage()->recordNamed("f.func").destroy(); - // f: x->R(-1) - assert_simplify("R(-1)*R(-1)>f(x)"); + // f : x → √(-1) + assert_simplify("√(-1)×√(-1)→f(x)"); // Approximate f(?) with ? = 5 // Cartesian assert_parsed_expression_approximates_with_value_for_symbol(Function::Builder("f", 1, Symbol::Builder(Symbol::SpecialSymbols::UnknownX)), x, 1.0, -1.0); - // Real + // Real assert_parsed_expression_approximates_with_value_for_symbol(Function::Builder("f", 1, Symbol::Builder(Symbol::SpecialSymbols::UnknownX)), x, 1.0, (double)NAN, Real); // Clean the storage for other tests @@ -179,14 +179,15 @@ QUIZ_CASE(poincare_user_variable_functions_with_context) { QUIZ_CASE(poincare_user_variable_properties) { Shared::GlobalContext context; - assert_parsed_expression_evaluates_to("[[1]]>a", "[[1]]"); + assert_parsed_expression_evaluates_to("[[1]]→a", "[[1]]"); quiz_assert(Symbol::Builder('a').isApproximate(context)); quiz_assert(Poincare::Expression::IsMatrix(Symbol::Builder('a'), context, true)); - /* [[x]]->f(x) expression contains a matrix, so its simplification is going + /* [[x]]→f(x) expression contains a matrix, so its simplification is going * to be interrupted. We thus rather approximate it instead of simplifying it. * TODO: use parse_and_simplify when matrix are simplified. */ - assert_parsed_expression_evaluates_to("[[x]]>f(x)", "[[undef]]"); + + assert_parsed_expression_evaluates_to("[[x]]→f(x)", "[[undef]]"); quiz_assert(Function::Builder("f", 1, Rational::Builder(2)).isApproximate(context)); quiz_assert(Poincare::Expression::IsMatrix(Function::Builder("f", 1, Symbol::Builder('x')), context, true)); diff --git a/poincare/test/vertical_offset_layout.cpp b/poincare/test/vertical_offset_layout.cpp index 72bc3ae09..1c1846140 100644 --- a/poincare/test/vertical_offset_layout.cpp +++ b/poincare/test/vertical_offset_layout.cpp @@ -14,5 +14,7 @@ QUIZ_CASE(poincare_vertical_offset_layout_serialize) { VerticalOffsetLayoutNode::Type::Superscript ) ); - assert_expression_layout_serialize_to(layout, "2$x+5#"); + assert(KDCodePointLeftSuperscript == '\x12'); + assert(KDCodePointRightSuperscript == '\x13'); + assert_expression_layout_serialize_to(layout, "2\x12x+5\x13"); }