diff --git a/apps/calculation/calculation.cpp b/apps/calculation/calculation.cpp
index 72a9ba3cf..399e6dd89 100644
--- a/apps/calculation/calculation.cpp
+++ b/apps/calculation/calculation.cpp
@@ -70,7 +70,7 @@ void Calculation::setContent(const char * c, Context * context) {
   m_exactOutput = input()->clone();
   Expression::Simplify(&m_exactOutput, *context);
   m_exactOutput->writeTextInBuffer(m_exactOutputText, sizeof(m_exactOutputText));
-  m_approximateOutput = m_exactOutput->evaluate<double>(*context);
+  m_approximateOutput = m_exactOutput->approximate<double>(*context);
   m_approximateOutput->writeTextInBuffer(m_approximateOutputText, sizeof(m_approximateOutputText));
 }
 
@@ -189,7 +189,7 @@ Expression * Calculation::approximateOutput(Context * context) {
      * call 'evaluate'. */
     Expression * exp = Expression::parse(m_approximateOutputText);
     if (exp != nullptr) {
-      m_approximateOutput = exp->evaluate<double>(*context);
+      m_approximateOutput = exp->approximate<double>(*context);
       delete exp;
     } else {
       m_approximateOutput = new Complex<double>(Complex<double>::Float(NAN));
diff --git a/apps/probability/law/binomial_law.cpp b/apps/probability/law/binomial_law.cpp
index b1adcdee3..5f973b4b4 100644
--- a/apps/probability/law/binomial_law.cpp
+++ b/apps/probability/law/binomial_law.cpp
@@ -102,7 +102,7 @@ double BinomialLaw::rightIntegralInverseForProbability(double * probability) {
 }
 
 template<typename T>
-T BinomialLaw::templatedEvaluateAtAbscissa(T x) const {
+T BinomialLaw::templatedApproximateAtAbscissa(T x) const {
   if (m_parameter1 == 0) {
     if (m_parameter2 == 0 || m_parameter2 == 1) {
       return NAN;
@@ -134,5 +134,5 @@ T BinomialLaw::templatedEvaluateAtAbscissa(T x) const {
 
 }
 
-template float Probability::BinomialLaw::templatedEvaluateAtAbscissa(float x) const;
-template double Probability::BinomialLaw::templatedEvaluateAtAbscissa(double x) const;
+template float Probability::BinomialLaw::templatedApproximateAtAbscissa(float x) const;
+template double Probability::BinomialLaw::templatedApproximateAtAbscissa(double x) const;
diff --git a/apps/probability/law/binomial_law.h b/apps/probability/law/binomial_law.h
index 2e81fa6cd..54efc013a 100644
--- a/apps/probability/law/binomial_law.h
+++ b/apps/probability/law/binomial_law.h
@@ -18,16 +18,16 @@ public:
   I18n::Message parameterNameAtIndex(int index) override;
   I18n::Message parameterDefinitionAtIndex(int index) override;
   float evaluateAtAbscissa(float x) const override {
-    return templatedEvaluateAtAbscissa(x);
+    return templatedApproximateAtAbscissa(x);
   }
   bool authorizedValueAtIndex(float x, int index) const override;
   double cumulativeDistributiveInverseForProbability(double * probability) override;
   double rightIntegralInverseForProbability(double * probability) override;
 protected:
   double evaluateAtDiscreteAbscissa(int k) const override {
-    return templatedEvaluateAtAbscissa((double)k);
+    return templatedApproximateAtAbscissa((double)k);
   }
-  template<typename T> T templatedEvaluateAtAbscissa(T x) const;
+  template<typename T> T templatedApproximateAtAbscissa(T x) const;
 };
 
 }
diff --git a/apps/probability/law/poisson_law.cpp b/apps/probability/law/poisson_law.cpp
index fe1369d32..4cafce3e4 100644
--- a/apps/probability/law/poisson_law.cpp
+++ b/apps/probability/law/poisson_law.cpp
@@ -63,7 +63,7 @@ bool PoissonLaw::authorizedValueAtIndex(float x, int index) const {
 }
 
 template<typename T>
-T PoissonLaw::templatedEvaluateAtAbscissa(T x) const {
+T PoissonLaw::templatedApproximateAtAbscissa(T x) const {
   if (x < 0) {
     return NAN;
   }
@@ -73,5 +73,5 @@ T PoissonLaw::templatedEvaluateAtAbscissa(T x) const {
 
 }
 
-template float Probability::PoissonLaw::templatedEvaluateAtAbscissa(float x) const;
-template double Probability::PoissonLaw::templatedEvaluateAtAbscissa(double x) const;
+template float Probability::PoissonLaw::templatedApproximateAtAbscissa(float x) const;
+template double Probability::PoissonLaw::templatedApproximateAtAbscissa(double x) const;
diff --git a/apps/probability/law/poisson_law.h b/apps/probability/law/poisson_law.h
index d78399e51..3ae372a1b 100644
--- a/apps/probability/law/poisson_law.h
+++ b/apps/probability/law/poisson_law.h
@@ -18,14 +18,14 @@ public:
   I18n::Message parameterNameAtIndex(int index) override;
   I18n::Message parameterDefinitionAtIndex(int index) override;
   float evaluateAtAbscissa(float x) const override {
-    return templatedEvaluateAtAbscissa(x);
+    return templatedApproximateAtAbscissa(x);
   }
   bool authorizedValueAtIndex(float x, int index) const override;
 private:
   double evaluateAtDiscreteAbscissa(int k) const override {
-    return templatedEvaluateAtAbscissa((double)k);
+    return templatedApproximateAtAbscissa((double)k);
   }
-  template<typename T> T templatedEvaluateAtAbscissa(T x) const;
+  template<typename T> T templatedApproximateAtAbscissa(T x) const;
 };
 
 }
diff --git a/apps/sequence/sequence.cpp b/apps/sequence/sequence.cpp
index 3f1089d03..7993e8c03 100644
--- a/apps/sequence/sequence.cpp
+++ b/apps/sequence/sequence.cpp
@@ -267,7 +267,7 @@ bool Sequence::isEmpty() {
 }
 
 template<typename T>
-T Sequence::templatedEvaluateAtAbscissa(T x, Poincare::Context * context) const {
+T Sequence::templatedApproximateAtAbscissa(T x, Poincare::Context * context) const {
   T n = std::round(x);
   switch (m_type) {
     case Type::Explicite:
diff --git a/apps/sequence/sequence.h b/apps/sequence/sequence.h
index c14687fbf..6cc16b383 100644
--- a/apps/sequence/sequence.h
+++ b/apps/sequence/sequence.h
@@ -39,10 +39,10 @@ public:
   bool isDefined() override;
   bool isEmpty() override;
   float evaluateAtAbscissa(float x, Poincare::Context * context) const override {
-    return templatedEvaluateAtAbscissa(x, context);
+    return templatedApproximateAtAbscissa(x, context);
   }
   double evaluateAtAbscissa(double x, Poincare::Context * context) const override {
-    return templatedEvaluateAtAbscissa(x, context);
+    return templatedApproximateAtAbscissa(x, context);
   }
   double sumOfTermsBetweenAbscissa(double start, double end, Poincare::Context * context);
   void tidy() override;
@@ -52,7 +52,7 @@ private:
   constexpr static size_t k_dataLengthInBytes = (3*TextField::maxBufferSize()+3)*sizeof(char)+1;
   static_assert((k_dataLengthInBytes & 0x3) == 0, "The sequence data size is not a multiple of 4 bytes (cannot compute crc)"); // Assert that dataLengthInBytes is a multiple of 4
   char symbol() const override;
-  template<typename T> T templatedEvaluateAtAbscissa(T x, Poincare::Context * context) const;
+  template<typename T> T templatedApproximateAtAbscissa(T x, Poincare::Context * context) const;
   Type m_type;
   char m_firstInitialConditionText[TextField::maxBufferSize()];
   char m_secondInitialConditionText[TextField::maxBufferSize()];
diff --git a/apps/shared/function.cpp b/apps/shared/function.cpp
index ffe6b113b..a4e64108d 100644
--- a/apps/shared/function.cpp
+++ b/apps/shared/function.cpp
@@ -100,7 +100,7 @@ bool Function::isEmpty() {
 }
 
 template<typename T>
-T Function::templatedEvaluateAtAbscissa(T x, Poincare::Context * context) const {
+T Function::templatedApproximateAtAbscissa(T x, Poincare::Context * context) const {
   Poincare::VariableContext<T> variableContext = Poincare::VariableContext<T>(symbol(), context);
   Poincare::Symbol xSymbol(symbol());
   Poincare::Complex<T> e = Poincare::Complex<T>::Float(x);
@@ -121,5 +121,5 @@ void Function::tidy() {
 
 }
 
-template float Shared::Function::templatedEvaluateAtAbscissa<float>(float, Poincare::Context*) const;
-template double Shared::Function::templatedEvaluateAtAbscissa<double>(double, Poincare::Context*) const;
+template float Shared::Function::templatedApproximateAtAbscissa<float>(float, Poincare::Context*) const;
+template double Shared::Function::templatedApproximateAtAbscissa<double>(double, Poincare::Context*) const;
diff --git a/apps/shared/function.h b/apps/shared/function.h
index 2e6303bfe..6d3adc71f 100644
--- a/apps/shared/function.h
+++ b/apps/shared/function.h
@@ -28,16 +28,16 @@ public:
   virtual void setContent(const char * c);
   void setColor(KDColor m_color);
   virtual float evaluateAtAbscissa(float x, Poincare::Context * context) const {
-    return templatedEvaluateAtAbscissa(x, context);
+    return templatedApproximateAtAbscissa(x, context);
   }
   virtual double evaluateAtAbscissa(double x, Poincare::Context * context) const {
-    return templatedEvaluateAtAbscissa(x, context);
+    return templatedApproximateAtAbscissa(x, context);
   }
   virtual void tidy();
 private:
   constexpr static size_t k_dataLengthInBytes = (TextField::maxBufferSize()+2)*sizeof(char)+2;
   static_assert((k_dataLengthInBytes & 0x3) == 0, "The function data size is not a multiple of 4 bytes (cannot compute crc)"); // Assert that dataLengthInBytes is a multiple of 4
-  template<typename T> T templatedEvaluateAtAbscissa(T x, Poincare::Context * context) const;
+  template<typename T> T templatedApproximateAtAbscissa(T x, Poincare::Context * context) const;
   virtual char symbol() const = 0;
   mutable Poincare::Expression * m_expression;
   char m_text[TextField::maxBufferSize()];
diff --git a/poincare/Makefile b/poincare/Makefile
index 80bf9006c..a4bd1d233 100644
--- a/poincare/Makefile
+++ b/poincare/Makefile
@@ -25,7 +25,7 @@ objs += $(addprefix poincare/src/,\
   division_quotient.o\
   division_remainder.o\
   dynamic_hierarchy.o\
-  evaluation_engine.o\
+  approximation_engine.o\
   expression.o\
   expression_lexer.o\
   expression_parser.o\
diff --git a/poincare/include/poincare/absolute_value.h b/poincare/include/poincare/absolute_value.h
index e4a6030d5..870facc18 100644
--- a/poincare/include/poincare/absolute_value.h
+++ b/poincare/include/poincare/absolute_value.h
@@ -2,7 +2,7 @@
 #define POINCARE_ABSOLUTE_VALUE_H
 
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 #include <poincare/layout_engine.h>
 
 namespace Poincare {
@@ -24,11 +24,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-  return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+  return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/addition.h b/poincare/include/poincare/addition.h
index 9f2a6a9d5..7652bf7f5 100644
--- a/poincare/include/poincare/addition.h
+++ b/poincare/include/poincare/addition.h
@@ -4,7 +4,7 @@
 #include <poincare/dynamic_hierarchy.h>
 #include <poincare/rational.h>
 #include <poincare/layout_engine.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -19,10 +19,10 @@ public:
   /* Evaluation */
   template<typename T> static Complex<T> compute(const Complex<T> c, const Complex<T> d);
   template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n) {
-    return EvaluationEngine::elementWiseOnComplexMatrices(m, n, compute<T>);
+    return ApproximationEngine::elementWiseOnComplexMatrices(m, n, compute<T>);
   }
   template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * m) {
-    return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
+    return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
   }
 private:
   /* Layout */
@@ -43,13 +43,13 @@ private:
   static bool TermsHaveIdenticalNonRationalFactors(const Expression * e1, const Expression * e2);
   /* Evaluation */
   template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * c) {
-    return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
+    return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
   }
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
    }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
    }
 };
 
diff --git a/poincare/include/poincare/evaluation_engine.h b/poincare/include/poincare/approximation_engine.h
similarity index 93%
rename from poincare/include/poincare/evaluation_engine.h
rename to poincare/include/poincare/approximation_engine.h
index 9d256c101..673aa5226 100644
--- a/poincare/include/poincare/evaluation_engine.h
+++ b/poincare/include/poincare/approximation_engine.h
@@ -1,5 +1,5 @@
-#ifndef POINCARE_EVALUATION_ENGINE_H
-#define POINCARE_EVALUATION_ENGINE_H
+#ifndef POINCARE_APPROXIMATION_ENGINE_H
+#define POINCARE_APPROXIMATION_ENGINE_H
 
 #include <poincare/expression.h>
 #include <poincare/complex.h>
@@ -7,7 +7,7 @@
 
 namespace Poincare {
 
-class EvaluationEngine {
+class ApproximationEngine {
 public:
   template <typename T> using ComplexCompute = Complex<T>(*)(const Complex<T>, Expression::AngleUnit angleUnit);
   template<typename T> static Expression * map(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexCompute<T> compute);
diff --git a/poincare/include/poincare/arc_cosine.h b/poincare/include/poincare/arc_cosine.h
index 81e29eb21..7b27c7e8a 100644
--- a/poincare/include/poincare/arc_cosine.h
+++ b/poincare/include/poincare/arc_cosine.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -27,11 +27,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/arc_sine.h b/poincare/include/poincare/arc_sine.h
index dcceec881..d2d0737ca 100644
--- a/poincare/include/poincare/arc_sine.h
+++ b/poincare/include/poincare/arc_sine.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/arc_tangent.h b/poincare/include/poincare/arc_tangent.h
index b9a34a536..d8fb48580 100644
--- a/poincare/include/poincare/arc_tangent.h
+++ b/poincare/include/poincare/arc_tangent.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/binomial_coefficient.h b/poincare/include/poincare/binomial_coefficient.h
index f0215e7c8..95e562c37 100644
--- a/poincare/include/poincare/binomial_coefficient.h
+++ b/poincare/include/poincare/binomial_coefficient.h
@@ -21,9 +21,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/ceiling.h b/poincare/include/poincare/ceiling.h
index 3bd704e49..e0e1363e2 100644
--- a/poincare/include/poincare/ceiling.h
+++ b/poincare/include/poincare/ceiling.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -23,11 +23,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/complex.h b/poincare/include/poincare/complex.h
index 60bc090e3..c5120e6a8 100644
--- a/poincare/include/poincare/complex.h
+++ b/poincare/include/poincare/complex.h
@@ -67,9 +67,9 @@ private:
   Complex(T a, T b);
   constexpr static int k_numberOfSignificantDigits = 7;
   ExpressionLayout * privateCreateLayout(Expression::FloatDisplayMode floatDisplayMode, Expression::ComplexFormat complexFormat) const override;
-  Expression * privateEvaluate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename U> Complex<U> * templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const;
+  Expression * privateApproximate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename U> Complex<U> * templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const;
   /* We here define the buffer size to write the lengthest float possible.
    * At maximum, the number has 7 significant digits so, in the worst case it
    * has the form -1.999999e-308 (7+7+1 char) (the auto mode is always
diff --git a/poincare/include/poincare/complex_argument.h b/poincare/include/poincare/complex_argument.h
index cee734982..6d7f03659 100644
--- a/poincare/include/poincare/complex_argument.h
+++ b/poincare/include/poincare/complex_argument.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/confidence_interval.h b/poincare/include/poincare/confidence_interval.h
index 72c26f5fd..269a47afd 100644
--- a/poincare/include/poincare/confidence_interval.h
+++ b/poincare/include/poincare/confidence_interval.h
@@ -23,9 +23,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/conjugate.h b/poincare/include/poincare/conjugate.h
index 3bb1754d9..2e199020c 100644
--- a/poincare/include/poincare/conjugate.h
+++ b/poincare/include/poincare/conjugate.h
@@ -2,7 +2,7 @@
 #define POINCARE_CONJUGATE_H
 
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 #include <poincare/layout_engine.h>
 
 namespace Poincare {
@@ -22,11 +22,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/cosine.h b/poincare/include/poincare/cosine.h
index 2c23dc3a9..0fd5e471d 100644
--- a/poincare/include/poincare/cosine.h
+++ b/poincare/include/poincare/cosine.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 #include <poincare/trigonometry.h>
 
 namespace Poincare {
@@ -27,11 +27,11 @@ private:
   /* Simplication */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/decimal.h b/poincare/include/poincare/decimal.h
index 72242b183..823e1c98d 100644
--- a/poincare/include/poincare/decimal.h
+++ b/poincare/include/poincare/decimal.h
@@ -37,9 +37,9 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   Expression * shallowBeautify(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Expression * templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Expression * templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const;
 
   constexpr static int k_maxLength = 10;
   Integer m_mantissa;
diff --git a/poincare/include/poincare/derivative.h b/poincare/include/poincare/derivative.h
index 351fed8a0..c88c18aa4 100644
--- a/poincare/include/poincare/derivative.h
+++ b/poincare/include/poincare/derivative.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
   template<typename T> T growthRateAroundAbscissa(T x, T h, VariableContext<T> variableContext, AngleUnit angleUnit) const;
   template<typename T> T approximateDerivate2(T x, T h, VariableContext<T> xContext, AngleUnit angleUnit) const;
   // TODO: Change coefficients?
diff --git a/poincare/include/poincare/determinant.h b/poincare/include/poincare/determinant.h
index 6bb607695..39ad84723 100644
--- a/poincare/include/poincare/determinant.h
+++ b/poincare/include/poincare/determinant.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/division.h b/poincare/include/poincare/division.h
index 631a2e094..8b114ef98 100644
--- a/poincare/include/poincare/division.h
+++ b/poincare/include/poincare/division.h
@@ -2,7 +2,7 @@
 #define POINCARE_DIVISION_H
 
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 #include <poincare/layout_engine.h>
 
 namespace Poincare {
@@ -27,16 +27,16 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * c) {
-    return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
+    return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
   }
   template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * n);
   template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n);
 
-  virtual Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
+  virtual Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
   }
-  virtual Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
+  virtual Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
   }
 };
 
diff --git a/poincare/include/poincare/division_quotient.h b/poincare/include/poincare/division_quotient.h
index 4c2171187..b9e84b9dd 100644
--- a/poincare/include/poincare/division_quotient.h
+++ b/poincare/include/poincare/division_quotient.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/division_remainder.h b/poincare/include/poincare/division_remainder.h
index 3c4b1dc87..8316ca63a 100644
--- a/poincare/include/poincare/division_remainder.h
+++ b/poincare/include/poincare/division_remainder.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 
 };
 
diff --git a/poincare/include/poincare/expression.h b/poincare/include/poincare/expression.h
index 7cef1dbec..a2150512d 100644
--- a/poincare/include/poincare/expression.h
+++ b/poincare/include/poincare/expression.h
@@ -72,7 +72,7 @@ class Expression {
   friend class SimplificationRoot;
   friend class Sequence;
   friend class Trigonometry;
-  friend class EvaluationEngine;
+  friend class ApproximationEngine;
   friend class SimplificationEngine;
 
 public:
@@ -213,7 +213,7 @@ public:
   /* Evaluation Engine
    * The function evaluate creates a new expression and thus mallocs memory.
    * Do not forget to delete the new expression to avoid leaking. */
-  template<typename T> Expression * evaluate(Context& context, AngleUnit angleUnit = AngleUnit::Default) const;
+  template<typename T> Expression * approximate(Context& context, AngleUnit angleUnit = AngleUnit::Default) const;
   template<typename T> T approximateToScalar(Context& context, AngleUnit angleUnit = AngleUnit::Default) const;
   template<typename T> static T approximateToScalar(const char * text, Context& context, AngleUnit angleUnit = AngleUnit::Default);
 protected:
@@ -267,8 +267,8 @@ private:
     return nullptr;
   }
   /* Evaluation Engine */
-  virtual Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const = 0;
-  virtual Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const = 0;
+  virtual Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const = 0;
+  virtual Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const = 0;
 
   Expression * m_parent;
 };
diff --git a/poincare/include/poincare/factorial.h b/poincare/include/poincare/factorial.h
index 97b80b185..da1109b2a 100644
--- a/poincare/include/poincare/factorial.h
+++ b/poincare/include/poincare/factorial.h
@@ -2,7 +2,7 @@
 #define POINCARE_FACTORIAL_H
 
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -14,11 +14,11 @@ public:
 private:
   constexpr static int k_maxOperandValue = 100;
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
diff --git a/poincare/include/poincare/floor.h b/poincare/include/poincare/floor.h
index 8ad78242a..78bfa51f4 100644
--- a/poincare/include/poincare/floor.h
+++ b/poincare/include/poincare/floor.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -23,11 +23,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/frac_part.h b/poincare/include/poincare/frac_part.h
index 745034d24..21f478c15 100644
--- a/poincare/include/poincare/frac_part.h
+++ b/poincare/include/poincare/frac_part.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/great_common_divisor.h b/poincare/include/poincare/great_common_divisor.h
index 4005715f0..63a5d0d02 100644
--- a/poincare/include/poincare/great_common_divisor.h
+++ b/poincare/include/poincare/great_common_divisor.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/hyperbolic_arc_cosine.h b/poincare/include/poincare/hyperbolic_arc_cosine.h
index 4122a0e20..ccab941bc 100644
--- a/poincare/include/poincare/hyperbolic_arc_cosine.h
+++ b/poincare/include/poincare/hyperbolic_arc_cosine.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/hyperbolic_arc_sine.h b/poincare/include/poincare/hyperbolic_arc_sine.h
index e0ddecba9..25defc87f 100644
--- a/poincare/include/poincare/hyperbolic_arc_sine.h
+++ b/poincare/include/poincare/hyperbolic_arc_sine.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/hyperbolic_arc_tangent.h b/poincare/include/poincare/hyperbolic_arc_tangent.h
index 755394c64..694973778 100644
--- a/poincare/include/poincare/hyperbolic_arc_tangent.h
+++ b/poincare/include/poincare/hyperbolic_arc_tangent.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/hyperbolic_cosine.h b/poincare/include/poincare/hyperbolic_cosine.h
index 31dc054fc..ac543dd48 100644
--- a/poincare/include/poincare/hyperbolic_cosine.h
+++ b/poincare/include/poincare/hyperbolic_cosine.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/hyperbolic_sine.h b/poincare/include/poincare/hyperbolic_sine.h
index 244bb7d5e..b9921d4ea 100644
--- a/poincare/include/poincare/hyperbolic_sine.h
+++ b/poincare/include/poincare/hyperbolic_sine.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/hyperbolic_tangent.h b/poincare/include/poincare/hyperbolic_tangent.h
index e18448eb8..1ca7f1842 100644
--- a/poincare/include/poincare/hyperbolic_tangent.h
+++ b/poincare/include/poincare/hyperbolic_tangent.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/imaginary_part.h b/poincare/include/poincare/imaginary_part.h
index f2f713d74..6ece73ab0 100644
--- a/poincare/include/poincare/imaginary_part.h
+++ b/poincare/include/poincare/imaginary_part.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/integral.h b/poincare/include/poincare/integral.h
index 7c407e69d..f7c7c864f 100644
--- a/poincare/include/poincare/integral.h
+++ b/poincare/include/poincare/integral.h
@@ -22,9 +22,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
   template<typename T>
   struct DetailedResult
   {
diff --git a/poincare/include/poincare/least_common_multiple.h b/poincare/include/poincare/least_common_multiple.h
index d151b9c0d..977cea272 100644
--- a/poincare/include/poincare/least_common_multiple.h
+++ b/poincare/include/poincare/least_common_multiple.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/logarithm.h b/poincare/include/poincare/logarithm.h
index 5b3b0dcef..70c31e83f 100644
--- a/poincare/include/poincare/logarithm.h
+++ b/poincare/include/poincare/logarithm.h
@@ -26,9 +26,9 @@ private:
   Expression * splitInteger(Integer i, bool isDenominator, Context & context, AngleUnit angleUnit);
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/matrix.h b/poincare/include/poincare/matrix.h
index 1ed00cbc6..fd7ea221b 100644
--- a/poincare/include/poincare/matrix.h
+++ b/poincare/include/poincare/matrix.h
@@ -33,9 +33,9 @@ private:
   /* Layout */
   ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
   int m_numberOfRows;
 };
 
diff --git a/poincare/include/poincare/matrix_dimension.h b/poincare/include/poincare/matrix_dimension.h
index a3922e12b..928790558 100644
--- a/poincare/include/poincare/matrix_dimension.h
+++ b/poincare/include/poincare/matrix_dimension.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/matrix_inverse.h b/poincare/include/poincare/matrix_inverse.h
index 7037ebf54..1fbdc7c01 100644
--- a/poincare/include/poincare/matrix_inverse.h
+++ b/poincare/include/poincare/matrix_inverse.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/matrix_trace.h b/poincare/include/poincare/matrix_trace.h
index e54ce0df5..128fe34d6 100644
--- a/poincare/include/poincare/matrix_trace.h
+++ b/poincare/include/poincare/matrix_trace.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/matrix_transpose.h b/poincare/include/poincare/matrix_transpose.h
index 13f27bb00..2be3c90cb 100644
--- a/poincare/include/poincare/matrix_transpose.h
+++ b/poincare/include/poincare/matrix_transpose.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/multiplication.h b/poincare/include/poincare/multiplication.h
index 72d6cf741..64376d5d0 100644
--- a/poincare/include/poincare/multiplication.h
+++ b/poincare/include/poincare/multiplication.h
@@ -3,7 +3,7 @@
 
 #include <poincare/dynamic_hierarchy.h>
 #include <poincare/layout_engine.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -22,7 +22,7 @@ public:
   /* Evaluation */
   template<typename T> static Complex<T> compute(const Complex<T> c, const Complex<T> d);
   template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * m) {
-    return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
+    return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
   }
   template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n);
 private:
@@ -52,13 +52,13 @@ private:
   /* Evaluation */
 
   template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * c) {
-    return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
+    return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
   }
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
   }
 };
 
diff --git a/poincare/include/poincare/naperian_logarithm.h b/poincare/include/poincare/naperian_logarithm.h
index 5034cd456..9991b9a51 100644
--- a/poincare/include/poincare/naperian_logarithm.h
+++ b/poincare/include/poincare/naperian_logarithm.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/nth_root.h b/poincare/include/poincare/nth_root.h
index 3455772d0..facf310e4 100644
--- a/poincare/include/poincare/nth_root.h
+++ b/poincare/include/poincare/nth_root.h
@@ -22,9 +22,9 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> compute(const Complex<T> c, const Complex<T> d);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 
 };
 
diff --git a/poincare/include/poincare/opposite.h b/poincare/include/poincare/opposite.h
index 954409bfc..1c4a0219b 100644
--- a/poincare/include/poincare/opposite.h
+++ b/poincare/include/poincare/opposite.h
@@ -3,7 +3,7 @@
 
 #include <poincare/static_hierarchy.h>
 #include <poincare/layout_engine.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -20,11 +20,11 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit, compute<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit, compute<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, compute<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, compute<double>);
   }
 };
 
diff --git a/poincare/include/poincare/parenthesis.h b/poincare/include/poincare/parenthesis.h
index 93c61a0be..a5a56d291 100644
--- a/poincare/include/poincare/parenthesis.h
+++ b/poincare/include/poincare/parenthesis.h
@@ -21,9 +21,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 
 };
 
diff --git a/poincare/include/poincare/permute_coefficient.h b/poincare/include/poincare/permute_coefficient.h
index 0cf54c594..da3497fa2 100644
--- a/poincare/include/poincare/permute_coefficient.h
+++ b/poincare/include/poincare/permute_coefficient.h
@@ -25,9 +25,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/power.h b/poincare/include/poincare/power.h
index eab93f84a..01175c0d8 100644
--- a/poincare/include/poincare/power.h
+++ b/poincare/include/poincare/power.h
@@ -2,7 +2,7 @@
 #define POINCARE_POWER_H
 
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 #include <poincare/rational.h>
 #include <poincare/multiplication.h>
 
@@ -55,11 +55,11 @@ private:
   template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * n) { return nullptr; }
   template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * d);
   template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n) { return nullptr; }
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
   }
 };
 
diff --git a/poincare/include/poincare/prediction_interval.h b/poincare/include/poincare/prediction_interval.h
index 8018a17b9..7c3875e10 100644
--- a/poincare/include/poincare/prediction_interval.h
+++ b/poincare/include/poincare/prediction_interval.h
@@ -23,9 +23,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/product.h b/poincare/include/poincare/product.h
index 031b85bf7..ba5fe91c5 100644
--- a/poincare/include/poincare/product.h
+++ b/poincare/include/poincare/product.h
@@ -15,12 +15,12 @@ private:
   int emptySequenceValue() const override;
   ExpressionLayout * createSequenceLayoutWithArgumentLayouts(ExpressionLayout * subscriptLayout, ExpressionLayout * superscriptLayout, ExpressionLayout * argumentLayout) const override;
   Expression * evaluateWithNextTerm(DoublePrecision p, Expression * a, Expression * b) const override {
-    return templatedEvaluateWithNextTerm<double>(a, b);
+    return templatedApproximateWithNextTerm<double>(a, b);
   }
   Expression * evaluateWithNextTerm(SinglePrecision p, Expression * a, Expression * b) const override {
-    return templatedEvaluateWithNextTerm<float>(a, b);
+    return templatedApproximateWithNextTerm<float>(a, b);
   }
-  template<typename T> Expression * templatedEvaluateWithNextTerm(Expression * a, Expression * b) const;
+  template<typename T> Expression * templatedApproximateWithNextTerm(Expression * a, Expression * b) const;
 };
 
 }
diff --git a/poincare/include/poincare/rational.h b/poincare/include/poincare/rational.h
index 776298378..52435dc8f 100644
--- a/poincare/include/poincare/rational.h
+++ b/poincare/include/poincare/rational.h
@@ -44,9 +44,9 @@ public:
 private:
   ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
   int writeTextInBuffer(char * buffer, int bufferSize) const override;
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename U> Complex<U> * templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename U> Complex<U> * templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const;
   Expression * shallowBeautify(Context & context, AngleUnit angleUnit) override;
   Expression * setSign(Sign s);
   Expression * setSign(Sign s, Context & context, AngleUnit angleUnit) override {
diff --git a/poincare/include/poincare/real_part.h b/poincare/include/poincare/real_part.h
index bcc7b2424..adfe7f0ee 100644
--- a/poincare/include/poincare/real_part.h
+++ b/poincare/include/poincare/real_part.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -25,11 +25,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/round.h b/poincare/include/poincare/round.h
index b9353bb7a..885dc0a7a 100644
--- a/poincare/include/poincare/round.h
+++ b/poincare/include/poincare/round.h
@@ -24,9 +24,9 @@ private:
   /* Simplification */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Complex */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/include/poincare/sequence.h b/poincare/include/poincare/sequence.h
index 503b5529c..38959bc42 100644
--- a/poincare/include/poincare/sequence.h
+++ b/poincare/include/poincare/sequence.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -17,9 +17,9 @@ private:
   virtual ExpressionLayout * createSequenceLayoutWithArgumentLayouts(ExpressionLayout * subscriptLayout, ExpressionLayout * superscriptLayout, ExpressionLayout * argumentLayout) const = 0;
   virtual const char * name() const = 0;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
   virtual int emptySequenceValue() const = 0;
   virtual Expression * evaluateWithNextTerm(SinglePrecision p, Expression * a, Expression * b) const = 0;
   virtual Expression * evaluateWithNextTerm(DoublePrecision p, Expression * a, Expression * b) const = 0;
diff --git a/poincare/include/poincare/simplification_root.h b/poincare/include/poincare/simplification_root.h
index 033c3e5b9..09e50ac08 100644
--- a/poincare/include/poincare/simplification_root.h
+++ b/poincare/include/poincare/simplification_root.h
@@ -23,11 +23,11 @@ public:
     return nullptr;
   }
   int writeTextInBuffer(char * buffer, int bufferSize) const override { return 0; }
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
     assert(false);
     return nullptr;
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
     assert(false);
     return nullptr;
   }
diff --git a/poincare/include/poincare/sine.h b/poincare/include/poincare/sine.h
index 300b224d6..93fbc4670 100644
--- a/poincare/include/poincare/sine.h
+++ b/poincare/include/poincare/sine.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 #include <poincare/trigonometry.h>
 
 namespace Poincare {
@@ -27,11 +27,11 @@ private:
   /* Simplication */
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/square_root.h b/poincare/include/poincare/square_root.h
index e567363cb..be1ee0094 100644
--- a/poincare/include/poincare/square_root.h
+++ b/poincare/include/poincare/square_root.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -20,11 +20,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 
 };
diff --git a/poincare/include/poincare/store.h b/poincare/include/poincare/store.h
index 4cbc28795..e58d4e961 100644
--- a/poincare/include/poincare/store.h
+++ b/poincare/include/poincare/store.h
@@ -18,9 +18,9 @@ private:
   ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
   int writeTextInBuffer(char * buffer, int bufferSize) const override;
   /* Evalutation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 
   const Symbol * symbol() const { return static_cast<const Symbol *>(operand(1)); }
   const Expression * value() const { return operand(0); }
diff --git a/poincare/include/poincare/subtraction.h b/poincare/include/poincare/subtraction.h
index 2f249b9f1..3c604d651 100644
--- a/poincare/include/poincare/subtraction.h
+++ b/poincare/include/poincare/subtraction.h
@@ -3,7 +3,7 @@
 
 #include <poincare/static_hierarchy.h>
 #include <poincare/layout_engine.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 namespace Poincare {
 
@@ -26,18 +26,18 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * c) {
-    return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
+    return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
   }
   template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * n);
   template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n) {
-    return EvaluationEngine::elementWiseOnComplexMatrices(m, n, compute<T>);
+    return ApproximationEngine::elementWiseOnComplexMatrices(m, n, compute<T>);
   }
 
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
   }
 };
 
diff --git a/poincare/include/poincare/sum.h b/poincare/include/poincare/sum.h
index b4ceff686..854e59d57 100644
--- a/poincare/include/poincare/sum.h
+++ b/poincare/include/poincare/sum.h
@@ -15,12 +15,12 @@ private:
   int emptySequenceValue() const override;
   ExpressionLayout * createSequenceLayoutWithArgumentLayouts(ExpressionLayout * subscriptLayout, ExpressionLayout * superscriptLayout, ExpressionLayout * argumentLayout) const override;
   Expression * evaluateWithNextTerm(DoublePrecision p, Expression * a, Expression * b) const override {
-    return templatedEvaluateWithNextTerm<double>(a, b);
+    return templatedApproximateWithNextTerm<double>(a, b);
   }
   Expression * evaluateWithNextTerm(SinglePrecision p, Expression * a, Expression * b) const override {
-    return templatedEvaluateWithNextTerm<float>(a, b);
+    return templatedApproximateWithNextTerm<float>(a, b);
   }
-  template<typename T> Expression * templatedEvaluateWithNextTerm(Expression * a, Expression * b) const;
+  template<typename T> Expression * templatedApproximateWithNextTerm(Expression * a, Expression * b) const;
 };
 
 }
diff --git a/poincare/include/poincare/symbol.h b/poincare/include/poincare/symbol.h
index d071272bb..f18f9fe9d 100644
--- a/poincare/include/poincare/symbol.h
+++ b/poincare/include/poincare/symbol.h
@@ -44,9 +44,9 @@ private:
   ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
   int writeTextInBuffer(char * buffer, int bufferSize) const override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
- template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+ template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
   const char m_name;
 };
 
diff --git a/poincare/include/poincare/tangent.h b/poincare/include/poincare/tangent.h
index 04f70029e..f201e4c69 100644
--- a/poincare/include/poincare/tangent.h
+++ b/poincare/include/poincare/tangent.h
@@ -3,7 +3,7 @@
 
 #include <poincare/layout_engine.h>
 #include <poincare/static_hierarchy.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 
 
 namespace Poincare {
@@ -26,11 +26,11 @@ private:
   Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
   /* Evaluation */
   template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit = AngleUnit::Radian);
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
   }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
-    return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+    return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
   }
 };
 
diff --git a/poincare/include/poincare/undefined.h b/poincare/include/poincare/undefined.h
index 11154047d..672294b72 100644
--- a/poincare/include/poincare/undefined.h
+++ b/poincare/include/poincare/undefined.h
@@ -15,9 +15,9 @@ private:
   /* Layout */
   ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
   /* Evaluation */
-  Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
-  Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
-  template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
+  Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
+  Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
+  template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
 };
 
 }
diff --git a/poincare/src/evaluation_engine.cpp b/poincare/src/approximation_engine.cpp
similarity index 50%
rename from poincare/src/evaluation_engine.cpp
rename to poincare/src/approximation_engine.cpp
index ddab709b7..da5902d51 100644
--- a/poincare/src/evaluation_engine.cpp
+++ b/poincare/src/approximation_engine.cpp
@@ -1,4 +1,4 @@
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 #include <poincare/matrix.h>
 #include <cmath>
 extern "C" {
@@ -7,9 +7,9 @@ extern "C" {
 
 namespace Poincare {
 
-template<typename T> Expression * EvaluationEngine::map(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexCompute<T> compute) {
+template<typename T> Expression * ApproximationEngine::map(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexCompute<T> compute) {
   assert(expression->numberOfOperands() == 1);
-  Expression * input = expression->operand(0)->evaluate<T>(context, angleUnit);
+  Expression * input = expression->operand(0)->approximate<T>(context, angleUnit);
   Expression * result = nullptr;
   if (input->type() == Expression::Type::Complex) {
     Complex<T> * c = static_cast<Complex<T> *>(input);
@@ -29,11 +29,11 @@ template<typename T> Expression * EvaluationEngine::map(const Expression * expre
   return result;
 }
 
-template<typename T> Expression * EvaluationEngine::mapReduce(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexAndComplexReduction<T> computeOnComplexes, ComplexAndMatrixReduction<T> computeOnComplexAndMatrix, MatrixAndComplexReduction<T> computeOnMatrixAndComplex, MatrixAndMatrixReduction<T> computeOnMatrices) {
-  Expression * result = expression->operand(0)->evaluate<T>(context, angleUnit);
+template<typename T> Expression * ApproximationEngine::mapReduce(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexAndComplexReduction<T> computeOnComplexes, ComplexAndMatrixReduction<T> computeOnComplexAndMatrix, MatrixAndComplexReduction<T> computeOnMatrixAndComplex, MatrixAndMatrixReduction<T> computeOnMatrices) {
+  Expression * result = expression->operand(0)->approximate<T>(context, angleUnit);
   for (int i = 1; i < expression->numberOfOperands(); i++) {
     Expression * intermediateResult = nullptr;
-    Expression * nextOperandEvaluation = expression->operand(i)->evaluate<T>(context, angleUnit);
+    Expression * nextOperandEvaluation = expression->operand(i)->approximate<T>(context, angleUnit);
     if (result->type() == Expression::Type::Complex && nextOperandEvaluation->type() == Expression::Type::Complex) {
       const Complex<T> * c = static_cast<const Complex<T> *>(result);
       const Complex<T> * d = static_cast<const Complex<T> *>(nextOperandEvaluation);
@@ -65,7 +65,7 @@ template<typename T> Expression * EvaluationEngine::mapReduce(const Expression *
   return result;
 }
 
-template<typename T> Matrix * EvaluationEngine::elementWiseOnComplexAndComplexMatrix(const Complex<T> * c, const Matrix * m, ComplexAndComplexReduction<T> computeOnComplexes) {
+template<typename T> Matrix * ApproximationEngine::elementWiseOnComplexAndComplexMatrix(const Complex<T> * c, const Matrix * m, ComplexAndComplexReduction<T> computeOnComplexes) {
   Expression ** operands = new Expression * [m->numberOfRows()*m->numberOfColumns()];
   for (int i = 0; i < m->numberOfOperands(); i++) {
     const Complex<T> * d = static_cast<const Complex<T> *>(m->operand(i));
@@ -76,7 +76,7 @@ template<typename T> Matrix * EvaluationEngine::elementWiseOnComplexAndComplexMa
   return result;
 }
 
-template<typename T> Matrix * EvaluationEngine::elementWiseOnComplexMatrices(const Matrix * m, const Matrix * n, ComplexAndComplexReduction<T> computeOnComplexes) {
+template<typename T> Matrix * ApproximationEngine::elementWiseOnComplexMatrices(const Matrix * m, const Matrix * n, ComplexAndComplexReduction<T> computeOnComplexes) {
   if (m->numberOfRows() != n->numberOfRows() || m->numberOfColumns() != n->numberOfColumns()) {
     return nullptr;
   }
@@ -91,14 +91,14 @@ template<typename T> Matrix * EvaluationEngine::elementWiseOnComplexMatrices(con
   return result;
 }
 
-template Poincare::Expression * Poincare::EvaluationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::EvaluationEngine::ComplexCompute<float> compute);
-template Poincare::Expression * Poincare::EvaluationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::EvaluationEngine::ComplexCompute<double> compute);
-template Poincare::Expression * Poincare::EvaluationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::EvaluationEngine::ComplexAndComplexReduction<float> computeOnComplexes, Poincare::EvaluationEngine::ComplexAndMatrixReduction<float> computeOnComplexAndMatrix, Poincare::EvaluationEngine::MatrixAndComplexReduction<float> computeOnMatrixAndComplex, Poincare::EvaluationEngine::MatrixAndMatrixReduction<float> computeOnMatrices);
-template Poincare::Expression * Poincare::EvaluationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::EvaluationEngine::ComplexAndComplexReduction<double> computeOnComplexes, Poincare::EvaluationEngine::ComplexAndMatrixReduction<double> computeOnComplexAndMatrix, Poincare::EvaluationEngine::MatrixAndComplexReduction<double> computeOnMatrixAndComplex, Poincare::EvaluationEngine::MatrixAndMatrixReduction<double> computeOnMatrices);
-template Poincare::Matrix * Poincare::EvaluationEngine::elementWiseOnComplexAndComplexMatrix<float>(Poincare::Complex<float> const*, const Poincare::Matrix *, Poincare::Complex<float> (*)(Poincare::Complex<float>, Poincare::Complex<float>));
-template Poincare::Matrix* Poincare::EvaluationEngine::elementWiseOnComplexAndComplexMatrix<double>(Poincare::Complex<double> const*, const Poincare::Matrix*, Poincare::Complex<double> (*)(Poincare::Complex<double>, Poincare::Complex<double>));
-template Poincare::Matrix* Poincare::EvaluationEngine::elementWiseOnComplexMatrices<float>(const Poincare::Matrix*, const Poincare::Matrix*, Poincare::Complex<float> (*)(Poincare::Complex<float>, Poincare::Complex<float>));
-template Poincare::Matrix* Poincare::EvaluationEngine::elementWiseOnComplexMatrices<double>(const Poincare::Matrix*, const Poincare::Matrix*, Poincare::Complex<double> (*)(Poincare::Complex<double>, Poincare::Complex<double>));
+template Poincare::Expression * Poincare::ApproximationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexCompute<float> compute);
+template Poincare::Expression * Poincare::ApproximationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexCompute<double> compute);
+template Poincare::Expression * Poincare::ApproximationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexAndComplexReduction<float> computeOnComplexes, Poincare::ApproximationEngine::ComplexAndMatrixReduction<float> computeOnComplexAndMatrix, Poincare::ApproximationEngine::MatrixAndComplexReduction<float> computeOnMatrixAndComplex, Poincare::ApproximationEngine::MatrixAndMatrixReduction<float> computeOnMatrices);
+template Poincare::Expression * Poincare::ApproximationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexAndComplexReduction<double> computeOnComplexes, Poincare::ApproximationEngine::ComplexAndMatrixReduction<double> computeOnComplexAndMatrix, Poincare::ApproximationEngine::MatrixAndComplexReduction<double> computeOnMatrixAndComplex, Poincare::ApproximationEngine::MatrixAndMatrixReduction<double> computeOnMatrices);
+template Poincare::Matrix * Poincare::ApproximationEngine::elementWiseOnComplexAndComplexMatrix<float>(Poincare::Complex<float> const*, const Poincare::Matrix *, Poincare::Complex<float> (*)(Poincare::Complex<float>, Poincare::Complex<float>));
+template Poincare::Matrix* Poincare::ApproximationEngine::elementWiseOnComplexAndComplexMatrix<double>(Poincare::Complex<double> const*, const Poincare::Matrix*, Poincare::Complex<double> (*)(Poincare::Complex<double>, Poincare::Complex<double>));
+template Poincare::Matrix* Poincare::ApproximationEngine::elementWiseOnComplexMatrices<float>(const Poincare::Matrix*, const Poincare::Matrix*, Poincare::Complex<float> (*)(Poincare::Complex<float>, Poincare::Complex<float>));
+template Poincare::Matrix* Poincare::ApproximationEngine::elementWiseOnComplexMatrices<double>(const Poincare::Matrix*, const Poincare::Matrix*, Poincare::Complex<double> (*)(Poincare::Complex<double>, Poincare::Complex<double>));
 
 
 }
diff --git a/poincare/src/binomial_coefficient.cpp b/poincare/src/binomial_coefficient.cpp
index ae2812a92..b1d947a48 100644
--- a/poincare/src/binomial_coefficient.cpp
+++ b/poincare/src/binomial_coefficient.cpp
@@ -83,9 +83,9 @@ ExpressionLayout * BinomialCoefficient::privateCreateLayout(FloatDisplayMode flo
 }
 
 template<typename T>
-Expression * BinomialCoefficient::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * nInput = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * kInput = operand(1)->evaluate<T>(context, angleUnit);
+Expression * BinomialCoefficient::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * nInput = operand(0)->approximate<T>(context, angleUnit);
+  Expression * kInput = operand(1)->approximate<T>(context, angleUnit);
   if (nInput->type() != Type::Complex || kInput->type() != Type::Complex) {
     return new Complex<T>(Complex<T>::Float(NAN));
   }
diff --git a/poincare/src/complex.cpp b/poincare/src/complex.cpp
index 6a40feb18..8ea42b682 100644
--- a/poincare/src/complex.cpp
+++ b/poincare/src/complex.cpp
@@ -248,7 +248,7 @@ ExpressionLayout * Complex<T>::privateCreateLayout(Expression::FloatDisplayMode
 
 template<typename T>
 template<typename U>
-Complex<U> * Complex<T>::templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const {
+Complex<U> * Complex<T>::templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const {
   return new Complex<U>(Complex<U>::Cartesian((U)m_a, (U)m_b));
 }
 
@@ -478,10 +478,10 @@ ExpressionLayout * Complex<T>::createCartesianLayout(Expression::FloatDisplayMod
 
 template class Complex<float>;
 template class Complex<double>;
-template Complex<double>* Complex<double>::templatedEvaluate<double>(Context&, Expression::AngleUnit) const;
-template Complex<float>* Complex<double>::templatedEvaluate<float>(Context&, Expression::AngleUnit) const;
-template Complex<double>* Complex<float>::templatedEvaluate<double>(Context&, Expression::AngleUnit) const;
-template Complex<float>* Complex<float>::templatedEvaluate<float>(Context&, Expression::AngleUnit) const;
+template Complex<double>* Complex<double>::templatedApproximate<double>(Context&, Expression::AngleUnit) const;
+template Complex<float>* Complex<double>::templatedApproximate<float>(Context&, Expression::AngleUnit) const;
+template Complex<double>* Complex<float>::templatedApproximate<double>(Context&, Expression::AngleUnit) const;
+template Complex<float>* Complex<float>::templatedApproximate<float>(Context&, Expression::AngleUnit) const;
 
 }
 
diff --git a/poincare/src/confidence_interval.cpp b/poincare/src/confidence_interval.cpp
index 3ffc36764..3aa587249 100644
--- a/poincare/src/confidence_interval.cpp
+++ b/poincare/src/confidence_interval.cpp
@@ -59,9 +59,9 @@ Expression * ConfidenceInterval::shallowReduce(Context& context, AngleUnit angle
 }
 
 template<typename T>
-Expression * ConfidenceInterval::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * fInput = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * nInput = operand(1)->evaluate<T>(context, angleUnit);
+Expression * ConfidenceInterval::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * fInput = operand(0)->approximate<T>(context, angleUnit);
+  Expression * nInput = operand(1)->approximate<T>(context, angleUnit);
   if (fInput->type() != Type::Complex || nInput->type() != Type::Complex) {
     return new Complex<T>(Complex<T>::Float(NAN));
   }
diff --git a/poincare/src/decimal.cpp b/poincare/src/decimal.cpp
index e7ac92254..8bf643a2a 100644
--- a/poincare/src/decimal.cpp
+++ b/poincare/src/decimal.cpp
@@ -107,7 +107,7 @@ Expression * Decimal::clone() const {
   return new Decimal(m_mantissa, m_exponent);
 }
 
-template<typename T> Expression * Decimal::templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const {
+template<typename T> Expression * Decimal::templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const {
   T m = m_mantissa.approximate<T>();
   int numberOfDigits = numberOfDigitsInMantissaWithoutSign();
   return new Complex<T>(Complex<T>::Float(m*std::pow((T)10.0, (T)(m_exponent-numberOfDigits+1))));
diff --git a/poincare/src/derivative.cpp b/poincare/src/derivative.cpp
index cfea6e23e..cb5b8d75c 100644
--- a/poincare/src/derivative.cpp
+++ b/poincare/src/derivative.cpp
@@ -35,17 +35,17 @@ Expression * Derivative::shallowReduce(Context& context, AngleUnit angleUnit) {
 }
 
 template<typename T>
-Expression * Derivative::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
+Expression * Derivative::templatedApproximate(Context& context, AngleUnit angleUnit) const {
   static T min = sizeof(T) == sizeof(double) ? DBL_MIN : FLT_MIN;
   static T max = sizeof(T) == sizeof(double) ? DBL_MAX : FLT_MAX;
   VariableContext<T> xContext = VariableContext<T>('x', &context);
   Symbol xSymbol('x');
-  Expression * xInput = operand(1)->evaluate<T>(context, angleUnit);
+  Expression * xInput = operand(1)->approximate<T>(context, angleUnit);
   T x = xInput->type() == Type::Complex ? static_cast<Complex<T> *>(xInput)->toScalar() : NAN;
   delete xInput;
   Complex<T> e = Complex<T>::Float(x);
   xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
-  Expression * fInput = operand(0)->evaluate<T>(xContext, angleUnit);
+  Expression * fInput = operand(0)->approximate<T>(xContext, angleUnit);
   T functionValue = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
   delete fInput;
 
@@ -123,12 +123,12 @@ T Derivative::growthRateAroundAbscissa(T x, T h, VariableContext<T> xContext, An
   Symbol xSymbol('x');
   Complex<T> e = Complex<T>::Float(x + h);
   xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
-  Expression * fInput = operand(0)->evaluate<T>(xContext, angleUnit);
+  Expression * fInput = operand(0)->approximate<T>(xContext, angleUnit);
   T expressionPlus = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
   delete fInput;
   e = Complex<T>::Float(x-h);
   xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
-  fInput = operand(0)->evaluate<T>(xContext, angleUnit);
+  fInput = operand(0)->approximate<T>(xContext, angleUnit);
   T expressionMinus = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
   delete fInput;
   return (expressionPlus - expressionMinus)/(2*h);
@@ -139,17 +139,17 @@ T Derivative::approximateDerivate2(T x, T h, VariableContext<T> xContext, AngleU
   Symbol xSymbol('x');
   Complex<T> e = Complex<T>::Float(x + h);
   xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
-  Expression * fInput = operand(0)->evaluate<T>(xContext, angleUnit);
+  Expression * fInput = operand(0)->approximate<T>(xContext, angleUnit);
   T expressionPlus = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
   delete fInput;
   e = Complex<T>::Float(x);
   xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
-  fInput = operand(0)->evaluate<T>(xContext, angleUnit);
+  fInput = operand(0)->approximate<T>(xContext, angleUnit);
   T expression = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
   delete fInput;
   e = Complex<T>::Float(x-h);
   xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
-  fInput = operand(0)->evaluate<T>(xContext, angleUnit);
+  fInput = operand(0)->approximate<T>(xContext, angleUnit);
   T expressionMinus = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
   delete fInput;
   return expressionPlus - 2.0*expression + expressionMinus;
diff --git a/poincare/src/determinant.cpp b/poincare/src/determinant.cpp
index cf19a054a..5f42249da 100644
--- a/poincare/src/determinant.cpp
+++ b/poincare/src/determinant.cpp
@@ -34,8 +34,8 @@ Expression * Determinant::shallowReduce(Context& context, AngleUnit angleUnit) {
 
 // TODO: handle this exactly in shallowReduce for small dimensions.
 template<typename T>
-Expression * Determinant::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * input = operand(0)->evaluate<T>(context, angleUnit);
+Expression * Determinant::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * input = operand(0)->approximate<T>(context, angleUnit);
   Expression * result = nullptr;
   if (input->type() == Type::Complex) {
     result = input->clone();
diff --git a/poincare/src/division_quotient.cpp b/poincare/src/division_quotient.cpp
index 938299b14..23032d0d4 100644
--- a/poincare/src/division_quotient.cpp
+++ b/poincare/src/division_quotient.cpp
@@ -58,9 +58,9 @@ Expression * DivisionQuotient::shallowReduce(Context& context, AngleUnit angleUn
 }
 
 template<typename T>
-Complex<T> * DivisionQuotient::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
+Complex<T> * DivisionQuotient::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
+  Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
   T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
   T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
   delete f1Input;
diff --git a/poincare/src/division_remainder.cpp b/poincare/src/division_remainder.cpp
index ab631b010..bf6157b8a 100644
--- a/poincare/src/division_remainder.cpp
+++ b/poincare/src/division_remainder.cpp
@@ -58,9 +58,9 @@ Expression * DivisionRemainder::shallowReduce(Context& context, AngleUnit angleU
 }
 
 template<typename T>
-Complex<T> * DivisionRemainder::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
+Complex<T> * DivisionRemainder::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
+  Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
   T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
   T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
   delete f1Input;
diff --git a/poincare/src/expression.cpp b/poincare/src/expression.cpp
index 36d3f1544..a8822dace 100644
--- a/poincare/src/expression.cpp
+++ b/poincare/src/expression.cpp
@@ -253,17 +253,17 @@ Expression * Expression::deepBeautify(Context & context, AngleUnit angleUnit) {
 
 /* Evaluation */
 
-template<typename T> Expression * Expression::evaluate(Context& context, AngleUnit angleUnit) const {
+template<typename T> Expression * Expression::approximate(Context& context, AngleUnit angleUnit) const {
   switch (angleUnit) {
     case AngleUnit::Default:
-      return privateEvaluate(T(), context, Preferences::sharedPreferences()->angleUnit());
+      return privateApproximate(T(), context, Preferences::sharedPreferences()->angleUnit());
     default:
-      return privateEvaluate(T(), context, angleUnit);
+      return privateApproximate(T(), context, angleUnit);
   }
 }
 
 template<typename T> T Expression::approximateToScalar(Context& context, AngleUnit angleUnit) const {
-  Expression * evaluation = evaluate<T>(context, angleUnit);
+  Expression * evaluation = approximate<T>(context, angleUnit);
   assert(evaluation->type() == Type::Complex || evaluation->type() == Type::Matrix);
   T result = NAN;
   if (evaluation->type() == Type::Complex) {
@@ -292,8 +292,8 @@ template<typename T> T Expression::epsilon() {
 
 }
 
-template Poincare::Expression * Poincare::Expression::evaluate<double>(Context& context, AngleUnit angleUnit) const;
-template Poincare::Expression * Poincare::Expression::evaluate<float>(Context& context, AngleUnit angleUnit) const;
+template Poincare::Expression * Poincare::Expression::approximate<double>(Context& context, AngleUnit angleUnit) const;
+template Poincare::Expression * Poincare::Expression::approximate<float>(Context& context, AngleUnit angleUnit) const;
 template double Poincare::Expression::approximateToScalar<double>(char const*, Poincare::Context&, Poincare::Expression::AngleUnit);
 template float Poincare::Expression::approximateToScalar<float>(char const*, Poincare::Context&, Poincare::Expression::AngleUnit);
 template double Poincare::Expression::approximateToScalar<double>(Poincare::Context&, Poincare::Expression::AngleUnit) const;
diff --git a/poincare/src/global_context.cpp b/poincare/src/global_context.cpp
index f53998574..a55a4edf4 100644
--- a/poincare/src/global_context.cpp
+++ b/poincare/src/global_context.cpp
@@ -77,7 +77,7 @@ void GlobalContext::setExpressionForSymbolName(const Expression * expression, co
   if (symbol->isMatrixSymbol()) {
     int indexMatrix = symbol->name() - (char)Symbol::SpecialSymbols::M0;
     assert(indexMatrix >= 0 && indexMatrix < k_maxNumberOfMatrixExpressions);
-    Expression * evaluation = expression ? expression->evaluate<double>(context) : nullptr; // evaluate before deleting anything (to be able to evaluate M1+2->M1)
+    Expression * evaluation = expression ? expression->approximate<double>(context) : nullptr; // evaluate before deleting anything (to be able to evaluate M1+2->M1)
     if (m_matrixExpressions[indexMatrix] != nullptr) {
       delete m_matrixExpressions[indexMatrix];
       m_matrixExpressions[indexMatrix] = nullptr;
@@ -95,7 +95,7 @@ void GlobalContext::setExpressionForSymbolName(const Expression * expression, co
   if (index < 0 || index >= k_maxNumberOfScalarExpressions) {
     return;
   }
-  Expression * evaluation = expression ? expression->evaluate<double>(context) : nullptr; // evaluate before deleting anything (to be able to evaluate A+2->A)
+  Expression * evaluation = expression ? expression->approximate<double>(context) : nullptr; // evaluate before deleting anything (to be able to evaluate A+2->A)
   if (m_expressions[index] != nullptr) {
     delete m_expressions[index];
     m_expressions[index] = nullptr;
diff --git a/poincare/src/great_common_divisor.cpp b/poincare/src/great_common_divisor.cpp
index 53494e623..6cd10604c 100644
--- a/poincare/src/great_common_divisor.cpp
+++ b/poincare/src/great_common_divisor.cpp
@@ -57,9 +57,9 @@ Expression * GreatCommonDivisor::shallowReduce(Context& context, AngleUnit angle
 }
 
 template<typename T>
-Complex<T> * GreatCommonDivisor::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
+Complex<T> * GreatCommonDivisor::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
+  Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
   T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
   T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
   delete f1Input;
diff --git a/poincare/src/integral.cpp b/poincare/src/integral.cpp
index 9d02e67ef..a60268268 100644
--- a/poincare/src/integral.cpp
+++ b/poincare/src/integral.cpp
@@ -37,12 +37,12 @@ Expression * Integral::shallowReduce(Context& context, AngleUnit angleUnit) {
 }
 
 template<typename T>
-Complex<T> * Integral::templatedEvaluate(Context & context, AngleUnit angleUnit) const {
+Complex<T> * Integral::templatedApproximate(Context & context, AngleUnit angleUnit) const {
   VariableContext<T> xContext = VariableContext<T>('x', &context);
-  Expression * aInput = operand(1)->evaluate<T>(context, angleUnit);
+  Expression * aInput = operand(1)->approximate<T>(context, angleUnit);
   T a = aInput->type() == Type::Complex ? static_cast<Complex<T> *>(aInput)->toScalar() : NAN;
   delete aInput;
-  Expression * bInput = operand(2)->evaluate<T>(context, angleUnit);
+  Expression * bInput = operand(2)->approximate<T>(context, angleUnit);
   T b = bInput->type() == Type::Complex ? static_cast<Complex<T> *>(bInput)->toScalar() : NAN;
   delete bInput;
   if (std::isnan(a) || std::isnan(b)) {
@@ -70,7 +70,7 @@ T Integral::functionValueAtAbscissa(T x, VariableContext<T> xContext, AngleUnit
   Complex<T> e = Complex<T>::Float(x);
   Symbol xSymbol('x');
   xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
-  Expression * f = operand(0)->evaluate<T>(xContext, angleUnit);
+  Expression * f = operand(0)->approximate<T>(xContext, angleUnit);
   T result = f->type() == Type::Complex ? static_cast<Complex<T> *>(f)->toScalar() : NAN;
   delete f;
   return result;
diff --git a/poincare/src/least_common_multiple.cpp b/poincare/src/least_common_multiple.cpp
index f55d410dd..71f048e6d 100644
--- a/poincare/src/least_common_multiple.cpp
+++ b/poincare/src/least_common_multiple.cpp
@@ -57,9 +57,9 @@ Expression * LeastCommonMultiple::shallowReduce(Context& context, AngleUnit angl
 }
 
 template<typename T>
-Complex<T> * LeastCommonMultiple::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
+Complex<T> * LeastCommonMultiple::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
+  Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
   T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
   T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
   delete f1Input;
diff --git a/poincare/src/logarithm.cpp b/poincare/src/logarithm.cpp
index 22588fe3f..734f03efa 100644
--- a/poincare/src/logarithm.cpp
+++ b/poincare/src/logarithm.cpp
@@ -8,7 +8,7 @@
 #include <poincare/arithmetic.h>
 #include <poincare/power.h>
 #include <poincare/naperian_logarithm.h>
-#include <poincare/evaluation_engine.h>
+#include <poincare/approximation_engine.h>
 #include <poincare/simplification_engine.h>
 #include <cmath>
 #include <ion.h>
@@ -192,12 +192,12 @@ Expression * Logarithm::shallowBeautify(Context & context, AngleUnit angleUnit)
 }
 
 template<typename T>
-Expression * Logarithm::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
+Expression * Logarithm::templatedApproximate(Context& context, AngleUnit angleUnit) const {
   if (numberOfOperands() == 1) {
-    return EvaluationEngine::map(this, context, angleUnit, computeOnComplex<T>);
+    return ApproximationEngine::map(this, context, angleUnit, computeOnComplex<T>);
   }
-  Expression * x = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * n = operand(1)->evaluate<T>(context, angleUnit);
+  Expression * x = operand(0)->approximate<T>(context, angleUnit);
+  Expression * n = operand(1)->approximate<T>(context, angleUnit);
   Complex<T> result = Complex<T>::Float(NAN);
   if (x->type() == Type::Complex && n->type() == Type::Complex) {
     Complex<T> * xc = static_cast<Complex<T> *>(x);
diff --git a/poincare/src/matrix.cpp b/poincare/src/matrix.cpp
index 8e23e7753..d9a67e939 100644
--- a/poincare/src/matrix.cpp
+++ b/poincare/src/matrix.cpp
@@ -312,10 +312,10 @@ Matrix * Matrix::createApproximateIdentity(int dim) {
 }
 
 template<typename T>
-Expression * Matrix::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
+Expression * Matrix::templatedApproximate(Context& context, AngleUnit angleUnit) const {
   Expression ** operands = new Expression * [numberOfOperands()];
   for (int i = 0; i < numberOfOperands(); i++) {
-    Expression * operandEvaluation = operand(i)->evaluate<T>(context, angleUnit);
+    Expression * operandEvaluation = operand(i)->approximate<T>(context, angleUnit);
     if (operandEvaluation->type() != Type::Complex) {
       operands[i] = new Complex<T>(Complex<T>::Float(NAN));
       delete operandEvaluation;
diff --git a/poincare/src/matrix_dimension.cpp b/poincare/src/matrix_dimension.cpp
index 8bbb5fb74..f582f93cc 100644
--- a/poincare/src/matrix_dimension.cpp
+++ b/poincare/src/matrix_dimension.cpp
@@ -40,8 +40,8 @@ Expression * MatrixDimension::shallowReduce(Context& context, AngleUnit angleUni
 }
 
 template<typename T>
-Expression * MatrixDimension::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * input = operand(0)->evaluate<T>(context, angleUnit);
+Expression * MatrixDimension::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * input = operand(0)->approximate<T>(context, angleUnit);
   Expression * operands[2];
   if (input->type() == Type::Matrix) {
     operands[0] = new Complex<T>(Complex<T>::Float((T)static_cast<Matrix *>(input)->numberOfRows()));
diff --git a/poincare/src/matrix_inverse.cpp b/poincare/src/matrix_inverse.cpp
index 1d5271be5..988604eb0 100644
--- a/poincare/src/matrix_inverse.cpp
+++ b/poincare/src/matrix_inverse.cpp
@@ -46,8 +46,8 @@ Expression * MatrixInverse::shallowReduce(Context& context, AngleUnit angleUnit)
 
 // TODO: handle this exactly in shallowReduce for small dimensions.
 template<typename T>
-Expression * MatrixInverse::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * input = operand(0)->evaluate<T>(context, angleUnit);
+Expression * MatrixInverse::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * input = operand(0)->approximate<T>(context, angleUnit);
   Expression * result = nullptr;
   if (input->type() == Type::Complex) {
     Complex<T> * c = static_cast<Complex<T> *>(input);
diff --git a/poincare/src/matrix_trace.cpp b/poincare/src/matrix_trace.cpp
index 4ae4ebfab..0525b1590 100644
--- a/poincare/src/matrix_trace.cpp
+++ b/poincare/src/matrix_trace.cpp
@@ -49,8 +49,8 @@ Expression * MatrixTrace::shallowReduce(Context& context, AngleUnit angleUnit) {
 }
 
 template<typename T>
-Expression * MatrixTrace::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * input = operand(0)->evaluate<T>(context, angleUnit);
+Expression * MatrixTrace::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * input = operand(0)->approximate<T>(context, angleUnit);
   Expression * result = nullptr;
   if (input->type() == Type::Complex) {
     result = input->clone();
diff --git a/poincare/src/matrix_transpose.cpp b/poincare/src/matrix_transpose.cpp
index 59bb4ec3f..c6deb029d 100644
--- a/poincare/src/matrix_transpose.cpp
+++ b/poincare/src/matrix_transpose.cpp
@@ -39,8 +39,8 @@ Expression * MatrixTranspose::shallowReduce(Context& context, AngleUnit angleUni
 }
 
 template<typename T>
-Expression * MatrixTranspose::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * input = operand(0)->evaluate<T>(context, angleUnit);
+Expression * MatrixTranspose::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * input = operand(0)->approximate<T>(context, angleUnit);
   Expression * result = nullptr;
   if (input->type() == Type::Complex) {
     result = input->clone();
diff --git a/poincare/src/nth_root.cpp b/poincare/src/nth_root.cpp
index 030dc13ff..e648818c0 100644
--- a/poincare/src/nth_root.cpp
+++ b/poincare/src/nth_root.cpp
@@ -54,9 +54,9 @@ Complex<T> NthRoot::compute(const Complex<T> c, const Complex<T> d) {
 }
 
 template<typename T>
-Expression * NthRoot::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * base = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * index = operand(1)->evaluate<T>(context, angleUnit);
+Expression * NthRoot::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * base = operand(0)->approximate<T>(context, angleUnit);
+  Expression * index = operand(1)->approximate<T>(context, angleUnit);
   Complex<T> result = Complex<T>::Float(NAN);
   if (base->type() == Type::Complex && index->type() == Type::Complex) {
     Complex<T> * basec = static_cast<Complex<T> *>(base);
diff --git a/poincare/src/parenthesis.cpp b/poincare/src/parenthesis.cpp
index 9cc9c0829..e8a7985b6 100644
--- a/poincare/src/parenthesis.cpp
+++ b/poincare/src/parenthesis.cpp
@@ -32,8 +32,8 @@ Expression * Parenthesis::shallowReduce(Context& context, AngleUnit angleUnit) {
 }
 
 template<typename T>
-Expression * Parenthesis::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  return operand(0)->evaluate<T>(context, angleUnit);
+Expression * Parenthesis::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  return operand(0)->approximate<T>(context, angleUnit);
 }
 
 }
diff --git a/poincare/src/permute_coefficient.cpp b/poincare/src/permute_coefficient.cpp
index f381173d4..4ecc692ef 100644
--- a/poincare/src/permute_coefficient.cpp
+++ b/poincare/src/permute_coefficient.cpp
@@ -68,9 +68,9 @@ Expression * PermuteCoefficient::shallowReduce(Context& context, AngleUnit angle
 }
 
 template<typename T>
-Complex<T> * PermuteCoefficient::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * nInput = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * kInput = operand(1)->evaluate<T>(context, angleUnit);
+Complex<T> * PermuteCoefficient::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * nInput = operand(0)->approximate<T>(context, angleUnit);
+  Expression * kInput = operand(1)->approximate<T>(context, angleUnit);
   if (nInput->type() != Type::Complex || kInput->type() != Type::Complex) {
     return new Complex<T>(Complex<T>::Float(NAN));
   }
diff --git a/poincare/src/power.cpp b/poincare/src/power.cpp
index 0566c1041..707dc5330 100644
--- a/poincare/src/power.cpp
+++ b/poincare/src/power.cpp
@@ -183,8 +183,8 @@ Expression * Power::shallowReduce(Context& context, AngleUnit angleUnit) {
 
   /* Step 0: if both operands are true complexes, the result is undefined.
    * We can assert that evaluations is a complex as matrix are not simplified */
-  Complex<float> * op0 = static_cast<Complex<float> *>(operand(0)->evaluate<float>(context, angleUnit));
-  Complex<float> * op1 = static_cast<Complex<float> *>(operand(1)->evaluate<float>(context, angleUnit));
+  Complex<float> * op0 = static_cast<Complex<float> *>(operand(0)->approximate<float>(context, angleUnit));
+  Complex<float> * op1 = static_cast<Complex<float> *>(operand(1)->approximate<float>(context, angleUnit));
   bool bothOperandsComplexes = op0->b() != 0 && op1->b() != 0;
   delete op0;
   delete op1;
diff --git a/poincare/src/prediction_interval.cpp b/poincare/src/prediction_interval.cpp
index 42f33e734..548f2442a 100644
--- a/poincare/src/prediction_interval.cpp
+++ b/poincare/src/prediction_interval.cpp
@@ -68,9 +68,9 @@ Expression * PredictionInterval::shallowReduce(Context& context, AngleUnit angle
 }
 
 template<typename T>
-Expression * PredictionInterval::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * pInput = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * nInput = operand(1)->evaluate<T>(context, angleUnit);
+Expression * PredictionInterval::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * pInput = operand(0)->approximate<T>(context, angleUnit);
+  Expression * nInput = operand(1)->approximate<T>(context, angleUnit);
   if (pInput->type() != Type::Complex || nInput->type() != Type::Complex) {
     return new Complex<T>(Complex<T>::Float(NAN));
   }
diff --git a/poincare/src/product.cpp b/poincare/src/product.cpp
index dcc8f40d0..d202cd807 100644
--- a/poincare/src/product.cpp
+++ b/poincare/src/product.cpp
@@ -31,7 +31,7 @@ ExpressionLayout * Product::createSequenceLayoutWithArgumentLayouts(ExpressionLa
 }
 
 template<typename T>
-Expression * Product::templatedEvaluateWithNextTerm(Expression * a, Expression * b) const {
+Expression * Product::templatedApproximateWithNextTerm(Expression * a, Expression * b) const {
   if (a->type() == Type::Complex && b->type() == Type::Complex) {
     Complex<T> * c = static_cast<Complex<T> *>(a);
     Complex<T> * d = static_cast<Complex<T> *>(b);
diff --git a/poincare/src/rational.cpp b/poincare/src/rational.cpp
index 78accb430..863a605f4 100644
--- a/poincare/src/rational.cpp
+++ b/poincare/src/rational.cpp
@@ -138,7 +138,7 @@ int Rational::simplificationOrderSameType(const Expression * e) const {
   return NaturalOrder(*this, *other);
 }
 
-template<typename T> Complex<T> * Rational::templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const {
+template<typename T> Complex<T> * Rational::templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const {
   T n = m_numerator.approximate<T>();
   T d = m_denominator.approximate<T>();
   return new Complex<T>(Complex<T>::Float(n/d));
diff --git a/poincare/src/round.cpp b/poincare/src/round.cpp
index 60cc6bedc..77ba9ae5f 100644
--- a/poincare/src/round.cpp
+++ b/poincare/src/round.cpp
@@ -48,9 +48,9 @@ Expression * Round::shallowReduce(Context& context, AngleUnit angleUnit) {
 }
 
 template<typename T>
-Complex<T> * Round::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
-  Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
+Complex<T> * Round::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
+  Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
   T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
   T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
   delete f1Input;
diff --git a/poincare/src/sequence.cpp b/poincare/src/sequence.cpp
index 0b2b5bf1a..87386e816 100644
--- a/poincare/src/sequence.cpp
+++ b/poincare/src/sequence.cpp
@@ -23,9 +23,9 @@ ExpressionLayout * Sequence::privateCreateLayout(FloatDisplayMode floatDisplayMo
 }
 
 template<typename T>
-Expression * Sequence::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
-  Expression * aInput = operand(1)->evaluate<T>(context, angleUnit);
-  Expression * bInput = operand(2)->evaluate<T>(context, angleUnit);
+Expression * Sequence::templatedApproximate(Context& context, AngleUnit angleUnit) const {
+  Expression * aInput = operand(1)->approximate<T>(context, angleUnit);
+  Expression * bInput = operand(2)->approximate<T>(context, angleUnit);
   T start = aInput->type() == Type::Complex ? static_cast<Complex<T> *>(aInput)->toScalar() : NAN;
   T end = bInput->type() == Type::Complex ? static_cast<Complex<T> *>(bInput)->toScalar() : NAN;
   delete aInput;
@@ -43,7 +43,7 @@ Expression * Sequence::templatedEvaluate(Context& context, AngleUnit angleUnit)
     }
     Complex<T> iExpression = Complex<T>::Float(i);
     nContext.setExpressionForSymbolName(&iExpression, &nSymbol, nContext);
-    Expression * expression = operand(0)->evaluate<T>(nContext, angleUnit);
+    Expression * expression = operand(0)->approximate<T>(nContext, angleUnit);
     Expression * newResult = evaluateWithNextTerm(T(), result, expression);
     delete result;
     delete expression;
diff --git a/poincare/src/simplification/expression_simplify.cpp b/poincare/src/simplification/expression_simplify.cpp
index 7ce61943c..2d9d5f216 100644
--- a/poincare/src/simplification/expression_simplify.cpp
+++ b/poincare/src/simplification/expression_simplify.cpp
@@ -22,10 +22,10 @@ public:
   ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override {
     return nullptr;
   }
-  Evaluation<float> * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
+  Evaluation<float> * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
     return nullptr;
   }
-  Evaluation<double> * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
+  Evaluation<double> * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
     return nullptr;
   }
 };
diff --git a/poincare/src/store.cpp b/poincare/src/store.cpp
index e4616d889..34296a405 100644
--- a/poincare/src/store.cpp
+++ b/poincare/src/store.cpp
@@ -37,10 +37,10 @@ ExpressionLayout * Store::privateCreateLayout(FloatDisplayMode floatDisplayMode,
 }
 
 template<typename T>
-Expression * Store::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
+Expression * Store::templatedApproximate(Context& context, AngleUnit angleUnit) const {
   context.setExpressionForSymbolName(value(), symbol(), context);
   if (context.expressionForSymbol(symbol()) != nullptr) {
-    return context.expressionForSymbol(symbol())->evaluate<T>(context, angleUnit);
+    return context.expressionForSymbol(symbol())->approximate<T>(context, angleUnit);
   }
   return new Complex<T>(Complex<T>::Float(NAN));
 }
diff --git a/poincare/src/sum.cpp b/poincare/src/sum.cpp
index 7e7e5c792..70a5168b7 100644
--- a/poincare/src/sum.cpp
+++ b/poincare/src/sum.cpp
@@ -31,7 +31,7 @@ ExpressionLayout * Sum::createSequenceLayoutWithArgumentLayouts(ExpressionLayout
 }
 
 template<typename T>
-Expression * Sum::templatedEvaluateWithNextTerm(Expression * a, Expression * b) const {
+Expression * Sum::templatedApproximateWithNextTerm(Expression * a, Expression * b) const {
   if (a->type() == Type::Complex && b->type() == Type::Complex) {
     Complex<T> * c = static_cast<Complex<T> *>(a);
     Complex<T> * d = static_cast<Complex<T> *>(b);
diff --git a/poincare/src/symbol.cpp b/poincare/src/symbol.cpp
index 440b9fdee..26c6f6abc 100644
--- a/poincare/src/symbol.cpp
+++ b/poincare/src/symbol.cpp
@@ -111,9 +111,9 @@ Expression::Sign Symbol::sign() const {
 }
 
 template<typename T>
-Expression * Symbol::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
+Expression * Symbol::templatedApproximate(Context& context, AngleUnit angleUnit) const {
   if (context.expressionForSymbol(this) != nullptr) {
-    return context.expressionForSymbol(this)->evaluate<T>(context, angleUnit);
+    return context.expressionForSymbol(this)->approximate<T>(context, angleUnit);
   }
   return new Complex<T>(Complex<T>::Float(NAN));
 }
diff --git a/poincare/src/undefined.cpp b/poincare/src/undefined.cpp
index c8da8aac4..1fc6f27ad 100644
--- a/poincare/src/undefined.cpp
+++ b/poincare/src/undefined.cpp
@@ -14,7 +14,7 @@ Expression * Undefined::clone() const {
   return new Undefined();
 }
 
-template<typename T> Complex<T> * Undefined::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
+template<typename T> Complex<T> * Undefined::templatedApproximate(Context& context, AngleUnit angleUnit) const {
   return new Complex<T>(Complex<T>::Float(NAN));
 }
 
diff --git a/poincare/test/complex.cpp b/poincare/test/complex.cpp
index 3c8a0c9ce..a1c883c0b 100644
--- a/poincare/test/complex.cpp
+++ b/poincare/test/complex.cpp
@@ -105,14 +105,14 @@ QUIZ_CASE(poincare_complex_cartesian_to_text) {
 QUIZ_CASE(poincare_complex_evaluate) {
   GlobalContext globalContext;
   Expression * a = new Complex<float>(Complex<float>::Float(123.456f));
-  Expression * m = a->evaluate<double>(globalContext);
+  Expression * m = a->approximate<double>(globalContext);
   assert(m->type() == Expression::Type::Complex);
   Complex<double> * mc = static_cast<Complex<double> *>(m);
   assert(std::fabs(mc->a() - 123.456) < 0.00001);
   assert(mc->b() == 0.0);
   delete m;
 
-  Expression * n = a->evaluate<float>(globalContext);
+  Expression * n = a->approximate<float>(globalContext);
   assert(n->type() == Expression::Type::Complex);
   Complex<float> * nc = static_cast<Complex<float> *>(n);
   assert(nc->a() == 123.456f);
diff --git a/poincare/test/helper.cpp b/poincare/test/helper.cpp
index 1694d6d3e..2e069679a 100644
--- a/poincare/test/helper.cpp
+++ b/poincare/test/helper.cpp
@@ -36,7 +36,7 @@ template<typename T>
 void assert_parsed_expression_evaluates_to(const char * expression, Complex<T> * results, int numberOfRows, int numberOfColumns, Expression::AngleUnit angleUnit) {
   GlobalContext globalContext;
   Expression * a = parse_expression(expression);
-  Expression * m = a->evaluate<T>(globalContext, angleUnit);
+  Expression * m = a->approximate<T>(globalContext, angleUnit);
   assert(m);
   assert(m->numberOfOperands() == 0 || m->numberOfOperands() == numberOfRows*numberOfColumns);
   if (m->type() == Expression::Type::Matrix) {