[tests] Fix unicode for tests

2026-01-19 00:37:25 +01:00 · 2019-01-22 16:27:34 +01:00
parent 76e6860f83
commit 6b6d3d7fe2
30 changed files with 1057 additions and 1057 deletions
--- 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);
 }
--- 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);

 }
--- a/kandinsky/test/utf8decoder.cpp
+++ b/kandinsky/test/utf8decoder.cpp
@@ -1,15 +0,0 @@
-#include <quiz.h>
-#include <kandinsky/unicode/utf8_decoder.h>
-
-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);
-}
--- 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;
--- 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>(float, char*, int, int, Preferences::Preferences::PrintFloatMode, bool);
--- 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<float>("1+2", "3");
-  assert_parsed_expression_evaluates_to<float>("I", "I");
-  assert_parsed_expression_evaluates_to<float>("I+I", "2*I");
-  assert_parsed_expression_evaluates_to<double>("2+I+4+I", "6+2*I");
+  assert_parsed_expression_evaluates_to<float>("𝐢", "𝐢");
+  assert_parsed_expression_evaluates_to<float>("𝐢+𝐢", "2×𝐢");
+  assert_parsed_expression_evaluates_to<double>("2+𝐢+4+𝐢", "6+2×𝐢");
 #if MATRICES_ARE_DEFINED
  assert_parsed_expression_evaluates_to<float>("[[1,2][3,4][5,6]]+3", "[[4,5][6,7][8,9]]");
-  assert_parsed_expression_evaluates_to<double>("[[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<double>("[[1,2+𝐢][3,4][5,6]]+3+𝐢", "[[4+𝐢,5+2×𝐢][6+𝐢,7+𝐢][8+𝐢,9+𝐢]]");
  assert_parsed_expression_evaluates_to<float>("3+[[1,2][3,4][5,6]]", "[[4,5][6,7][8,9]]");
-  assert_parsed_expression_evaluates_to<double>("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<double>("3+𝐢+[[1,2+𝐢][3,4][5,6]]", "[[4+𝐢,5+2×𝐢][6+𝐢,7+𝐢][8+𝐢,9+𝐢]]");
  assert_parsed_expression_evaluates_to<float>("[[1,2][3,4][5,6]]+[[1,2][3,4][5,6]]", "[[2,4][6,8][10,12]]");
-  assert_parsed_expression_evaluates_to<double>("[[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<double>("[[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)×ℯ^π))");
 }
--- 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<float>("I", "unreal", System, Radian, Real);
-  assert_parsed_expression_evaluates_to<double>("R(-1)", "unreal", System, Radian, Real);
-  assert_parsed_expression_evaluates_to<double>("R(-1)*R(-1)", "unreal", System, Radian, Real);
+  assert_parsed_expression_evaluates_to<float>("𝐢", "unreal", System, Radian, Real);
+  assert_parsed_expression_evaluates_to<double>("√(-1)", "unreal", System, Radian, Real);
+  assert_parsed_expression_evaluates_to<double>("√(-1)×√(-1)", "unreal", System, Radian, Real);
  assert_parsed_expression_evaluates_to<double>("ln(-2)", "unreal", System, Radian, Real);
  assert_parsed_expression_evaluates_to<double>("(-8)^(1/3)", "-2", System, Radian, Real);
  assert_parsed_expression_evaluates_to<double>("8^(1/3)", "2", System, Radian, Real);
@@ -18,89 +18,89 @@ QUIZ_CASE(poincare_complex_evaluate) {
  assert_parsed_expression_evaluates_without_simplifying_to<double>("root(-8,3)", "-2", Radian, Real);

  // Cartesian
-  assert_parsed_expression_evaluates_to<float>("I", "I", System, Radian, Cartesian);
-  assert_parsed_expression_evaluates_to<double>("R(-1)", "I", System, Radian, Cartesian);
-  assert_parsed_expression_evaluates_to<double>("R(-1)*R(-1)", "-1", System, Radian, Cartesian);
-  assert_parsed_expression_evaluates_to<double>("ln(-2)", "6.9314718055995E-1+3.1415926535898*I", System, Radian, Cartesian);
-  assert_parsed_expression_evaluates_to<double>("(-8)^(1/3)", "1+1.7320508075689*I", System, Radian, Cartesian);
-  assert_parsed_expression_evaluates_to<float>("(-8)^(2/3)", "-2+3.464102*I", System, Radian, Cartesian);
-  assert_parsed_expression_evaluates_without_simplifying_to<double>("root(-8,3)", "1+1.7320508075689*I", Radian, Cartesian);
+  assert_parsed_expression_evaluates_to<float>("𝐢", "𝐢", System, Radian, Cartesian);
+  assert_parsed_expression_evaluates_to<double>("√(-1)", "𝐢", System, Radian, Cartesian);
+  assert_parsed_expression_evaluates_to<double>("√(-1)×√(-1)", "-1", System, Radian, Cartesian);
+  assert_parsed_expression_evaluates_to<double>("ln(-2)", "6.9314718055995ᴇ-1+3.1415926535898×𝐢", System, Radian, Cartesian);
+  assert_parsed_expression_evaluates_to<double>("(-8)^(1/3)", "1+1.7320508075689×𝐢", System, Radian, Cartesian);
+  assert_parsed_expression_evaluates_to<float>("(-8)^(2/3)", "-2+3.464102×𝐢", System, Radian, Cartesian);
+  assert_parsed_expression_evaluates_without_simplifying_to<double>("root(-8,3)", "1+1.7320508075689×𝐢", Radian, Cartesian);

  // Polar
-  assert_parsed_expression_evaluates_to<float>("I", "X^(1.570796*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<double>("R(-1)", "X^(1.5707963267949*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<double>("R(-1)*R(-1)", "X^(3.1415926535898*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<double>("(-8)^(1/3)", "2*X^(1.0471975511966*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<float>("(-8)^(2/3)", "4*X^(2.094395*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_without_simplifying_to<double>("root(-8,3)", "2*X^(1.0471975511966*I)", Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("𝐢", "ℯ^(1.570796×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<double>("√(-1)", "ℯ^(1.5707963267949×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<double>("√(-1)×√(-1)", "ℯ^(3.1415926535898×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<double>("(-8)^(1/3)", "2×ℯ^(1.0471975511966×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("(-8)^(2/3)", "4×ℯ^(2.094395×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_without_simplifying_to<double>("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();
 }
--- 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<float>("0.1", "0.1");
  assert_parsed_expression_evaluates_to<float>("0.1234567", "0.1234567");
  assert_parsed_expression_evaluates_to<float>("0.12345678", "0.1234568");
-  assert_parsed_expression_evaluates_to<float>("1+2*I", "1+2*I");
-  assert_parsed_expression_evaluates_to<float>("1+I-I", "1");
-  assert_parsed_expression_evaluates_to<float>("1+I-1", "I");
-  assert_parsed_expression_evaluates_to<float>("1+I", "1+I");
-  assert_parsed_expression_evaluates_to<float>("3+I", "3+I");
-  assert_parsed_expression_evaluates_to<float>("3-I", "3-I");
-  assert_parsed_expression_evaluates_to<float>("3-I-3", "-I");
+  assert_parsed_expression_evaluates_to<float>("1+2×𝐢", "1+2×𝐢");
+  assert_parsed_expression_evaluates_to<float>("1+𝐢-𝐢", "1");
+  assert_parsed_expression_evaluates_to<float>("1+𝐢-1", "𝐢");
+  assert_parsed_expression_evaluates_to<float>("1+𝐢", "1+𝐢");
+  assert_parsed_expression_evaluates_to<float>("3+𝐢", "3+𝐢");
+  assert_parsed_expression_evaluates_to<float>("3-𝐢", "3-𝐢");
+  assert_parsed_expression_evaluates_to<float>("3-𝐢-3", "-𝐢");

  assert_parsed_expression_evaluates_to<float>("10", "10", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<float>("-10", "10*X^(3.141593*I)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("-10", "10×ℯ^(3.141593×𝐢)", System, Radian, Polar);
  assert_parsed_expression_evaluates_to<float>("100", "100", System, Radian, Polar);
  assert_parsed_expression_evaluates_to<float>("0.1", "0.1", System, Radian, Polar);
  assert_parsed_expression_evaluates_to<float>("0.1234567", "0.1234567", System, Radian, Polar);
  assert_parsed_expression_evaluates_to<float>("0.12345678", "0.1234568", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<float>("1+2*I", "2.236068*X^(1.107149*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<float>("1+I-I", "1", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<float>("1+I-1", "X^(1.570796*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<float>("1+I", "1.414214*X^(0.7853982*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<float>("3+I", "3.162278*X^(0.3217506*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<float>("3-I", "3.162278*X^(-0.3217506*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<float>("3-I-3", "X^(-1.570796*I)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("1+2×𝐢", "2.236068×ℯ^(1.107149×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("1+𝐢-𝐢", "1", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("1+𝐢-1", "ℯ^(1.570796×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("1+𝐢", "1.414214×ℯ^(0.7853982×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("3+𝐢", "3.162278×ℯ^(0.3217506×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("3-𝐢", "3.162278×ℯ^(-0.3217506×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<float>("3-𝐢-3", "ℯ^(-1.570796×𝐢)", System, Radian, Polar);

  assert_parsed_expression_evaluates_to<double>("10", "10");
  assert_parsed_expression_evaluates_to<double>("-10", "-10");
  assert_parsed_expression_evaluates_to<double>("100", "100");
  assert_parsed_expression_evaluates_to<double>("0.1", "0.1");
-  assert_parsed_expression_evaluates_to<double>("0.12345678901234", "1.2345678901234E-1");
-  assert_parsed_expression_evaluates_to<double>("0.123456789012345", "1.2345678901235E-1");
-  assert_parsed_expression_evaluates_to<double>("1+2*I", "1+2*I");
-  assert_parsed_expression_evaluates_to<double>("1+I-I", "1");
-  assert_parsed_expression_evaluates_to<double>("1+I-1", "I");
-  assert_parsed_expression_evaluates_to<double>("1+I", "1+I");
-  assert_parsed_expression_evaluates_to<double>("3+I", "3+I");
-  assert_parsed_expression_evaluates_to<double>("3-I", "3-I");
-  assert_parsed_expression_evaluates_to<double>("3-I-3", "-I");
+  assert_parsed_expression_evaluates_to<double>("0.12345678901234", "1.2345678901234ᴇ-1");
+  assert_parsed_expression_evaluates_to<double>("0.123456789012345", "1.2345678901235ᴇ-1");
+  assert_parsed_expression_evaluates_to<double>("1+2×𝐢", "1+2×𝐢");
+  assert_parsed_expression_evaluates_to<double>("1+𝐢-𝐢", "1");
+  assert_parsed_expression_evaluates_to<double>("1+𝐢-1", "𝐢");
+  assert_parsed_expression_evaluates_to<double>("1+𝐢", "1+𝐢");
+  assert_parsed_expression_evaluates_to<double>("3+𝐢", "3+𝐢");
+  assert_parsed_expression_evaluates_to<double>("3-𝐢", "3-𝐢");
+  assert_parsed_expression_evaluates_to<double>("3-𝐢-3", "-𝐢");

  assert_parsed_expression_evaluates_to<double>("10", "10", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<double>("-10", "10*X^(3.1415926535898*I)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<double>("-10", "10×ℯ^(3.1415926535898×𝐢)", System, Radian, Polar);
  assert_parsed_expression_evaluates_to<double>("100", "100", System, Radian, Polar);
  assert_parsed_expression_evaluates_to<double>("0.1", "0.1", System, Radian, Polar);
  assert_parsed_expression_evaluates_to<double>("0.1234567", "0.1234567", System, Radian, Polar);
  assert_parsed_expression_evaluates_to<double>("0.12345678", "0.12345678", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<double>("1+2*I", "2.2360679775*X^(1.10714871779*I)", System, Radian, Polar, 12);
-  assert_parsed_expression_evaluates_to<double>("1+I-I", "1", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<double>("1+I-1", "X^(1.57079632679*I)", System, Radian, Polar, 12);
-  assert_parsed_expression_evaluates_to<double>("1+I", "1.41421356237*X^(0.785398163397*I)", System, Radian, Polar, 12);
-  assert_parsed_expression_evaluates_to<double>("3+I", "3.16227766017*X^(0.321750554397*I)", System, Radian, Polar,12);
-  assert_parsed_expression_evaluates_to<double>("3-I", "3.16227766017*X^(-0.321750554397*I)", System, Radian, Polar,12);
-  assert_parsed_expression_evaluates_to<double>("3-I-3", "X^(-1.57079632679*I)", System, Radian, Polar,12);
+  assert_parsed_expression_evaluates_to<double>("1+2×𝐢", "2.2360679775×ℯ^(1.10714871779×𝐢)", System, Radian, Polar, 12);
+  assert_parsed_expression_evaluates_to<double>("1+𝐢-𝐢", "1", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<double>("1+𝐢-1", "ℯ^(1.57079632679×𝐢)", System, Radian, Polar, 12);
+  assert_parsed_expression_evaluates_to<double>("1+𝐢", "1.41421356237×ℯ^(0.785398163397×𝐢)", System, Radian, Polar, 12);
+  assert_parsed_expression_evaluates_to<double>("3+𝐢", "3.16227766017×ℯ^(0.321750554397×𝐢)", System, Radian, Polar,12);
+  assert_parsed_expression_evaluates_to<double>("3-𝐢", "3.16227766017×ℯ^(-0.321750554397×𝐢)", System, Radian, Polar,12);
+  assert_parsed_expression_evaluates_to<double>("3-𝐢-3", "ℯ^(-1.57079632679×𝐢)", System, Radian, Polar,12);

-  assert_parsed_expression_evaluates_to<double>("2+3*I", "3.60555127546*X^(0.982793723247*I)", System, Radian, Polar, 12);
-  assert_parsed_expression_evaluates_to<double>("3.60555127546*X^(0.982793723247*I)", "2+3*I", System, Radian, Cartesian, 12);
-  assert_parsed_expression_evaluates_to<float>("12.04159457879229548012824103*X^(1.4876550949*I)", "1+12*I", System, Radian, Cartesian, 5);
-  assert_parsed_expression_evaluates_to<float>("-2E20+2E20*I", "-2E20+2E20*I");
-  assert_parsed_expression_evaluates_to<float>("-2E20+2E20*I", "2.828427E20*X^(2.356194*I)", System, Radian, Polar);
-  assert_parsed_expression_evaluates_to<double>("1E155-1E155*I", "1E155-1E155*I");
-  assert_parsed_expression_evaluates_to<double>("1E155-1E155*I", "1.41421356237E155*X^(-0.785398163397*I)", System, Radian, Polar,12);
+  assert_parsed_expression_evaluates_to<double>("2+3×𝐢", "3.60555127546×ℯ^(0.982793723247×𝐢)", System, Radian, Polar, 12);
+  assert_parsed_expression_evaluates_to<double>("3.60555127546×ℯ^(0.982793723247×𝐢)", "2+3×𝐢", System, Radian, Cartesian, 12);
+  assert_parsed_expression_evaluates_to<float>("12.04159457879229548012824103×ℯ^(1.4876550949×𝐢)", "1+12×𝐢", System, Radian, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<float>("-2ᴇ20+2ᴇ20×𝐢", "-2ᴇ20+2ᴇ20×𝐢");
+  assert_parsed_expression_evaluates_to<float>("-2ᴇ20+2ᴇ20×𝐢", "2.828427ᴇ20×ℯ^(2.356194×𝐢)", System, Radian, Polar);
+  assert_parsed_expression_evaluates_to<double>("1ᴇ155-1ᴇ155×𝐢", "1ᴇ155-1ᴇ155×𝐢");
+  assert_parsed_expression_evaluates_to<double>("1ᴇ155-1ᴇ155×𝐢", "1.41421356237ᴇ155×ℯ^(-0.785398163397×𝐢)", System, Radian, Polar,12);

-  assert_parsed_expression_evaluates_to<float>("-2E100+2E100*I", Undefined::Name());
-  assert_parsed_expression_evaluates_to<double>("-2E360+2E360*I", Undefined::Name());
-  assert_parsed_expression_evaluates_to<float>("-2E100+2E10*I", "-inf+2E10*I");
-  assert_parsed_expression_evaluates_to<double>("-2E360+2*I", "-inf+2*I");
-  assert_parsed_expression_evaluates_to<float>("undef+2E100*I", Undefined::Name());
-  assert_parsed_expression_evaluates_to<double>("-2E360+undef*I", Undefined::Name());
+  assert_parsed_expression_evaluates_to<float>("-2ᴇ100+2ᴇ100×𝐢", Undefined::Name());
+  assert_parsed_expression_evaluates_to<double>("-2ᴇ360+2ᴇ360×𝐢", Undefined::Name());
+  assert_parsed_expression_evaluates_to<float>("-2ᴇ100+2ᴇ10×𝐢", "-inf+2ᴇ10×𝐢");
+  assert_parsed_expression_evaluates_to<double>("-2ᴇ360+2×𝐢", "-inf+2×𝐢");
+  assert_parsed_expression_evaluates_to<float>("undef+2ᴇ100×𝐢", Undefined::Name());
+  assert_parsed_expression_evaluates_to<double>("-2ᴇ360+undef×𝐢", Undefined::Name());

-  assert_parsed_expression_evaluates_to<double>("2*X^(I)", "2*X^I", System, Radian, Polar, 5);
-  assert_parsed_expression_evaluates_to<double>("2*X^(-I)", "2*X^(-I)", System, Radian, Polar, 5);
+  assert_parsed_expression_evaluates_to<double>("2×ℯ^(𝐢)", "2×ℯ^𝐢", System, Radian, Polar, 5);
+  assert_parsed_expression_evaluates_to<double>("2×ℯ^(-𝐢)", "2×ℯ^(-𝐢)", System, Radian, Polar, 5);
 }
--- 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<double>::Builder(-1.23456789E30), "-1.23456789E30", DecimalMode, 14);
-  assert_expression_prints_to(Float<double>::Builder(1.23456789E30), "1.23456789E30", DecimalMode, 14);
-  assert_expression_prints_to(Float<double>::Builder(-1.23456789E-30), "-1.23456789E-30", DecimalMode, 14);
+  assert_expression_prints_to(Float<double>::Builder(-1.23456789E30), "-1.23456789ᴇ30", DecimalMode, 14);
+  assert_expression_prints_to(Float<double>::Builder(1.23456789E30), "1.23456789ᴇ30", DecimalMode, 14);
+  assert_expression_prints_to(Float<double>::Builder(-1.23456789E-30), "-1.23456789ᴇ-30", DecimalMode, 14);
  assert_expression_prints_to(Float<double>::Builder(-1.2345E-3), "-0.0012345", DecimalMode);
  assert_expression_prints_to(Float<double>::Builder(1.2345E-3), "0.0012345", DecimalMode);
  assert_expression_prints_to(Float<double>::Builder(1.2345E3), "1234.5", DecimalMode);
  assert_expression_prints_to(Float<double>::Builder(-1.2345E3), "-1234.5", DecimalMode);
-  assert_expression_prints_to(Float<double>::Builder(0.99999999999995), "9.9999999999995E-1", ScientificMode, 14);
-  assert_expression_prints_to(Float<double>::Builder(0.00000099999999999995), "9.9999999999995E-7", DecimalMode, 14);
-  assert_expression_prints_to(Float<double>::Builder(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7", DecimalMode, 14);
+  assert_expression_prints_to(Float<double>::Builder(0.99999999999995), "9.9999999999995ᴇ-1", ScientificMode, 14);
+  assert_expression_prints_to(Float<double>::Builder(0.00000099999999999995), "9.9999999999995ᴇ-7", DecimalMode, 14);
+  assert_expression_prints_to(Float<double>::Builder(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012ᴇ-7", DecimalMode, 14);
  assert_expression_prints_to(Float<float>::Builder(1.2345E-1), "0.12345", DecimalMode);
  assert_expression_prints_to(Float<float>::Builder(1), "1", DecimalMode);
  assert_expression_prints_to(Float<float>::Builder(0.9999999999999995), "1", DecimalMode);
--- 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<float>("1.2343E-2", "0.012343");
-  assert_parsed_expression_evaluates_to<double>("-567.2E2", "-56720");
+  assert_parsed_expression_evaluates_to<float>("1.2343ᴇ-2", "0.012343");
+  assert_parsed_expression_evaluates_to<double>("-567.2ᴇ2", "-56720");
 }
--- 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<float>("1/2", "0.5");
-  assert_parsed_expression_evaluates_to<double>("(3+I)/(4+I)", "7.6470588235294E-1+5.8823529411765E-2*I");
+  assert_parsed_expression_evaluates_to<double>("(3+𝐢)/(4+𝐢)", "7.6470588235294ᴇ-1+5.8823529411765ᴇ-2×𝐢");

 #if MATRICES_ARE_DEFINED
  assert_parsed_expression_evaluates_to<float>("[[1,2][3,4][5,6]]/2", "[[0.5,1][1.5,2][2.5,3]]");
-  assert_parsed_expression_evaluates_to<double>("[[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<double>("[[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<float>("[[1,2][3,4][5,6]]/2", "[[0.5,1][1.5,2][2.5,3]]");
-  assert_parsed_expression_evaluates_to<double>("[[1,2][3,4]]/[[3,4][6,9]]", "[[-1,6.6666666666667E-1][1,0]]");
+  assert_parsed_expression_evaluates_to<double>("[[1,2][3,4]]/[[3,4][6,9]]", "[[-1,6.6666666666667ᴇ-1][1,0]]");
  assert_parsed_expression_evaluates_to<double>("3/[[3,4][5,6]]", "[[-9,6][7.5,-4.5]]");
-  assert_parsed_expression_evaluates_to<double>("(3+4I)/[[1,I][3,4]]", "[[4*I,1][-3*I,I]]");
+  assert_parsed_expression_evaluates_to<double>("(3+4𝐢)/[[1,𝐢][3,4]]", "[[4×𝐢,1][-3×𝐢,𝐢]]");
 #endif
-  assert_parsed_expression_evaluates_to<float>("1E20/(1E20+1E20I)", "0.5-0.5*I");
-  assert_parsed_expression_evaluates_to<double>("1E155/(1E155+1E155I)", "0.5-0.5*I");
+  assert_parsed_expression_evaluates_to<float>("1ᴇ20/(1ᴇ20+1ᴇ20𝐢)", "0.5-0.5×𝐢");
+  assert_parsed_expression_evaluates_to<double>("1ᴇ155/(1ᴇ155+1ᴇ155𝐢)", "0.5-0.5×𝐢");
 }
--- 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());
 }
--- a/poincare/test/float.cpp
+++ b/poincare/test/float.cpp
@@ -21,16 +21,16 @@ void assert_float_evaluates_to(Float<T> f, const char * result) {
 }

 QUIZ_CASE(poincare_float_evaluate) {
-  assert_float_evaluates_to<double>(Float<double>::Builder(-1.23456789E30), "-1.23456789E30");
-  assert_float_evaluates_to<double>(Float<double>::Builder(1.23456789E30), "1.23456789E30");
-  assert_float_evaluates_to<double>(Float<double>::Builder(-1.23456789E-30), "-1.23456789E-30");
+  assert_float_evaluates_to<double>(Float<double>::Builder(-1.23456789E30), "-1.23456789ᴇ30");
+  assert_float_evaluates_to<double>(Float<double>::Builder(1.23456789E30), "1.23456789ᴇ30");
+  assert_float_evaluates_to<double>(Float<double>::Builder(-1.23456789E-30), "-1.23456789ᴇ-30");
  assert_float_evaluates_to<double>(Float<double>::Builder(-1.2345E-3), "-0.0012345");
  assert_float_evaluates_to<double>(Float<double>::Builder(1.2345E-3), "0.0012345");
  assert_float_evaluates_to<double>(Float<double>::Builder(1.2345E3), "1234.5");
  assert_float_evaluates_to<double>(Float<double>::Builder(-1.2345E3), "-1234.5");
-  assert_float_evaluates_to<double>(Float<double>::Builder(0.99999999999995), "9.9999999999995E-1");
-  assert_float_evaluates_to<double>(Float<double>::Builder(0.00000099999999999995), "9.9999999999995E-7");
-  assert_float_evaluates_to<double>(Float<double>::Builder(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7");
+  assert_float_evaluates_to<double>(Float<double>::Builder(0.99999999999995), "9.9999999999995ᴇ-1");
+  assert_float_evaluates_to<double>(Float<double>::Builder(0.00000099999999999995), "9.9999999999995ᴇ-7");
+  assert_float_evaluates_to<double>(Float<double>::Builder(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012ᴇ-7");
  assert_float_evaluates_to<float>(Float<float>::Builder(1.2345E-1), "0.12345");
  assert_float_evaluates_to<float>(Float<float>::Builder(1), "1");
  assert_float_evaluates_to<float>(Float<float>::Builder(0.9999999999999995), "1");
--- 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<float>("abs(-1)", "1");
  assert_parsed_expression_evaluates_to<double>("abs(-1)", "1");

-  assert_parsed_expression_evaluates_to<float>("abs(3+2I)", "3.605551");
-  assert_parsed_expression_evaluates_to<double>("abs(3+2I)", "3.605551275464");
+  assert_parsed_expression_evaluates_to<float>("abs(3+2𝐢)", "3.605551");
+  assert_parsed_expression_evaluates_to<double>("abs(3+2𝐢)", "3.605551275464");

  assert_parsed_expression_evaluates_to<float>("abs([[1,-2][3,-4]])", "[[1,2][3,4]]");
  assert_parsed_expression_evaluates_to<double>("abs([[1,-2][3,-4]])", "[[1,2][3,4]]");

-  assert_parsed_expression_evaluates_to<float>("abs([[3+2I,3+4I][5+2I,3+2I]])", "[[3.605551,5][5.385165,3.605551]]");
-  assert_parsed_expression_evaluates_to<double>("abs([[3+2I,3+4I][5+2I,3+2I]])", "[[3.605551275464,5][5.3851648071345,3.605551275464]]");
+  assert_parsed_expression_evaluates_to<float>("abs([[3+2𝐢,3+4𝐢][5+2𝐢,3+2𝐢]])", "[[3.605551,5][5.385165,3.605551]]");
+  assert_parsed_expression_evaluates_to<double>("abs([[3+2𝐢,3+4𝐢][5+2𝐢,3+2𝐢]])", "[[3.605551275464,5][5.3851648071345,3.605551275464]]");

  assert_parsed_expression_evaluates_to<float>("binomial(10, 4)", "210");
  assert_parsed_expression_evaluates_to<double>("binomial(10, 4)", "210");
@@ -86,14 +86,16 @@ QUIZ_CASE(poincare_function_evaluate) {
 #if MATRICES_ARE_DEFINED
  assert_parsed_expression_evaluates_to<float>("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<double>("det([[1,23,3][4,5,6][7,8,9]])", "126");
-  assert_parsed_expression_evaluates_to<float>("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<double>("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<float>("diff(2*x, x, 2)", "2");
-  assert_parsed_expression_evaluates_to<double>("diff(2*x, x, 2)", "2");

-  assert_parsed_expression_evaluates_to<float>("diff(2*TO^2, TO, 7)", "28");
-  assert_parsed_expression_evaluates_to<double>("diff(2*TO^2, TO, 7)", "28");
+  assert_parsed_expression_evaluates_to<float>("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<double>("det([[𝐢,23-2𝐢,3×𝐢][4+𝐢,5×𝐢,6][7,8×𝐢+2,9]])", "126-231×𝐢");
+#endif
+
+  assert_parsed_expression_evaluates_to<float>("diff(2×x, x, 2)", "2");
+  assert_parsed_expression_evaluates_to<double>("diff(2×x, x, 2)", "2");
+
+  assert_parsed_expression_evaluates_to<float>("diff(2×TO^2, TO, 7)", "28");
+  assert_parsed_expression_evaluates_to<double>("diff(2×TO^2, TO, 7)", "28");

  assert_parsed_expression_evaluates_to<float>("floor(2.3)", "2");
  assert_parsed_expression_evaluates_to<double>("floor(2.3)", "2");
@@ -104,8 +106,8 @@ QUIZ_CASE(poincare_function_evaluate) {
  assert_parsed_expression_evaluates_to<float>("gcd(234,394)", "2");
  assert_parsed_expression_evaluates_to<double>("gcd(234,394)", "2");

-  assert_parsed_expression_evaluates_to<float>("im(2+3I)", "3");
-  assert_parsed_expression_evaluates_to<double>("im(2+3I)", "3");
+  assert_parsed_expression_evaluates_to<float>("im(2+3𝐢)", "3");
+  assert_parsed_expression_evaluates_to<double>("im(2+3𝐢)", "3");

  assert_parsed_expression_evaluates_to<float>("lcm(234,394)", "46098");
  assert_parsed_expression_evaluates_to<double>("lcm(234,394)", "46098");
@@ -114,10 +116,10 @@ QUIZ_CASE(poincare_function_evaluate) {
  assert_parsed_expression_evaluates_to<double>("int(x,x, 1, 2)", "1.5");

  assert_parsed_expression_evaluates_to<float>("ln(2)", "0.6931472");
-  assert_parsed_expression_evaluates_to<double>("ln(2)", "6.9314718055995E-1");
+  assert_parsed_expression_evaluates_to<double>("ln(2)", "6.9314718055995ᴇ-1");

  assert_parsed_expression_evaluates_to<float>("log(2)", "0.30103");
-  assert_parsed_expression_evaluates_to<double>("log(2)", "3.0102999566398E-1");
+  assert_parsed_expression_evaluates_to<double>("log(2)", "3.0102999566398ᴇ-1");

  assert_parsed_expression_evaluates_to<float>("permute(10, 4)", "5040");
  assert_parsed_expression_evaluates_to<double>("permute(10, 4)", "5040");
@@ -128,19 +130,19 @@ QUIZ_CASE(poincare_function_evaluate) {
  assert_parsed_expression_evaluates_to<float>("quo(29, 10)", "2");
  assert_parsed_expression_evaluates_to<double>("quo(29, 10)", "2");

-  assert_parsed_expression_evaluates_to<float>("re(2+I)", "2");
-  assert_parsed_expression_evaluates_to<double>("re(2+I)", "2");
+  assert_parsed_expression_evaluates_to<float>("re(2+𝐢)", "2");
+  assert_parsed_expression_evaluates_to<double>("re(2+𝐢)", "2");

  assert_parsed_expression_evaluates_to<float>("rem(29, 10)", "9");
  assert_parsed_expression_evaluates_to<double>("rem(29, 10)", "9");
  assert_parsed_expression_evaluates_to<float>("root(2,3)", "1.259921");
  assert_parsed_expression_evaluates_to<double>("root(2,3)", "1.2599210498949");

-  assert_parsed_expression_evaluates_to<float>("R(2)", "1.414214");
-  assert_parsed_expression_evaluates_to<double>("R(2)", "1.4142135623731");
+  assert_parsed_expression_evaluates_to<float>("√(2)", "1.414214");
+  assert_parsed_expression_evaluates_to<double>("√(2)", "1.4142135623731");

-  assert_parsed_expression_evaluates_to<float>("R(-1)", "I");
-  assert_parsed_expression_evaluates_to<double>("R(-1)", "I");
+  assert_parsed_expression_evaluates_to<float>("√(-1)", "𝐢");
+  assert_parsed_expression_evaluates_to<double>("√(-1)", "𝐢");

  assert_parsed_expression_evaluates_to<float>("sum(r,r, 4, 10)", "49");
  assert_parsed_expression_evaluates_to<double>("sum(k,k, 4, 10)", "49");
@@ -158,17 +160,17 @@ QUIZ_CASE(poincare_function_evaluate) {
  assert_parsed_expression_evaluates_to<double>("dim([[1,2,3][4,5,-6]])", "[[2,3]]");
 #endif

-  assert_parsed_expression_evaluates_to<float>("conj(3+2*I)", "3-2*I");
-  assert_parsed_expression_evaluates_to<double>("conj(3+2*I)", "3-2*I");
+  assert_parsed_expression_evaluates_to<float>("conj(3+2×𝐢)", "3-2×𝐢");
+  assert_parsed_expression_evaluates_to<double>("conj(3+2×𝐢)", "3-2×𝐢");

  assert_parsed_expression_evaluates_to<float>("factor(-23/4)", "-5.75");
  assert_parsed_expression_evaluates_to<double>("factor(-123/24)", "-5.125");

 #if MATRICES_ARE_DEFINED
  assert_parsed_expression_evaluates_to<float>("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<double>("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<float>("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<double>("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<double>("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<float>("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<double>("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<float>("prediction(0.1, 100)", "[[0,0.2]]");
@@ -177,20 +179,20 @@ QUIZ_CASE(poincare_function_evaluate) {
  assert_parsed_expression_evaluates_to<float>("prediction95(0.1, 100)", "[[0.0412,0.1588]]");
  assert_parsed_expression_evaluates_to<double>("prediction95(0.1, 100)", "[[0.0412,0.1588]]");

-  assert_parsed_expression_evaluates_to<float>("product(2+k*I,k, 1, 5)", "-100-540*I");
-  assert_parsed_expression_evaluates_to<double>("product(2+o*I,o, 1, 5)", "-100-540*I");
+  assert_parsed_expression_evaluates_to<float>("product(2+k×𝐢,k, 1, 5)", "-100-540×𝐢");
+  assert_parsed_expression_evaluates_to<double>("product(2+o×𝐢,o, 1, 5)", "-100-540×𝐢");

-  assert_parsed_expression_evaluates_to<float>("root(3+I, 3)", "1.459366+0.1571201*I");
-  assert_parsed_expression_evaluates_to<double>("root(3+I, 3)", "1.4593656008684+1.5712012294394E-1*I");
+  assert_parsed_expression_evaluates_to<float>("root(3+𝐢, 3)", "1.459366+0.1571201×𝐢");
+  assert_parsed_expression_evaluates_to<double>("root(3+𝐢, 3)", "1.4593656008684+1.5712012294394ᴇ-1×𝐢");

-  assert_parsed_expression_evaluates_to<float>("root(3, 3+I)", "1.382007-0.1524428*I");
-  assert_parsed_expression_evaluates_to<double>("root(3, 3+I)", "1.3820069623326-0.1524427794159*I");
+  assert_parsed_expression_evaluates_to<float>("root(3, 3+𝐢)", "1.382007-0.1524428×𝐢");
+  assert_parsed_expression_evaluates_to<double>("root(3, 3+𝐢)", "1.3820069623326-0.1524427794159×𝐢");

-  assert_parsed_expression_evaluates_to<float>("root(5^((-I)3^9),I)", "3.504", System, Degree, Cartesian, 4);
-  assert_parsed_expression_evaluates_to<double>("root(5^((-I)3^9),I)", "3.5039410843", System, Degree, Cartesian, 11);
+  assert_parsed_expression_evaluates_to<float>("root(5^((-𝐢)3^9),𝐢)", "3.504", System, Degree, Cartesian, 4);
+  assert_parsed_expression_evaluates_to<double>("root(5^((-𝐢)3^9),𝐢)", "3.5039410843", System, Degree, Cartesian, 11);

-  assert_parsed_expression_evaluates_to<float>("R(3+I)", "1.755317+0.2848488*I");
-  assert_parsed_expression_evaluates_to<double>("R(3+I)", "1.7553173018244+2.8484878459314E-1*I");
+  assert_parsed_expression_evaluates_to<float>("√(3+𝐢)", "1.755317+0.2848488×𝐢");
+  assert_parsed_expression_evaluates_to<double>("√(3+𝐢)", "1.7553173018244+2.8484878459314ᴇ-1×𝐢");

  assert_parsed_expression_evaluates_to<float>("sign(-23+1)", "-1");
  assert_parsed_expression_evaluates_to<float>("sign(inf)", "1");
@@ -198,11 +200,11 @@ QUIZ_CASE(poincare_function_evaluate) {
  assert_parsed_expression_evaluates_to<float>("sign(0)", "0");
  assert_parsed_expression_evaluates_to<float>("sign(-0)", "0");
  assert_parsed_expression_evaluates_to<float>("sign(x)", "undef");
-  assert_parsed_expression_evaluates_to<double>("sign(2+I)", "undef");
+  assert_parsed_expression_evaluates_to<double>("sign(2+𝐢)", "undef");
  assert_parsed_expression_evaluates_to<double>("sign(undef)", "undef");

-  assert_parsed_expression_evaluates_to<double>("sum(2+n*I,n,1,5)", "10+15*I");
-  assert_parsed_expression_evaluates_to<double>("sum(2+n*I,n,1,5)", "10+15*I");
+  assert_parsed_expression_evaluates_to<double>("sum(2+n×𝐢,n,1,5)", "10+15×𝐢");
+  assert_parsed_expression_evaluates_to<double>("sum(2+n×𝐢,n,1,5)", "10+15×𝐢");

 #if MATRICES_ARE_DEFINED
  assert_parsed_expression_evaluates_to<float>("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<float>("6!", "720");
  assert_parsed_expression_evaluates_to<double>("6!", "720");

-  assert_parsed_expression_evaluates_to<float>("R(-1)", "I");
-  assert_parsed_expression_evaluates_to<double>("R(-1)", "I");
+  assert_parsed_expression_evaluates_to<float>("√(-1)", "𝐢");
+  assert_parsed_expression_evaluates_to<double>("√(-1)", "𝐢");

-  assert_parsed_expression_evaluates_to<float>("root(-1,3)", "0.5+0.8660254*I");
-  assert_parsed_expression_evaluates_to<double>("root(-1,3)", "0.5+8.6602540378444E-1*I");
+  assert_parsed_expression_evaluates_to<float>("root(-1,3)", "0.5+0.8660254×𝐢");
+  assert_parsed_expression_evaluates_to<double>("root(-1,3)", "0.5+8.6602540378444ᴇ-1×𝐢");

-  assert_parsed_expression_evaluates_to<float>("int(int(x*x,x,0,x),x,0,4)", "21.33333");
-  assert_parsed_expression_evaluates_to<double>("int(int(x*x,x,0,x),x,0,4)", "21.333333333333");
+  assert_parsed_expression_evaluates_to<float>("int(int(x×x,x,0,x),x,0,4)", "21.33333");
+  assert_parsed_expression_evaluates_to<double>("int(int(x×x,x,0,x),x,0,4)", "21.333333333333");

  assert_parsed_expression_evaluates_to<float>("int(1+cos(e),e, 0, 180)", "180");
  assert_parsed_expression_evaluates_to<double>("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");
--- 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<double>("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<double>("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");
--- 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);
 }
--- a/poincare/test/logarithm.cpp
+++ b/poincare/test/logarithm.cpp
@@ -10,16 +10,16 @@ QUIZ_CASE(poincare_logarithm_evaluate) {
  assert_parsed_expression_evaluates_to<double>("log(6,7)", "0.9207822211616");
  assert_parsed_expression_evaluates_to<float>("log(5)", "0.69897");
  assert_parsed_expression_evaluates_to<double>("ln(5)", "1.6094379124341");
-  assert_parsed_expression_evaluates_to<float>("log(2+5*I,64)", "0.4048317+0.2862042*I");
-  assert_parsed_expression_evaluates_to<double>("log(6,7+4*I)", "8.0843880717528E-1-2.0108238082167E-1*I");
-  assert_parsed_expression_evaluates_to<float>("log(5+2*I)", "0.731199+0.1652518*I");
-  assert_parsed_expression_evaluates_to<double>("ln(5+2*I)", "1.6836479149932+3.8050637711236E-1*I");
+  assert_parsed_expression_evaluates_to<float>("log(2+5×𝐢,64)", "0.4048317+0.2862042×𝐢");
+  assert_parsed_expression_evaluates_to<double>("log(6,7+4×𝐢)", "8.0843880717528ᴇ-1-2.0108238082167ᴇ-1×𝐢");
+  assert_parsed_expression_evaluates_to<float>("log(5+2×𝐢)", "0.731199+0.1652518×𝐢");
+  assert_parsed_expression_evaluates_to<double>("ln(5+2×𝐢)", "1.6836479149932+3.8050637711236ᴇ-1×𝐢");
  assert_parsed_expression_evaluates_to<double>("log(0,0)", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("log(0)", "-inf");
  assert_parsed_expression_evaluates_to<double>("log(2,0)", "0");

  // WARNING: evaluate on branch cut can be multivalued
-  assert_parsed_expression_evaluates_to<double>("ln(-4)", "1.3862943611199+3.1415926535898*I");
+  assert_parsed_expression_evaluates_to<double>("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)");
 }
--- 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<float>("1*2", "2");
-  assert_parsed_expression_evaluates_to<double>("(3+I)*(4+I)", "11+7*I");
+  assert_parsed_expression_evaluates_to<float>("1×2", "2");
+  assert_parsed_expression_evaluates_to<double>("(3+𝐢)×(4+𝐢)", "11+7×𝐢");

 #if MATRICES_ARE_DEFINED
-  assert_parsed_expression_evaluates_to<float>("[[1,2][3,4][5,6]]*2", "[[2,4][6,8][10,12]]");
-  assert_parsed_expression_evaluates_to<double>("[[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<float>("2*[[1,2][3,4][5,6]]", "[[2,4][6,8][10,12]]");
-  assert_parsed_expression_evaluates_to<double>("(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<float>("[[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<double>("[[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<float>("[[1,2][3,4][5,6]]×2", "[[2,4][6,8][10,12]]");
+  assert_parsed_expression_evaluates_to<double>("[[1,2+𝐢][3,4][5,6]]×(3+𝐢)", "[[3+𝐢,5+5×𝐢][9+3×𝐢,12+4×𝐢][15+5×𝐢,18+6×𝐢]]");
+  assert_parsed_expression_evaluates_to<float>("2×[[1,2][3,4][5,6]]", "[[2,4][6,8][10,12]]");
+  assert_parsed_expression_evaluates_to<double>("(3+𝐢)×[[1,2+𝐢][3,4][5,6]]", "[[3+𝐢,5+5×𝐢][9+3×𝐢,12+4×𝐢][15+5×𝐢,18+6×𝐢]]");
+  assert_parsed_expression_evaluates_to<float>("[[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<double>("[[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");
 }
--- 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));
 }
--- 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<float>("-0.1", "-0.1");
  assert_parsed_expression_evaluates_to<float>("-1.", "-1");
  assert_parsed_expression_evaluates_to<float>("-.1", "-0.1");
-  assert_parsed_expression_evaluates_to<float>("-0E2", "0");
-  assert_parsed_expression_evaluates_to<float>("-0.1E2", "-10");
-  assert_parsed_expression_evaluates_to<float>("-1.E2", "-100");
-  assert_parsed_expression_evaluates_to<float>("-.1E2", "-10");
-  assert_parsed_expression_evaluates_to<float>("-0E-2", "0");
-  assert_parsed_expression_evaluates_to<float>("-0.1E-2", "-0.001");
-  assert_parsed_expression_evaluates_to<float>("-1.E-2", "-0.01");
-  assert_parsed_expression_evaluates_to<float>("-.1E-2", "-0.001");
+  assert_parsed_expression_evaluates_to<float>("-0ᴇ2", "0");
+  assert_parsed_expression_evaluates_to<float>("-0.1ᴇ2", "-10");
+  assert_parsed_expression_evaluates_to<float>("-1.ᴇ2", "-100");
+  assert_parsed_expression_evaluates_to<float>("-.1ᴇ2", "-10");
+  assert_parsed_expression_evaluates_to<float>("-0ᴇ-2", "0");
+  assert_parsed_expression_evaluates_to<float>("-0.1ᴇ-2", "-0.001");
+  assert_parsed_expression_evaluates_to<float>("-1.ᴇ-2", "-0.01");
+  assert_parsed_expression_evaluates_to<float>("-.1ᴇ-2", "-0.001");

  assert_parsed_expression_evaluates_to<float>("-2-3", "-5");
-  assert_parsed_expression_evaluates_to<float>("1.2*X^(1)", "3.261938");
-  assert_parsed_expression_evaluates_to<float>("2X^(3)", "40.1711", System, Radian, Cartesian, 6); // WARNING: the 7th significant digit is wrong on blackbos simulator
-  assert_parsed_expression_evaluates_to<float>("X^2*X^(1)", "20.0855", System, Radian, Cartesian, 6); // WARNING: the 7th significant digit is wrong on simulator
-  assert_parsed_expression_evaluates_to<double>("X^2*X^(1)", "20.085536923188");
-  assert_parsed_expression_evaluates_to<double>("2*3^4+2", "164");
-  assert_parsed_expression_evaluates_to<float>("-2*3^4+2", "-160");
-  assert_parsed_expression_evaluates_to<double>("-sin(3)*2-3", "-3.2822400161197", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("1.2×ℯ^(1)", "3.261938");
+  assert_parsed_expression_evaluates_to<float>("2ℯ^(3)", "40.1711", System, Radian, Cartesian, 6); // WARNING: the 7th significant digit is wrong on blackbos simulator
+  assert_parsed_expression_evaluates_to<float>("ℯ^2×ℯ^(1)", "20.0855", System, Radian, Cartesian, 6); // WARNING: the 7th significant digit is wrong on simulator
+  assert_parsed_expression_evaluates_to<double>("ℯ^2×ℯ^(1)", "20.085536923188");
+  assert_parsed_expression_evaluates_to<double>("2×3^4+2", "164");
+  assert_parsed_expression_evaluates_to<float>("-2×3^4+2", "-160");
+  assert_parsed_expression_evaluates_to<double>("-sin(3)×2-3", "-3.2822400161197", System, Radian);
  assert_parsed_expression_evaluates_to<float>("-.003", "-0.003");
-  assert_parsed_expression_evaluates_to<double>(".02E2", "2");
+  assert_parsed_expression_evaluates_to<double>(".02ᴇ2", "2");
  assert_parsed_expression_evaluates_to<float>("5-2/3", "4.333333");
  assert_parsed_expression_evaluates_to<double>("2/3-5", "-4.3333333333333");
  assert_parsed_expression_evaluates_to<float>("-2/3-5", "-5.666667");
  assert_parsed_expression_evaluates_to<double>("sin(3)2(4+2)", "1.6934400967184", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("4/2*(2+3)", "10");
-  assert_parsed_expression_evaluates_to<double>("4/2*(2+3)", "10");
+  assert_parsed_expression_evaluates_to<float>("4/2×(2+3)", "10");
+  assert_parsed_expression_evaluates_to<double>("4/2×(2+3)", "10");
 }
--- 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<float>("2^3", "8");
-  assert_parsed_expression_evaluates_to<double>("(3+I)^4", "28+96*I");
-  assert_parsed_expression_evaluates_to<float>("4^(3+I)", "11.74125+62.91378*I");
-  assert_parsed_expression_evaluates_to<double>("(3+I)^(3+I)", "-11.898191759852+19.592921596609*I");
+  assert_parsed_expression_evaluates_to<double>("(3+𝐢)^4", "28+96×𝐢");
+  assert_parsed_expression_evaluates_to<float>("4^(3+𝐢)", "11.74125+62.91378×𝐢");
+  assert_parsed_expression_evaluates_to<double>("(3+𝐢)^(3+𝐢)", "-11.898191759852+19.592921596609×𝐢");

  assert_parsed_expression_evaluates_to<double>("0^0", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("0^2", "0");
  assert_parsed_expression_evaluates_to<double>("0^(-2)", Undefined::Name());
-  assert_parsed_expression_evaluates_to<double>("(-2)^4.2", "14.8690638497+10.8030072384*I", System, Radian, Cartesian, 12);
+
+  assert_parsed_expression_evaluates_to<double>("(-2)^4.2", "14.8690638497+10.8030072384×𝐢", System, Radian, Cartesian, 12);
  assert_parsed_expression_evaluates_to<double>("(-0.1)^4", "0.0001", System, Radian, Cartesian, 12);
+
 #if MATRICES_ARE_DEFINED
  assert_parsed_expression_evaluates_to<float>("[[1,2][3,4]]^(-3)", "[[-14.75,6.75][10.125,-4.625]]", System, Degree, Cartesian, 6);
  assert_parsed_expression_evaluates_to<double>("[[1,2][3,4]]^3", "[[37,54][81,118]]");
 #endif
  assert_parsed_expression_evaluates_to<float>("0^2", "0");
-  assert_parsed_expression_evaluates_to<double>("I^I", "2.0787957635076E-1");
+  assert_parsed_expression_evaluates_to<double>("𝐢^𝐢", "2.0787957635076ᴇ-1");
  assert_parsed_expression_evaluates_to<float>("1.0066666666667^60", "1.48985", System, Radian, Cartesian, 6);
  assert_parsed_expression_evaluates_to<double>("1.0066666666667^60", "1.4898457083046");
-  assert_parsed_expression_evaluates_to<float>("X^(I*P)", "-1");
-  assert_parsed_expression_evaluates_to<double>("X^(I*P)", "-1");
-  assert_parsed_expression_evaluates_to<float>("X^(I*P+2)", "-7.38906", System, Radian, Cartesian, 6);
-  assert_parsed_expression_evaluates_to<double>("X^(I*P+2)", "-7.3890560989307");
-  assert_parsed_expression_evaluates_to<float>("(-1)^(1/3)", "0.5+0.8660254*I");
-  assert_parsed_expression_evaluates_to<double>("(-1)^(1/3)", "0.5+8.6602540378444E-1*I");
-  assert_parsed_expression_evaluates_to<float>("X^(I*P/3)", "0.5+0.8660254*I");
-  assert_parsed_expression_evaluates_to<double>("X^(I*P/3)", "0.5+8.6602540378444E-1*I");
-  assert_parsed_expression_evaluates_to<float>("I^(2/3)", "0.5+0.8660254*I");
-  assert_parsed_expression_evaluates_to<double>("I^(2/3)", "0.5+8.6602540378444E-1*I");
+  assert_parsed_expression_evaluates_to<float>("ℯ^(𝐢×π)", "-1");
+  assert_parsed_expression_evaluates_to<double>("ℯ^(𝐢×π)", "-1");
+  assert_parsed_expression_evaluates_to<float>("ℯ^(𝐢×π+2)", "-7.38906", System, Radian, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<double>("ℯ^(𝐢×π+2)", "-7.3890560989307");
+  assert_parsed_expression_evaluates_to<float>("(-1)^(1/3)", "0.5+0.8660254×𝐢");
+  assert_parsed_expression_evaluates_to<double>("(-1)^(1/3)", "0.5+8.6602540378444ᴇ-1×𝐢");
+  assert_parsed_expression_evaluates_to<float>("ℯ^(𝐢×π/3)", "0.5+0.8660254×𝐢");
+  assert_parsed_expression_evaluates_to<double>("ℯ^(𝐢×π/3)", "0.5+8.6602540378444ᴇ-1×𝐢");
+  assert_parsed_expression_evaluates_to<float>("𝐢^(2/3)", "0.5+0.8660254×𝐢");
+  assert_parsed_expression_evaluates_to<double>("𝐢^(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);
 }
--- 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);
 }
--- 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<float>("1/3", "0.3333333");
-  assert_parsed_expression_evaluates_to<double>("123456/1234567", "9.9999432999586E-2");
+  assert_parsed_expression_evaluates_to<double>("123456/1234567", "9.9999432999586ᴇ-2");
 }


--- 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?

 }
--- 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<float>("1+42>A", "43");
-  assert_parsed_expression_evaluates_to<double>("0.123+I>B", "0.123+I");
+  assert_parsed_expression_evaluates_to<float>("1+42→A", "43");
+  assert_parsed_expression_evaluates_to<double>("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<double>("[[7]]>a", "[[7]]");
-  assert_parsed_expression_simplify_to("1+1>a", "2");
+  assert_parsed_expression_evaluates_to<double>("[[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<double>("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<double>("g(4)", "-1");
  assert_parsed_expression_evaluates_to<double>("f(4)", "0");

--- 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<float>("1-2", "-1");
-  assert_parsed_expression_evaluates_to<double>("3+I-(4+I)", "-1");
+  assert_parsed_expression_evaluates_to<double>("3+𝐢-(4+𝐢)", "-1");

 #if MATRICES_ARE_DEFINED
  assert_parsed_expression_evaluates_to<float>("[[1,2][3,4][5,6]]-3", "[[-2,-1][0,1][2,3]]");
-  assert_parsed_expression_evaluates_to<double>("[[1,2+I][3,4][5,6]]-(4+I)", "[[-3-I,-2][-1-I,-I][1-I,2-I]]");
+  assert_parsed_expression_evaluates_to<double>("[[1,2+𝐢][3,4][5,6]]-(4+𝐢)", "[[-3-𝐢,-2][-1-𝐢,-𝐢][1-𝐢,2-𝐢]]");
  assert_parsed_expression_evaluates_to<float>("3-[[1,2][3,4][5,6]]", "[[2,1][0,-1][-2,-3]]");
-  assert_parsed_expression_evaluates_to<double>("3+I-[[1,2+I][3,4][5,6]]", "[[2+I,1][I,-1+I][-2+I,-3+I]]");
+  assert_parsed_expression_evaluates_to<double>("3+𝐢-[[1,2+𝐢][3,4][5,6]]", "[[2+𝐢,1][𝐢,-1+𝐢][-2+𝐢,-3+𝐢]]");
  assert_parsed_expression_evaluates_to<float>("[[1,2][3,4][5,6]]-[[6,5][4,3][2,1]]", "[[-5,-3][-1,1][3,5]]");
-  assert_parsed_expression_evaluates_to<double>("[[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<double>("[[1,2+𝐢][3,4][5,6]]-[[1,2+𝐢][3,4][5,6]]", "[[0,0][0,0][0,0]]");
 #endif
 }
--- 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<double>("P", "3.1415926535898");
-  assert_parsed_expression_evaluates_to<float>("X", "2.718282");
-  assert_parsed_expression_evaluates_to<double>("1.2E3", "1200");
+  assert_parsed_expression_evaluates_to<double>("π", "3.1415926535898");
+  assert_parsed_expression_evaluates_to<float>("ℯ", "2.718282");
+  assert_parsed_expression_evaluates_to<double>("1.2ᴇ3", "1200");
 }

--- 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<double>("cos(2)", "-4.1614683654714E-1", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("cos(2)", "-4.1614683654714ᴇ-1", System, Radian);
  assert_parsed_expression_evaluates_to<double>("cos(2)", "0.9993908270191", System, Degree);
  // Oscillator
-  assert_parsed_expression_evaluates_to<float>("cos(P/2)", "0", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("cos(3*P/2)", "0", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("cos(3*P)", "-1", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("cos(π/2)", "0", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("cos(3×π/2)", "0", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("cos(3×π)", "-1", System, Radian);
  assert_parsed_expression_evaluates_to<float>("cos(-540)", "-1", System, Degree);
-  // On R*i
-  assert_parsed_expression_evaluates_to<double>("cos(-2*I)", "3.7621956910836", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("cos(-2*I)", "1.0006092967033", System, Degree);
+  // On R×i
+  assert_parsed_expression_evaluates_to<double>("cos(-2×𝐢)", "3.7621956910836", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("cos(-2×𝐢)", "1.0006092967033", System, Degree);
  // Symmetry: even
-  assert_parsed_expression_evaluates_to<double>("cos(2*I)", "3.7621956910836", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("cos(2*I)", "1.0006092967033", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("cos(2×𝐢)", "3.7621956910836", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("cos(2×𝐢)", "1.0006092967033", System, Degree);
  // On C
-  assert_parsed_expression_evaluates_to<float>("cos(I-4)", "-1.008625-0.8893952*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("cos(I-4)", "0.997716+0.00121754*I", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("cos(𝐢-4)", "-1.008625-0.8893952×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("cos(𝐢-4)", "0.997716+0.00121754×𝐢", System, Degree, Cartesian, 6);

  /* sin: R  ->  R (oscillator)
   *      Ri ->  Ri (odd)
   */
  // On R
-  assert_parsed_expression_evaluates_to<double>("sin(2)", "9.0929742682568E-1", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("sin(2)", "3.4899496702501E-2", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("sin(2)", "9.0929742682568ᴇ-1", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("sin(2)", "3.4899496702501ᴇ-2", System, Degree);
  // Oscillator
-  assert_parsed_expression_evaluates_to<float>("sin(P/2)", "1", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("sin(3*P/2)", "-1", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("sin(3*P)", "0", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("sin(π/2)", "1", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("sin(3×π/2)", "-1", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("sin(3×π)", "0", System, Radian);
  assert_parsed_expression_evaluates_to<float>("sin(-540)", "0", System, Degree);
-  // On R*i
-  assert_parsed_expression_evaluates_to<double>("sin(3*I)", "10.01787492741*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("sin(3*I)", "0.05238381*I", System, Degree);
+  // On R×i
+  assert_parsed_expression_evaluates_to<double>("sin(3×𝐢)", "10.01787492741×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("sin(3×𝐢)", "0.05238381×𝐢", System, Degree);
  // Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("sin(-3*I)", "-10.01787492741*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("sin(-3*I)", "-0.05238381*I", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("sin(-3×𝐢)", "-10.01787492741×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("sin(-3×𝐢)", "-0.05238381×𝐢", System, Degree);
  // On: C
-  assert_parsed_expression_evaluates_to<float>("sin(I-4)", "1.16781-0.768163*I", System, Radian, Cartesian, 6);
-  assert_parsed_expression_evaluates_to<float>("sin(I-4)", "-0.0697671+0.0174117*I", System, Degree, Cartesian, 6);
-  assert_parsed_expression_evaluates_to<float>("sin(1.234567890123456E-15)", "1.23457E-15", System, Radian, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("sin(𝐢-4)", "1.16781-0.768163×𝐢", System, Radian, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("sin(𝐢-4)", "-0.0697671+0.0174117×𝐢", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("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<double>("tan(2)", "-2.1850398632615", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("tan(2)", "3.4920769491748E-2", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("tan(2)", "3.4920769491748ᴇ-2", System, Degree);
  // Tangent-style
-  assert_parsed_expression_evaluates_to<float>("tan(P/2)", Undefined::Name(), System, Radian);
-  assert_parsed_expression_evaluates_to<double>("tan(3*P/2)", Undefined::Name(), System, Radian);
-  assert_parsed_expression_evaluates_to<float>("tan(3*P)", "0", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("tan(π/2)", Undefined::Name(), System, Radian);
+  assert_parsed_expression_evaluates_to<double>("tan(3×π/2)", Undefined::Name(), System, Radian);
+  assert_parsed_expression_evaluates_to<float>("tan(3×π)", "0", System, Radian);
  assert_parsed_expression_evaluates_to<float>("tan(-540)", "0", System, Degree);
-  // On R*i
-  assert_parsed_expression_evaluates_to<double>("tan(-2*I)", "-9.6402758007582E-1*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("tan(-2*I)", "-0.03489241*I", System, Degree);
+  // On R×i
+  assert_parsed_expression_evaluates_to<double>("tan(-2×𝐢)", "-9.6402758007582ᴇ-1×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("tan(-2×𝐢)", "-0.03489241×𝐢", System, Degree);
  // Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("tan(2*I)", "9.6402758007582E-1*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("tan(2*I)", "0.03489241*I", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("tan(2×𝐢)", "9.6402758007582ᴇ-1×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("tan(2×𝐢)", "0.03489241×𝐢", System, Degree);
  // On C
-  assert_parsed_expression_evaluates_to<float>("tan(I-4)", "-0.273553+1.00281*I", System, Radian, Cartesian, 6);
-  assert_parsed_expression_evaluates_to<float>("tan(I-4)", "-0.0699054+0.0175368*I", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("tan(𝐢-4)", "-0.273553+1.00281×𝐢", System, Radian, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("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<double>("acos(0.5)", "1.0471975511966", System, Radian);
  assert_parsed_expression_evaluates_to<double>("acos(0.03)", "1.5407918249714", System, Radian);
  assert_parsed_expression_evaluates_to<double>("acos(0.5)", "60", System, Degree);
  // On [1, inf[
-  assert_parsed_expression_evaluates_to<double>("acos(2)", "1.3169578969248*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("acos(2)", "75.456129290217*I", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("acos(2)", "1.3169578969248×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("acos(2)", "75.456129290217×𝐢", System, Degree);
  // Symmetry: odd on imaginary
-  assert_parsed_expression_evaluates_to<double>("acos(-2)", "3.1415926535898-1.3169578969248*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("acos(-2)", "180-75.456129290217*I", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("acos(-2)", "3.1415926535898-1.3169578969248×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("acos(-2)", "180-75.456129290217×𝐢", System, Degree);
  // On ]-inf, -1[
-  assert_parsed_expression_evaluates_to<double>("acos(-32)", "3.1415926535898-4.1586388532792*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("acos(-32)", "180-238.2725*I", System, Degree);
-  // On R*i
-  assert_parsed_expression_evaluates_to<float>("acos(3*I)", "1.5708-1.8184*I", System, Radian, Cartesian, 5);
-  assert_parsed_expression_evaluates_to<float>("acos(3*I)", "90-104.19*I", System, Degree, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<double>("acos(-32)", "3.1415926535898-4.1586388532792×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("acos(-32)", "180-238.2725×𝐢", System, Degree);
+  // On R×i
+  assert_parsed_expression_evaluates_to<float>("acos(3×𝐢)", "1.5708-1.8184×𝐢", System, Radian, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<float>("acos(3×𝐢)", "90-104.19×𝐢", System, Degree, Cartesian, 5);
  // Symmetry: odd on imaginary
-  assert_parsed_expression_evaluates_to<float>("acos(-3*I)", "1.5708+1.8184*I", System, Radian, Cartesian, 5);
-  assert_parsed_expression_evaluates_to<float>("acos(-3*I)", "90+104.19*I", System, Degree, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<float>("acos(-3×𝐢)", "1.5708+1.8184×𝐢", System, Radian, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<float>("acos(-3×𝐢)", "90+104.19×𝐢", System, Degree, Cartesian, 5);
  // On C
-  assert_parsed_expression_evaluates_to<float>("acos(I-4)", "2.8894-2.0966*I", System, Radian, Cartesian, 5);
-  assert_parsed_expression_evaluates_to<float>("acos(I-4)", "165.551-120.126*I", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("acos(𝐢-4)", "2.8894-2.0966×𝐢", System, Radian, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<float>("acos(𝐢-4)", "165.551-120.126×𝐢", System, Degree, Cartesian, 6);
  // Key values
  assert_parsed_expression_evaluates_to<double>("acos(0)", "90", System, Degree);
  assert_parsed_expression_evaluates_to<float>("acos(-1)", "180", System, Degree);
  assert_parsed_expression_evaluates_to<double>("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<double>("asin(0.5)", "0.5235987755983", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("asin(0.03)", "3.0004501823477E-2", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("asin(0.03)", "3.0004501823477ᴇ-2", System, Radian);
  assert_parsed_expression_evaluates_to<double>("asin(0.5)", "30", System, Degree);
  // On [1, inf[
-  assert_parsed_expression_evaluates_to<double>("asin(2)", "1.5707963267949-1.3169578969248*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("asin(2)", "90-75.456129290217*I", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("asin(2)", "1.5707963267949-1.3169578969248×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("asin(2)", "90-75.456129290217×𝐢", System, Degree);
  // Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("asin(-2)", "-1.5707963267949+1.3169578969248*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("asin(-2)", "-90+75.456129290217*I", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("asin(-2)", "-1.5707963267949+1.3169578969248×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("asin(-2)", "-90+75.456129290217×𝐢", System, Degree);
  // On ]-inf, -1[
-  assert_parsed_expression_evaluates_to<float>("asin(-32)", "-1.571+4.159*I", System, Radian, Cartesian, 4);
-  assert_parsed_expression_evaluates_to<float>("asin(-32)", "-90+238*I", System, Degree, Cartesian, 3);
-  // On R*i
-  assert_parsed_expression_evaluates_to<double>("asin(3*I)", "1.8184464592321*I", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("asin(-32)", "-1.571+4.159×𝐢", System, Radian, Cartesian, 4);
+  assert_parsed_expression_evaluates_to<float>("asin(-32)", "-90+238×𝐢", System, Degree, Cartesian, 3);
+  // On R×i
+  assert_parsed_expression_evaluates_to<double>("asin(3×𝐢)", "1.8184464592321×𝐢", System, Radian);
  // Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("asin(-3*I)", "-1.8184464592321*I", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("asin(-3×𝐢)", "-1.8184464592321×𝐢", System, Radian);
  // On C
-  assert_parsed_expression_evaluates_to<float>("asin(I-4)", "-1.3186+2.0966*I", System, Radian, Cartesian, 5);
-  assert_parsed_expression_evaluates_to<float>("asin(I-4)", "-75.551+120.13*I", System, Degree, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<float>("asin(𝐢-4)", "-1.3186+2.0966×𝐢", System, Radian, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<float>("asin(𝐢-4)", "-75.551+120.13×𝐢", System, Degree, Cartesian, 5);
  // Key values
  assert_parsed_expression_evaluates_to<double>("asin(0)", "0", System, Degree);
  assert_parsed_expression_evaluates_to<float>("asin(-1)", "-90", System, Degree);
  assert_parsed_expression_evaluates_to<double>("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<double>("atan(2)", "1.1071487177941", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("atan(0.01)", "9.9996666866652E-3", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("atan(0.01)", "9.9996666866652ᴇ-3", System, Radian);
  assert_parsed_expression_evaluates_to<double>("atan(2)", "63.434948822922", System, Degree);
  assert_parsed_expression_evaluates_to<float>("atan(0.5)", "0.4636476", System, Radian);
  // Symmetry: odd
  assert_parsed_expression_evaluates_to<double>("atan(-2)", "-1.1071487177941", System, Radian);
-  // On [-i, i]
-  assert_parsed_expression_evaluates_to<float>("atan(0.2*I)", "0.202733*I", System, Radian, Cartesian, 6);
+  // On [-𝐢, 𝐢]
+  assert_parsed_expression_evaluates_to<float>("atan(0.2×𝐢)", "0.202733×𝐢", System, Radian, Cartesian, 6);
  // Symmetry: odd
-  assert_parsed_expression_evaluates_to<float>("atan(-0.2*I)", "-0.202733*I", System, Radian, Cartesian, 6);
-  // On [i, inf*i[
-  assert_parsed_expression_evaluates_to<double>("atan(26*I)", "1.5707963267949+3.8480520568064E-2*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("atan(26*I)", "90+2.2047714220164*I", System, Degree);
+  assert_parsed_expression_evaluates_to<float>("atan(-0.2×𝐢)", "-0.202733×𝐢", System, Radian, Cartesian, 6);
+  // On [𝐢, inf×𝐢[
+  assert_parsed_expression_evaluates_to<double>("atan(26×𝐢)", "1.5707963267949+3.8480520568064ᴇ-2×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("atan(26×𝐢)", "90+2.2047714220164×𝐢", System, Degree);
  // Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("atan(-26*I)", "-1.5707963267949-3.8480520568064E-2*I", System, Radian);
-  // On ]-inf*i, -i[
-  assert_parsed_expression_evaluates_to<float>("atan(-3.4*I)", "-1.570796-0.3030679*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("atan(-3.4*I)", "-90-17.3645*I", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<double>("atan(-26×𝐢)", "-1.5707963267949-3.8480520568064ᴇ-2×𝐢", System, Radian);
+  // On ]-inf×𝐢, -𝐢[
+  assert_parsed_expression_evaluates_to<float>("atan(-3.4×𝐢)", "-1.570796-0.3030679×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("atan(-3.4×𝐢)", "-90-17.3645×𝐢", System, Degree, Cartesian, 6);
  // On C
-  assert_parsed_expression_evaluates_to<float>("atan(I-4)", "-1.338973+0.05578589*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("atan(I-4)", "-76.7175+3.1963*I", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("atan(𝐢-4)", "-1.338973+0.05578589×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("atan(𝐢-4)", "-76.7175+3.1963×𝐢", System, Degree, Cartesian, 6);
  // Key values
  assert_parsed_expression_evaluates_to<float>("atan(0)", "0", System, Degree);
-  assert_parsed_expression_evaluates_to<double>("atan(-I)", "-inf*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("atan(I)", "inf*I", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("atan(-𝐢)", "-inf×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("atan(𝐢)", "inf×𝐢", System, Radian);

  /* cosh: R         -> R (even)
-   *       R*i       -> R (oscillator)
+   *       R×𝐢       -> R (oscillator)
   */
  // On R
  assert_parsed_expression_evaluates_to<double>("cosh(2)", "3.7621956910836", System, Radian);
@@ -189,90 +189,90 @@ QUIZ_CASE(poincare_trigo_evaluate) {
  // Symmetry: even
  assert_parsed_expression_evaluates_to<double>("cosh(-2)", "3.7621956910836", System, Radian);
  assert_parsed_expression_evaluates_to<double>("cosh(-2)", "3.7621956910836", System, Degree);
-  // On R*i
-  assert_parsed_expression_evaluates_to<double>("cosh(43*I)", "5.5511330152063E-1", System, Radian);
+  // On R×𝐢
+  assert_parsed_expression_evaluates_to<double>("cosh(43×𝐢)", "5.5511330152063ᴇ-1", System, Radian);
  // Oscillator
-  assert_parsed_expression_evaluates_to<float>("cosh(P*I/2)", "0", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("cosh(5*P*I/2)", "0", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("cosh(8*P*I/2)", "1", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("cosh(9*P*I/2)", "0", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("cosh(π×𝐢/2)", "0", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("cosh(5×π×𝐢/2)", "0", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("cosh(8×π×𝐢/2)", "1", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("cosh(9×π×𝐢/2)", "0", System, Radian);
  // On C
-  assert_parsed_expression_evaluates_to<float>("cosh(I-4)", "14.7547-22.9637*I", System, Radian, Cartesian, 6);
-  assert_parsed_expression_evaluates_to<float>("cosh(I-4)", "14.7547-22.9637*I", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("cosh(𝐢-4)", "14.7547-22.9637×𝐢", System, Radian, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("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<double>("sinh(2)", "3.626860407847", System, Radian);
  assert_parsed_expression_evaluates_to<double>("sinh(2)", "3.626860407847", System, Degree);
  // Symmetry: odd
  assert_parsed_expression_evaluates_to<double>("sinh(-2)", "-3.626860407847", System, Radian);
-  // On R*i
-  assert_parsed_expression_evaluates_to<double>("sinh(43*I)", "-0.8317747426286*I", System, Radian);
+  // On R×𝐢
+  assert_parsed_expression_evaluates_to<double>("sinh(43×𝐢)", "-0.8317747426286×𝐢", System, Radian);
  // Oscillator
-  assert_parsed_expression_evaluates_to<float>("sinh(P*I/2)", "I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("sinh(5*P*I/2)", "I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("sinh(7*P*I/2)", "-I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("sinh(8*P*I/2)", "0", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("sinh(9*P*I/2)", "I", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("sinh(π×𝐢/2)", "𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("sinh(5×π×𝐢/2)", "𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("sinh(7×π×𝐢/2)", "-𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("sinh(8×π×𝐢/2)", "0", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("sinh(9×π×𝐢/2)", "𝐢", System, Radian);
  // On C
-  assert_parsed_expression_evaluates_to<float>("sinh(I-4)", "-14.7448+22.9791*I", System, Radian, Cartesian, 6);
-  assert_parsed_expression_evaluates_to<float>("sinh(I-4)", "-14.7448+22.9791*I", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("sinh(𝐢-4)", "-14.7448+22.9791×𝐢", System, Radian, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("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<double>("tanh(2)", "9.6402758007582E-1", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("tanh(2)", "9.6402758007582ᴇ-1", System, Radian);
  // Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("tanh(-2)", "-9.6402758007582E-1", System, Degree);
-  // On R*i
-  assert_parsed_expression_evaluates_to<double>("tanh(43*I)", "-1.4983873388552*I", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("tanh(-2)", "-9.6402758007582ᴇ-1", System, Degree);
+  // On R×i
+  assert_parsed_expression_evaluates_to<double>("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<float>("tanh(P*I/2)", Undefined::Name(), System, Radian);
-  assert_parsed_expression_evaluates_to<float>("tanh(5*P*I/2)", Undefined::Name(), System, Radian);
-  assert_parsed_expression_evaluates_to<float>("tanh(7*P*I/2)", Undefined::Name(), System, Radian);
-  assert_parsed_expression_evaluates_to<float>("tanh(8*P*I/2)", "0", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("tanh(9*P*I/2)", Undefined::Name(), System, Radian);*/
+  /*assert_parsed_expression_evaluates_to<float>("tanh(π×𝐢/2)", Undefined::Name(), System, Radian);
+  assert_parsed_expression_evaluates_to<float>("tanh(5×π×𝐢/2)", Undefined::Name(), System, Radian);
+  assert_parsed_expression_evaluates_to<float>("tanh(7×π×𝐢/2)", Undefined::Name(), System, Radian);
+  assert_parsed_expression_evaluates_to<float>("tanh(8×π×𝐢/2)", "0", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("tanh(9×π×𝐢/2)", Undefined::Name(), System, Radian);*/
  // On C
-  assert_parsed_expression_evaluates_to<float>("tanh(I-4)", "-1.00028+0.000610241*I", System, Radian, Cartesian, 6);
-  assert_parsed_expression_evaluates_to<float>("tanh(I-4)", "-1.00028+0.000610241*I", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("tanh(𝐢-4)", "-1.00028+0.000610241×𝐢", System, Radian, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("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<double>("acosh(2)", "1.3169578969248", System, Radian);
  assert_parsed_expression_evaluates_to<double>("acosh(2)", "1.3169578969248", System, Degree);
  // On ]-inf, -1[
-  assert_parsed_expression_evaluates_to<double>("acosh(-4)", "2.0634370688956+3.1415926535898*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("acosh(-4)", "2.06344+3.14159*I", System, Radian, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<double>("acosh(-4)", "2.0634370688956+3.1415926535898×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("acosh(-4)", "2.06344+3.14159×𝐢", System, Radian, Cartesian, 6);
  // On ]1,inf[: Symmetry: even on real
  assert_parsed_expression_evaluates_to<double>("acosh(4)", "2.0634370688956", System, Radian);
  assert_parsed_expression_evaluates_to<float>("acosh(4)", "2.063437", System, Radian);
-  // On ]-inf*i, 0[
-  assert_parsed_expression_evaluates_to<double>("acosh(-42*I)", "4.4309584920805-1.5707963267949*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("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<double>("acosh(42*I)", "4.4309584920805+1.5707963267949*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("acosh(42*I)", "4.431+1.571*I", System, Radian, Cartesian, 4);
+  // On ]-inf×𝐢, 0[
+  assert_parsed_expression_evaluates_to<double>("acosh(-42×𝐢)", "4.4309584920805-1.5707963267949×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("acosh(-42×𝐢)", "4.431-1.571×𝐢", System, Radian, Cartesian, 4);
+  // On ]0, 𝐢×inf[: Symmetry: even on real
+  assert_parsed_expression_evaluates_to<double>("acosh(42×𝐢)", "4.4309584920805+1.5707963267949×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("acosh(42×𝐢)", "4.431+1.571×𝐢", System, Radian, Cartesian, 4);
  // On C
-  assert_parsed_expression_evaluates_to<float>("acosh(I-4)", "2.0966+2.8894*I", System, Radian, Cartesian, 5);
-  assert_parsed_expression_evaluates_to<float>("acosh(I-4)", "2.0966+2.8894*I", System, Degree, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<float>("acosh(𝐢-4)", "2.0966+2.8894×𝐢", System, Radian, Cartesian, 5);
+  assert_parsed_expression_evaluates_to<float>("acosh(𝐢-4)", "2.0966+2.8894×𝐢", System, Degree, Cartesian, 5);
  // Key values
-  //assert_parsed_expression_evaluates_to<double>("acosh(-1)", "3.1415926535898*I", System, Radian);
+  //assert_parsed_expression_evaluates_to<double>("acosh(-1)", "3.1415926535898×𝐢", System, Radian);
  assert_parsed_expression_evaluates_to<double>("acosh(1)", "0", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("acosh(0)", "1.570796*I", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("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<double>("asinh(2)", "1.4436354751788", System, Radian);
@@ -280,26 +280,26 @@ QUIZ_CASE(poincare_trigo_evaluate) {
  // Symmetry: odd
  assert_parsed_expression_evaluates_to<double>("asinh(-2)", "-1.4436354751788", System, Radian);
  assert_parsed_expression_evaluates_to<double>("asinh(-2)", "-1.4436354751788", System, Degree);
-  // On [-i,i]
-  assert_parsed_expression_evaluates_to<double>("asinh(0.2*I)", "2.0135792079033E-1*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("asinh(0.2*I)", "0.2013579*I", System, Degree);
+  // On [-𝐢,𝐢]
+  assert_parsed_expression_evaluates_to<double>("asinh(0.2×𝐢)", "2.0135792079033ᴇ-1×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("asinh(0.2×𝐢)", "0.2013579×𝐢", System, Degree);
  // Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("asinh(-0.2*I)", "-2.0135792079033E-1*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("asinh(-0.2*I)", "-0.2013579*I", System, Degree);
-  // On ]-inf*i, -i[
-  assert_parsed_expression_evaluates_to<double>("asinh(-22*I)", "-3.7836727043295-1.5707963267949*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("asinh(-22*I)", "-3.784-1.571*I", System, Degree, Cartesian, 4);
-  // On ]i, inf*i[, Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("asinh(22*I)", "3.7836727043295+1.5707963267949*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("asinh(22*I)", "3.784+1.571*I", System, Degree, Cartesian, 4);
+  assert_parsed_expression_evaluates_to<double>("asinh(-0.2×𝐢)", "-2.0135792079033ᴇ-1×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("asinh(-0.2×𝐢)", "-0.2013579×𝐢", System, Degree);
+  // On ]-inf×𝐢, -𝐢[
+  assert_parsed_expression_evaluates_to<double>("asinh(-22×𝐢)", "-3.7836727043295-1.5707963267949×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("asinh(-22×𝐢)", "-3.784-1.571×𝐢", System, Degree, Cartesian, 4);
+  // On ]𝐢, inf×𝐢[, Symmetry: odd
+  assert_parsed_expression_evaluates_to<double>("asinh(22×𝐢)", "3.7836727043295+1.5707963267949×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("asinh(22×𝐢)", "3.784+1.571×𝐢", System, Degree, Cartesian, 4);
  // On C
-  assert_parsed_expression_evaluates_to<float>("asinh(I-4)", "-2.123+0.2383*I", System, Radian, Cartesian, 4);
-  assert_parsed_expression_evaluates_to<float>("asinh(I-4)", "-2.123+0.2383*I", System, Degree, Cartesian, 4);
+  assert_parsed_expression_evaluates_to<float>("asinh(𝐢-4)", "-2.123+0.2383×𝐢", System, Radian, Cartesian, 4);
+  assert_parsed_expression_evaluates_to<float>("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<double>("atanh(0.4)", "0.4236489301936", System, Radian);
@@ -308,66 +308,66 @@ QUIZ_CASE(poincare_trigo_evaluate) {
  assert_parsed_expression_evaluates_to<double>("atanh(-0.4)", "-0.4236489301936", System, Radian);
  assert_parsed_expression_evaluates_to<double>("atanh(-0.4)", "-0.4236489301936", System, Degree);
  // On ]1, inf[
-  assert_parsed_expression_evaluates_to<double>("atanh(4)", "0.255412811883-1.5707963267949*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("atanh(4)", "0.2554128-1.570796*I", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("atanh(4)", "0.255412811883-1.5707963267949×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("atanh(4)", "0.2554128-1.570796×𝐢", System, Degree);
  // On ]-inf,-1[, Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("atanh(-4)", "-0.255412811883+1.5707963267949*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("atanh(-4)", "-0.2554128+1.570796*I", System, Degree);
-  // On R*i
-  assert_parsed_expression_evaluates_to<double>("atanh(4*I)", "1.325817663668*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("atanh(4*I)", "1.325818*I", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("atanh(-4)", "-0.255412811883+1.5707963267949×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("atanh(-4)", "-0.2554128+1.570796×𝐢", System, Degree);
+  // On R×𝐢
+  assert_parsed_expression_evaluates_to<double>("atanh(4×𝐢)", "1.325817663668×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("atanh(4×𝐢)", "1.325818×𝐢", System, Radian);
  // Symmetry: odd
-  assert_parsed_expression_evaluates_to<double>("atanh(-4*I)", "-1.325817663668*I", System, Radian);
-  assert_parsed_expression_evaluates_to<float>("atanh(-4*I)", "-1.325818*I", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("atanh(-4×𝐢)", "-1.325817663668×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<float>("atanh(-4×𝐢)", "-1.325818×𝐢", System, Radian);
  // On C
-  assert_parsed_expression_evaluates_to<float>("atanh(I-4)", "-0.238878+1.50862*I", System, Radian, Cartesian, 6);
-  assert_parsed_expression_evaluates_to<float>("atanh(I-4)", "-0.238878+1.50862*I", System, Degree, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("atanh(𝐢-4)", "-0.238878+1.50862×𝐢", System, Radian, Cartesian, 6);
+  assert_parsed_expression_evaluates_to<float>("atanh(𝐢-4)", "-0.238878+1.50862×𝐢", System, Degree, Cartesian, 6);

  // WARNING: evaluate on branch cut can be multivalued
-  assert_parsed_expression_evaluates_to<double>("acos(2)", "1.3169578969248*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("acos(2)", "75.456129290217*I", System, Degree);
-  assert_parsed_expression_evaluates_to<double>("asin(2)", "1.5707963267949-1.3169578969248*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("asin(2)", "90-75.456129290217*I", System, Degree);
-  assert_parsed_expression_evaluates_to<double>("atanh(2)", "5.4930614433405E-1-1.5707963267949*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("atan(2I)", "1.5707963267949+5.4930614433405E-1*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("atan(2I)", "90+31.472923730945*I", System, Degree);
-  assert_parsed_expression_evaluates_to<double>("asinh(2I)", "1.3169578969248+1.5707963267949*I", System, Radian);
-  assert_parsed_expression_evaluates_to<double>("acosh(-2)", "1.3169578969248+3.1415926535898*I", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("acos(2)", "1.3169578969248×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("acos(2)", "75.456129290217×𝐢", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("asin(2)", "1.5707963267949-1.3169578969248×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("asin(2)", "90-75.456129290217×𝐢", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("atanh(2)", "5.4930614433405ᴇ-1-1.5707963267949×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("atan(2𝐢)", "1.5707963267949+5.4930614433405ᴇ-1×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("atan(2𝐢)", "90+31.472923730945×𝐢", System, Degree);
+  assert_parsed_expression_evaluates_to<double>("asinh(2𝐢)", "1.3169578969248+1.5707963267949×𝐢", System, Radian);
+  assert_parsed_expression_evaluates_to<double>("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);
 }
--- 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<double>("a", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("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<double>("a", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("b", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("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<double>("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<double>("g(1)", "3");
  assert_parsed_expression_evaluates_to<double>("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<double>("f(1)", "2");
  assert_parsed_expression_evaluates_to<double>("g(1)", "3");
  assert_parsed_expression_evaluates_to<double>("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<double>("f(1)", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("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<double>("f(1)", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("g(1)", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("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<double>("f(1)", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("a", Undefined::Name());
  assert_parsed_expression_evaluates_to<double>("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<double>("f(2)", "4");
  assert_parsed_expression_evaluates_to<double>("g(3)", "1");
  assert_parsed_expression_evaluates_to<double>("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<double>("g(3)+[[1]]", "[[18]]");
  assert_parsed_expression_evaluates_to<double>("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<double>("f(g(4))", "25");
  // Add a matrix to bypass simplification
  assert_parsed_expression_evaluates_to<double>("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<double>("[[1]]>a", "[[1]]");
+  assert_parsed_expression_evaluates_to<double>("[[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<double>("[[x]]>f(x)", "[[undef]]");
+
+  assert_parsed_expression_evaluates_to<double>("[[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));

--- 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");
 }