diff --git a/poincare/test/approximation.cpp b/poincare/test/approximation.cpp
index b1307d595..ec896ab7f 100644
--- a/poincare/test/approximation.cpp
+++ b/poincare/test/approximation.cpp
@@ -420,26 +420,23 @@ QUIZ_CASE(poincare_approximation_function) {
   assert_expression_approximates_to<double>("transpose([[1,7,5][4,2,8]])", "[[1,4][7,2][5,8]]");
   assert_expression_approximates_to<double>("transpose([[1,2][4,5][7,8]])", "[[1,4,7][2,5,8]]");
 
-  /* Results for ref depend on the implementation. In any case :
-   * - Rows with only zeros must be at the bottom.
-   * - Leading coefficient of other rows must be to the right (strictly) of the
-   * - one above.
-   * - (Optional, but sometimes recommended) Leading coefficients must be 1. */
   assert_expression_approximates_to<double>("ref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,1.4,1.2,1.6][0,1,1.1,1.2][0,0,1,1.2215568862275]]");
   assert_expression_approximates_to<double>("rref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,0,0,3.3532934131737ᴇ-1][0,1,0,-0.1437125748503][0,0,1,1.2215568862275]]");
-  assert_expression_approximates_to<double>("ref([[1,0][5,6][0,10]])", "[[1,1.2][0,1][0,0]]");
-  assert_expression_approximates_to<double>("rref([[1,0][5,6][0,10]])", "[[1,0][0,1][0,0]]");
-  assert_expression_approximates_to<double>("ref([[0,0][0,0][0,0]])", "[[0,0][0,0][0,0]]");
-  assert_expression_approximates_to<double>("rref([[0,0][0,0][0,0]])", "[[0,0][0,0][0,0]]");
   assert_expression_approximates_to<double>("ref([[0,2,-1][5,6,7][12,11,10]])", "[[1,9.1666666666667ᴇ-1,8.3333333333333ᴇ-1][0,1,-0.5][0,0,1]]");
   assert_expression_approximates_to<double>("rref([[0,2,-1][5,6,7][12,11,10]])", "[[1,0,0][0,1,0][0,0,1]]");
-  assert_expression_approximates_to<double>("ref([[3,9][2,5]])", "[[1,3][0,1]]");
-  assert_expression_approximates_to<double>("ref([[3,2][5,7]])", "[[1,1.4][0,1]]");
-  assert_expression_approximates_to<double>("ref([[3,11][5,7]])", "[[1,1.4][0,1]]");
-  assert_expression_approximates_to<double>("ref([[2,5][2,7]])", "[[1,2.5][0,1]]");
-  assert_expression_approximates_to<double>("ref([[3,12][-4,1]])", "[[1,-0.25][0,1]]");
-  assert_expression_approximates_to<double>("ref([[0,1][1ᴇ-100,1]])", "[[1,1ᴇ100][0,1]]");
-  assert_expression_approximates_to<double>("rref([[0,1][1ᴇ-100,1]])", "[[1,0][0,1]]");
+  assert_expression_approximates_to<float>("ref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,1.4,1.2,1.6][0,1,1.1,1.2][0,0,1,1.221557]]");
+  assert_expression_approximates_to<float>("rref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,0,0,0.3353293][0,1,0,-0.1437126][0,0,1,1.221557]]");
+  assert_expression_approximates_to<float>("ref([[0,2,-1][5,6,7][12,11,10]])", "[[1,0.9166667,0.8333333][0,1,-0.5][0,0,1]]");
+  assert_expression_approximates_to<float>("rref([[0,2,-1][5,6,7][12,11,10]])", "[[1,0,0][0,1,0][0,0,1]]");
+
+  assert_expression_approximates_to<float>("cross([[1][2][3]],[[4][7][8]])", "[[-5][4][-1]]");
+  assert_expression_approximates_to<double>("cross([[1][2][3]],[[4][7][8]])", "[[-5][4][-1]]");
+
+  assert_expression_approximates_to<float>("dot([[1][2][3]],[[4][7][8]])", "42");
+  assert_expression_approximates_to<double>("dot([[1][2][3]],[[4][7][8]])", "42");
+
+  assert_expression_approximates_to<float>("norm([[-5][4][-1]])", "6.480741");
+  assert_expression_approximates_to<double>("norm([[-5][4][-1]])", "6.4807406984079");
 
   assert_expression_approximates_to<float>("round(2.3246,3)", "2.325");
   assert_expression_approximates_to<double>("round(2.3245,3)", "2.325");
diff --git a/poincare/test/expression_properties.cpp b/poincare/test/expression_properties.cpp
index b9570c996..cc3d11c4d 100644
--- a/poincare/test/expression_properties.cpp
+++ b/poincare/test/expression_properties.cpp
@@ -65,6 +65,7 @@ QUIZ_CASE(poincare_properties_is_matrix) {
   assert_expression_has_property("transpose([[1,2][3,4]])", &context, Expression::IsMatrix);
   assert_expression_has_property("ref([[1,2][3,4]])", &context, Expression::IsMatrix);
   assert_expression_has_property("rref([[1,2][3,4]])", &context, Expression::IsMatrix);
+  assert_expression_has_property("cross([[1][2][3]],[[3][4][5]])", &context, Expression::IsMatrix);
   assert_expression_has_not_property("2*3+1", &context, Expression::IsMatrix);
 }
 
diff --git a/poincare/test/parsing.cpp b/poincare/test/parsing.cpp
index b62ab6571..c40c05c99 100644
--- a/poincare/test/parsing.cpp
+++ b/poincare/test/parsing.cpp
@@ -365,12 +365,14 @@ QUIZ_CASE(poincare_parsing_identifiers) {
   assert_parsed_expression_is("binomial(2,1)", BinomialCoefficient::Builder(BasedInteger::Builder(2),BasedInteger::Builder(1)));
   assert_parsed_expression_is("ceil(1)", Ceiling::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("confidence(1,2)", ConfidenceInterval::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("cross(1,1)", VectorCross::Builder(BasedInteger::Builder(1),BasedInteger::Builder(1)));
   assert_text_not_parsable("diff(1,2,3)");
   assert_text_not_parsable("diff(0,_s,0)");
   assert_parsed_expression_is("diff(1,x,3)", Derivative::Builder(BasedInteger::Builder(1),Symbol::Builder("x",1),BasedInteger::Builder(3)));
   assert_parsed_expression_is("dim(1)", MatrixDimension::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("conj(1)", Conjugate::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("det(1)", Determinant::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("dot(1,1)", VectorDot::Builder(BasedInteger::Builder(1),BasedInteger::Builder(1)));
   assert_parsed_expression_is("cos(1)", Cosine::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("cosh(1)", HyperbolicCosine::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("factor(1)", Factor::Builder(BasedInteger::Builder(1)));
@@ -393,6 +395,7 @@ QUIZ_CASE(poincare_parsing_identifiers) {
   assert_parsed_expression_is("log{2}(1)", Logarithm::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
   assert_parsed_expression_is("permute(2,1)", PermuteCoefficient::Builder(BasedInteger::Builder(2),BasedInteger::Builder(1)));
   assert_parsed_expression_is("prediction95(1,2)", PredictionInterval::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("norm(1)", VectorNorm::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("prediction(1,2)", SimplePredictionInterval::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
   assert_parsed_expression_is("product(1,n,2,3)", Product::Builder(BasedInteger::Builder(1),Symbol::Builder("n",1),BasedInteger::Builder(2),BasedInteger::Builder(3)));
   assert_text_not_parsable("product(1,2,3,4)");
@@ -401,9 +404,11 @@ QUIZ_CASE(poincare_parsing_identifiers) {
   assert_parsed_expression_is("random()", Random::Builder());
   assert_parsed_expression_is("randint(1,2)", Randint::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
   assert_parsed_expression_is("re(1)", RealPart::Builder(BasedInteger::Builder(1)));
+  assert_parsed_expression_is("ref(1)", MatrixRowEchelonForm::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("rem(1,2)", DivisionRemainder::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
   assert_parsed_expression_is("root(1,2)", NthRoot::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
   assert_parsed_expression_is("round(1,2)", Round::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
+  assert_parsed_expression_is("rref(1)", MatrixReducedRowEchelonForm::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("sin(1)", Sine::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("sign(1)", SignFunction::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("sinh(1)", HyperbolicSine::Builder(BasedInteger::Builder(1)));
@@ -414,8 +419,6 @@ QUIZ_CASE(poincare_parsing_identifiers) {
   assert_parsed_expression_is("tanh(1)", HyperbolicTangent::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("trace(1)", MatrixTrace::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("transpose(1)", MatrixTranspose::Builder(BasedInteger::Builder(1)));
-  assert_parsed_expression_is("ref(1)", MatrixRowEchelonForm::Builder(BasedInteger::Builder(1)));
-  assert_parsed_expression_is("rref(1)", MatrixReducedRowEchelonForm::Builder(BasedInteger::Builder(1)));
   assert_parsed_expression_is("√(1)", SquareRoot::Builder(BasedInteger::Builder(1)));
   assert_text_not_parsable("cos(1,2)");
   assert_text_not_parsable("log(1,2,3)");
diff --git a/poincare/test/simplification.cpp b/poincare/test/simplification.cpp
index 27b796303..0a7f4e947 100644
--- a/poincare/test/simplification.cpp
+++ b/poincare/test/simplification.cpp
@@ -381,10 +381,12 @@ QUIZ_CASE(poincare_simplification_units) {
   assert_parsed_expression_simplify_to("conj(_s)", "undef");
   assert_parsed_expression_simplify_to("cos(_s)", "undef");
   assert_parsed_expression_simplify_to("cosh(_s)", "undef");
+  assert_parsed_expression_simplify_to("cross(_s,[[1][2][3]])", "undef");
   assert_parsed_expression_simplify_to("det(_s)", "undef");
   assert_parsed_expression_simplify_to("diff(_s,x,0)", "undef");
   assert_parsed_expression_simplify_to("diff(0,x,_s)", "undef");
   assert_parsed_expression_simplify_to("dim(_s)", "undef");
+  assert_parsed_expression_simplify_to("dot(_s,[[1][2][3]])", "undef");
   assert_parsed_expression_simplify_to("factor(_s)", "undef");
   assert_parsed_expression_simplify_to("(_s)!", "undef");
   assert_parsed_expression_simplify_to("floor(_s)", "undef");
@@ -411,6 +413,7 @@ QUIZ_CASE(poincare_simplification_units) {
   assert_parsed_expression_simplify_to("log(_s)", "undef");
   assert_parsed_expression_simplify_to("log(_s,2)", "undef");
   assert_parsed_expression_simplify_to("log(1,_s)", "undef");
+  assert_parsed_expression_simplify_to("norm(_s)", "undef");
   assert_parsed_expression_simplify_to("normcdf(_s,2,3)", "undef");
   assert_parsed_expression_simplify_to("normcdf(2,_s,3)", "undef");
   assert_parsed_expression_simplify_to("normcdf(2,3,_s)", "undef");
@@ -435,10 +438,12 @@ QUIZ_CASE(poincare_simplification_units) {
   assert_parsed_expression_simplify_to("randint(_s,1)", "undef");
   assert_parsed_expression_simplify_to("randint(1,_s)", "undef");
   assert_parsed_expression_simplify_to("re(_s)", "undef");
+  assert_parsed_expression_simplify_to("ref(_s)", "undef");
   assert_parsed_expression_simplify_to("rem(_s,1)", "undef");
   assert_parsed_expression_simplify_to("rem(1,_s)", "undef");
   assert_parsed_expression_simplify_to("round(_s,1)", "undef");
   assert_parsed_expression_simplify_to("round(1,_s)", "undef");
+  assert_parsed_expression_simplify_to("rref(_s)", "undef");
   assert_parsed_expression_simplify_to("sign(_s)", "undef");
   assert_parsed_expression_simplify_to("sin(_s)", "undef");
   assert_parsed_expression_simplify_to("sinh(_s)", "undef");
@@ -449,8 +454,6 @@ QUIZ_CASE(poincare_simplification_units) {
   assert_parsed_expression_simplify_to("tanh(_s)", "undef");
   assert_parsed_expression_simplify_to("trace(_s)", "undef");
   assert_parsed_expression_simplify_to("transpose(_s)", "undef");
-  assert_parsed_expression_simplify_to("ref(_s)", "undef");
-  assert_parsed_expression_simplify_to("rref(_s)", "undef");
 
   /* Valid expressions */
   assert_parsed_expression_simplify_to("-2×_A", "-2×_A");
@@ -960,6 +963,37 @@ QUIZ_CASE(poincare_simplification_matrix) {
   assert_parsed_expression_simplify_to("ref([[1,0,√(4)][0,1,1/√(2)][0,0,1]])", "[[1,0,2][0,1,√(2)/2][0,0,1]]");
   assert_parsed_expression_simplify_to("rref([[1,0,√(4)][0,1,1/√(2)][0,0,0]])", "[[1,0,2][0,1,√(2)/2][0,0,0]]");
   assert_parsed_expression_simplify_to("ref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,7/5,6/5,8/5][0,1,11/10,6/5][0,0,1,204/167]]");
+  assert_parsed_expression_simplify_to("ref([[1,0][5,6][0,10]])", "[[1,6/5][0,1][0,0]]");
+  assert_parsed_expression_simplify_to("rref([[1,0][5,6][0,10]])", "[[1,0][0,1][0,0]]");
+  assert_parsed_expression_simplify_to("ref([[0,0][0,0][0,0]])", "[[0,0][0,0][0,0]]");
+  assert_parsed_expression_simplify_to("rref([[0,0][0,0][0,0]])", "[[0,0][0,0][0,0]]");
+  assert_parsed_expression_simplify_to("rref([[0,1][1ᴇ-100,1]])", "[[1,0][0,1]]");
+  /* Results for ref depend on the implementation. In any case :
+   * - Rows with only zeros must be at the bottom.
+   * - Leading coefficient of other rows must be to the right (strictly) of the
+   * - one above.
+   * - (Optional, but sometimes recommended) Leading coefficients must be 1. */
+  assert_parsed_expression_simplify_to("ref([[3,9][2,5]])", "[[1,3][0,1]]");
+  assert_parsed_expression_simplify_to("ref([[3,2][5,7]])", "[[1,7/5][0,1]]");
+  assert_parsed_expression_simplify_to("ref([[3,11][5,7]])", "[[1,7/5][0,1]]");
+  assert_parsed_expression_simplify_to("ref([[2,5][2,7]])", "[[1,5/2][0,1]]");
+  assert_parsed_expression_simplify_to("ref([[3,12][-4,1]])", "[[1,-1/4][0,1]]");
+  assert_parsed_expression_simplify_to("ref([[0,1][1ᴇ-100,1]])", "[[1,10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000][0,1]]");
+
+  // Cross product
+  assert_parsed_expression_simplify_to("cross([[0][1/√(2)][0]],[[0][0][1]])", "[[√(2)/2][0][0]]");
+  assert_parsed_expression_simplify_to("cross([[1][2][3]],[[4][7][8]])", "[[-5][4][-1]]");
+  assert_parsed_expression_simplify_to("cross([[1][π][𝐢]],[[𝐢π][𝐢π^2][-π]])", "[[0][0][0]]");
+
+  // Dot product
+  assert_parsed_expression_simplify_to("dot([[1/√(2)][0][0]],[[1][0][0]])", "√(2)/2");
+  assert_parsed_expression_simplify_to("dot([[1][1][0]],[[0][0][1]])", "0");
+  assert_parsed_expression_simplify_to("dot([[1][1][1]],[[0][π][𝐢]])", "π+𝐢");
+
+  // Vector norm
+  assert_parsed_expression_simplify_to("norm([[1/√(2)][0][0]])", "√(2)/2");
+  assert_parsed_expression_simplify_to("norm([[1][2][3]])", "√(14)");
+  assert_parsed_expression_simplify_to("norm([[1][𝐢+1][π][-5]])", "√(π^2+28)");
 
   // Expressions with unreduced matrix
   assert_reduce("confidence(cos(2)/25,3)→a");