diff --git a/apps/calculation/calculation.cpp b/apps/calculation/calculation.cpp
index a92263ab0..348ad9f4e 100644
--- a/apps/calculation/calculation.cpp
+++ b/apps/calculation/calculation.cpp
@@ -1,5 +1,6 @@
 #include "calculation.h"
 #include <string.h>
+#include <math.h>
 using namespace Poincare;
 
 namespace Calculation {
diff --git a/apps/probability/calculation/discrete_calculation.cpp b/apps/probability/calculation/discrete_calculation.cpp
index 4c5f1db4a..43f0ca2bb 100644
--- a/apps/probability/calculation/discrete_calculation.cpp
+++ b/apps/probability/calculation/discrete_calculation.cpp
@@ -1,7 +1,7 @@
 #include "discrete_calculation.h"
 #include <assert.h>
 #include <ion.h>
-#include <math.h>
+#include <cmath>
 
 namespace Probability {
 
@@ -35,7 +35,7 @@ I18n::Message DiscreteCalculation::legendForParameterAtIndex(int index) {
 
 void DiscreteCalculation::setParameterAtIndex(float f, int index) {
   assert(index == 0);
-  float rf = roundf(f);
+  float rf = std::round(f);
   m_abscissa = rf;
   compute(index);
 }
@@ -63,7 +63,7 @@ void DiscreteCalculation::compute(int indexKnownElement) {
   }
   m_result = m_law->evaluateAtAbscissa(m_abscissa);
   /* Results in probability application are rounder to 3 decimals */
-  m_result = roundf(m_result/k_precision)*k_precision;
+  m_result = std::round(m_result/k_precision)*k_precision;
 }
 
 }
diff --git a/apps/probability/calculation/finite_integral_calculation.cpp b/apps/probability/calculation/finite_integral_calculation.cpp
index d843c88dd..538865c4b 100644
--- a/apps/probability/calculation/finite_integral_calculation.cpp
+++ b/apps/probability/calculation/finite_integral_calculation.cpp
@@ -2,7 +2,7 @@
 #include "../law/normal_law.h"
 #include <assert.h>
 #include <ion.h>
-#include <math.h>
+#include <cmath>
 
 namespace Probability {
 
@@ -43,7 +43,7 @@ I18n::Message FiniteIntegralCalculation::legendForParameterAtIndex(int index) {
 
 void FiniteIntegralCalculation::setParameterAtIndex(float f, int index) {
   assert(index >= 0 && index < 3);
-  float rf = roundf(f/k_precision)*k_precision;
+  float rf = std::round(f/k_precision)*k_precision;
   if (index == 0) {
     m_lowerBound = rf;
   }
@@ -84,12 +84,12 @@ void FiniteIntegralCalculation::compute(int indexKnownElement) {
     assert(m_law->type() == Law::Type::Normal);
     float p = (1.0f+m_result)/2.0f;
     float a = ((NormalLaw *)m_law)->cumulativeDistributiveInverseForProbability(&p);
-    m_lowerBound = roundf((2.0f*m_law->parameterValueAtIndex(0)-a)/k_precision)*k_precision;
-    m_upperBound = roundf(a/k_precision)*k_precision;
+    m_lowerBound = std::round((2.0f*m_law->parameterValueAtIndex(0)-a)/k_precision)*k_precision;
+    m_upperBound = std::round(a/k_precision)*k_precision;
   }
   m_result = m_law->finiteIntegralBetweenAbscissas(m_lowerBound, m_upperBound);
   /* Results in probability application are rounder to 3 decimals */
-  m_result = roundf(m_result/k_precision)*k_precision;
+  m_result = std::round(m_result/k_precision)*k_precision;
 }
 
 }
diff --git a/apps/probability/calculation/left_integral_calculation.cpp b/apps/probability/calculation/left_integral_calculation.cpp
index 2b53da9e2..aff517d7c 100644
--- a/apps/probability/calculation/left_integral_calculation.cpp
+++ b/apps/probability/calculation/left_integral_calculation.cpp
@@ -1,7 +1,7 @@
 #include "left_integral_calculation.h"
 #include <assert.h>
 #include <ion.h>
-#include <math.h>
+#include <cmath>
 
 namespace Probability {
 
@@ -31,7 +31,7 @@ I18n::Message LeftIntegralCalculation::legendForParameterAtIndex(int index) {
 
 void LeftIntegralCalculation::setParameterAtIndex(float f, int index) {
   assert(index >= 0 && index < 2);
-  float rf = roundf(f/k_precision)*k_precision;
+  float rf = std::round(f/k_precision)*k_precision;
   if (index == 0) {
     m_upperBound = rf;
   }
@@ -60,10 +60,10 @@ void LeftIntegralCalculation::compute(int indexKnownElement) {
   if (indexKnownElement == 0) {
     m_result = m_law->cumulativeDistributiveFunctionAtAbscissa(m_upperBound);
     /* Results in probability application are rounder to 3 decimals */
-    m_result = roundf(m_result/k_precision)*k_precision;
+    m_result = std::round(m_result/k_precision)*k_precision;
   } else {
     m_upperBound = m_law->cumulativeDistributiveInverseForProbability(&m_result);
-    m_upperBound = roundf(m_upperBound/k_precision)*k_precision;
+    m_upperBound = std::round(m_upperBound/k_precision)*k_precision;
   }
 }
 
diff --git a/apps/probability/calculation/right_integral_calculation.cpp b/apps/probability/calculation/right_integral_calculation.cpp
index 7878e98c5..ca498e8d3 100644
--- a/apps/probability/calculation/right_integral_calculation.cpp
+++ b/apps/probability/calculation/right_integral_calculation.cpp
@@ -1,7 +1,7 @@
 #include "right_integral_calculation.h"
 #include <assert.h>
 #include <ion.h>
-#include <math.h>
+#include <cmath>
 
 namespace Probability {
 
@@ -31,7 +31,7 @@ I18n::Message RightIntegralCalculation::legendForParameterAtIndex(int index) {
 
 void RightIntegralCalculation::setParameterAtIndex(float f, int index) {
   assert(index >= 0 && index < 2);
-  float rf = roundf(f/k_precision)*k_precision;
+  float rf = std::round(f/k_precision)*k_precision;
   if (index == 0) {
     m_lowerBound = rf;
   }
@@ -60,10 +60,10 @@ void RightIntegralCalculation::compute(int indexKnownElement) {
   if (indexKnownElement == 0) {
     m_result = m_law->rightIntegralFromAbscissa(m_lowerBound);
     /* Results in probability application are rounder to 3 decimals */
-    m_result = roundf(m_result/k_precision)*k_precision;
+    m_result = std::round(m_result/k_precision)*k_precision;
   } else {
     m_lowerBound = m_law->rightIntegralInverseForProbability(&m_result);
-    m_lowerBound = roundf(m_lowerBound/k_precision)*k_precision;
+    m_lowerBound = std::round(m_lowerBound/k_precision)*k_precision;
   }
 }
 
diff --git a/apps/probability/calculation_controller.cpp b/apps/probability/calculation_controller.cpp
index 580fee545..551b47b07 100644
--- a/apps/probability/calculation_controller.cpp
+++ b/apps/probability/calculation_controller.cpp
@@ -7,6 +7,7 @@
 #include "calculation/right_integral_calculation.h"
 #include "calculation/finite_integral_calculation.h"
 #include <assert.h>
+#include <cmath>
 
 using namespace Poincare;
 using namespace Shared;
@@ -231,7 +232,7 @@ bool CalculationController::textFieldDidFinishEditing(TextField * textField, con
     }
   }
   if (!m_law->isContinuous() && (m_highlightedSubviewIndex == 1 || m_calculation->type() == Calculation::Type::FiniteIntegral)) {
-    floatBody = roundf(floatBody);
+    floatBody = std::round(floatBody);
   }
   m_calculation->setParameterAtIndex(floatBody, m_highlightedSubviewIndex-1);
   if (event == Ion::Events::Right || event == Ion::Events::Left) {
diff --git a/apps/probability/law/binomial_law.cpp b/apps/probability/law/binomial_law.cpp
index 6c8a6f433..84b4c1783 100644
--- a/apps/probability/law/binomial_law.cpp
+++ b/apps/probability/law/binomial_law.cpp
@@ -1,6 +1,6 @@
 #include "binomial_law.h"
 #include <assert.h>
-#include <math.h>
+#include <cmath>
 
 namespace Probability {
 
@@ -92,9 +92,9 @@ float BinomialLaw::evaluateAtAbscissa(float x) const {
   if (x > m_parameter1) {
     return 0.0f;
   }
-  float lResult = lgammaf(m_parameter1+1) - lgammaf((int)x+1) - lgammaf(m_parameter1 - (int)x+1)+
-    (int)x*logf(m_parameter2) + (m_parameter1-(int)x)*logf(1-m_parameter2);
-  return expf(lResult);
+  float lResult = std::lgamma(m_parameter1+1) - std::lgamma(floorf(x)+1.0f) - std::lgamma(m_parameter1 - floorf(x)+1.0f)+
+    (int)x*std::log(m_parameter2) + (m_parameter1-(int)x)*std::log(1-m_parameter2);
+  return std::exp(lResult);
 }
 
 bool BinomialLaw::authorizedValueAtIndex(float x, int index) const {
diff --git a/apps/probability/law/exponential_law.cpp b/apps/probability/law/exponential_law.cpp
index df00bac55..c4933a77a 100644
--- a/apps/probability/law/exponential_law.cpp
+++ b/apps/probability/law/exponential_law.cpp
@@ -1,6 +1,6 @@
 #include "exponential_law.h"
 #include <assert.h>
-#include <math.h>
+#include <cmath>
 #include <float.h>
 #include <ion.h>
 
@@ -66,7 +66,7 @@ float ExponentialLaw::evaluateAtAbscissa(float x) const {
   if (x < 0.0f) {
     return NAN;
   }
-  return m_parameter1*expf(-m_parameter1*x);
+  return m_parameter1*std::exp(-m_parameter1*x);
 }
 
 bool ExponentialLaw::authorizedValueAtIndex(float x, int index) const {
@@ -77,7 +77,7 @@ bool ExponentialLaw::authorizedValueAtIndex(float x, int index) const {
 }
 
 float ExponentialLaw::cumulativeDistributiveFunctionAtAbscissa(float x) const {
-  return 1.0f - expf(-m_parameter1*x);
+  return 1.0f - std::exp(-m_parameter1*x);
 }
 
 float ExponentialLaw::cumulativeDistributiveInverseForProbability(float * probability) {
@@ -87,7 +87,7 @@ float ExponentialLaw::cumulativeDistributiveInverseForProbability(float * probab
   if (*probability <= 0.0f) {
     return 0.0f;
   }
-  return -logf(1.0f - *probability)/m_parameter1;
+  return -std::log(1.0f - *probability)/m_parameter1;
 }
 
 }
diff --git a/apps/probability/law/law.cpp b/apps/probability/law/law.cpp
index d9eb01e25..3e4552006 100644
--- a/apps/probability/law/law.cpp
+++ b/apps/probability/law/law.cpp
@@ -1,5 +1,5 @@
 #include "law.h"
-#include <math.h>
+#include <cmath>
 #include <float.h>
 
 namespace Probability {
@@ -14,7 +14,7 @@ float Law::xGridUnit() {
 
 float Law::cumulativeDistributiveFunctionAtAbscissa(float x) const {
   if (!isContinuous()) {
-    int end = roundf(x);
+    int end = std::round(x);
     float result = 0.0f;
     for (int k = 0; k <=end; k++) {
       result += evaluateAtAbscissa(k);
@@ -42,8 +42,8 @@ float Law::finiteIntegralBetweenAbscissas(float a, float b) const {
   if (isContinuous()) {
     return cumulativeDistributiveFunctionAtAbscissa(b) - cumulativeDistributiveFunctionAtAbscissa(a);
   }
-  int start = roundf(a);
-  int end = roundf(b);
+  int start = std::round(a);
+  int end = std::round(b);
   float result = 0.0f;
   for (int k = start; k <=end; k++) {
     result += evaluateAtAbscissa(k);
diff --git a/apps/probability/law/normal_law.cpp b/apps/probability/law/normal_law.cpp
index a32032df9..1840dac8e 100644
--- a/apps/probability/law/normal_law.cpp
+++ b/apps/probability/law/normal_law.cpp
@@ -1,6 +1,6 @@
 #include "normal_law.h"
 #include <assert.h>
-#include <math.h>
+#include <cmath>
 #include <float.h>
 #include <ion.h>
 
@@ -45,14 +45,14 @@ float NormalLaw::xMin() {
   if (m_parameter2 == 0.0f) {
     return m_parameter1 - 1.0f;
   }
-  return m_parameter1 - 5.0f*fabsf(m_parameter2);
+  return m_parameter1 - 5.0f*std::fabs(m_parameter2);
 }
 
 float NormalLaw::xMax() {
   if (m_parameter2 == 0.0f) {
     return m_parameter1 + 1.0f;
   }
-  return m_parameter1 + 5.0f*fabsf(m_parameter2);
+  return m_parameter1 + 5.0f*std::fabs(m_parameter2);
 }
 
 float NormalLaw::yMin() {
@@ -72,14 +72,14 @@ float NormalLaw::evaluateAtAbscissa(float x) const {
   if (m_parameter2 == 0.0f) {
     return NAN;
   }
-  return (1.0f/(fabsf(m_parameter2)*sqrtf(2.0f*M_PI)))*expf(-0.5f*powf((x-m_parameter1)/m_parameter2,2));
+  return (1.0f/(std::fabs(m_parameter2)*std::sqrt(2.0f*M_PI)))*std::exp(-0.5f*std::pow((x-m_parameter1)/m_parameter2,2));
 }
 
 bool NormalLaw::authorizedValueAtIndex(float x, int index) const {
   if (index == 0) {
     return true;
   }
-  if (x <= 0 || fabsf(m_parameter1/x) > k_maxRatioMuSigma) {
+  if (x <= 0 || std::fabs(m_parameter1/x) > k_maxRatioMuSigma) {
     return false;
   }
   return true;
@@ -87,7 +87,7 @@ bool NormalLaw::authorizedValueAtIndex(float x, int index) const {
 
 void NormalLaw::setParameterAtIndex(float f, int index) {
   TwoParameterLaw::setParameterAtIndex(f, index);
-  if (index == 0 && fabsf(m_parameter1/m_parameter2) > k_maxRatioMuSigma) {
+  if (index == 0 && std::fabs(m_parameter1/m_parameter2) > k_maxRatioMuSigma) {
     m_parameter2 = m_parameter1/k_maxRatioMuSigma;
   }
 }
@@ -96,14 +96,14 @@ float NormalLaw::cumulativeDistributiveFunctionAtAbscissa(float x) const {
   if (m_parameter2 ==  0.0f) {
     return NAN;
   }
-  return standardNormalCumulativeDistributiveFunctionAtAbscissa((x-m_parameter1)/fabsf(m_parameter2));
+  return standardNormalCumulativeDistributiveFunctionAtAbscissa((x-m_parameter1)/std::fabs(m_parameter2));
 }
 
 float NormalLaw::cumulativeDistributiveInverseForProbability(float * probability) {
   if (m_parameter2 ==  0.0f) {
     return NAN;
   }
-  return standardNormalCumulativeDistributiveInverseForProbability(*probability)*fabsf(m_parameter2) + m_parameter1;
+  return standardNormalCumulativeDistributiveInverseForProbability(*probability)*std::fabs(m_parameter2) + m_parameter1;
 }
 
 float NormalLaw::standardNormalCumulativeDistributiveFunctionAtAbscissa(float abscissa) const {
@@ -117,7 +117,7 @@ float NormalLaw::standardNormalCumulativeDistributiveFunctionAtAbscissa(float ab
     return 1.0f;
   }
   /* Waissi & Rossin's formula (error less than 0.0001) */
-  return 1.0f/(1.0f+expf(-sqrtf(M_PI)*(k_beta1*powf(abscissa,5)+k_beta2*powf(abscissa,3)+k_beta3*abscissa)));
+  return 1.0f/(1.0f+std::exp(-std::sqrt(M_PI)*(k_beta1*std::pow(abscissa,5)+k_beta2*std::pow(abscissa,3)+k_beta3*abscissa)));
 }
 
 float NormalLaw::standardNormalCumulativeDistributiveInverseForProbability(float probability) {
@@ -131,7 +131,7 @@ float NormalLaw::standardNormalCumulativeDistributiveInverseForProbability(float
     return -standardNormalCumulativeDistributiveInverseForProbability(1-probability);
   }
   /* Soranzo & Epure (error less than 0.001) */
-  return (k_alpha3/logf(k_alpha2))*logf(1.0f - logf(-logf(probability)/logf(2.0f))/logf(k_alpha1));
+  return (k_alpha3/std::log(k_alpha2))*std::log(1.0f - std::log(-std::log(probability)/std::log(2.0f))/std::log(k_alpha1));
 }
 
 
diff --git a/apps/probability/law/poisson_law.cpp b/apps/probability/law/poisson_law.cpp
index 117551729..5869ae528 100644
--- a/apps/probability/law/poisson_law.cpp
+++ b/apps/probability/law/poisson_law.cpp
@@ -1,6 +1,6 @@
 #include "poisson_law.h"
 #include <assert.h>
-#include <math.h>
+#include <cmath>
 #include <ion.h>
 
 namespace Probability {
@@ -38,7 +38,7 @@ float PoissonLaw::xMin() {
 
 float PoissonLaw::xMax() {
   assert(m_parameter1 != 0);
-  return (m_parameter1 + 5.0f*sqrtf(m_parameter1))*(1.0f+k_displayRightMarginRatio);
+  return (m_parameter1 + 5.0f*std::sqrt(m_parameter1))*(1.0f+k_displayRightMarginRatio);
 }
 
 float PoissonLaw::yMin() {
@@ -59,8 +59,8 @@ float PoissonLaw::evaluateAtAbscissa(float x) const {
   if (x < 0.0f) {
     return NAN;
   }
-  float lResult = -m_parameter1+(int)x*logf(m_parameter1)-lgammaf((int)x+1);
-  return expf(lResult);
+  float lResult = -m_parameter1+(int)x*std::log(m_parameter1)-std::lgamma(floorf(x)+1.0f);
+  return std::exp(lResult);
 }
 
 bool PoissonLaw::authorizedValueAtIndex(float x, int index) const {
diff --git a/apps/probability/law_curve_view.cpp b/apps/probability/law_curve_view.cpp
index 2d1d1d5e7..b4584c0b1 100644
--- a/apps/probability/law_curve_view.cpp
+++ b/apps/probability/law_curve_view.cpp
@@ -1,6 +1,5 @@
 #include "law_curve_view.h"
 #include <assert.h>
-#include <math.h>
 
 using namespace Shared;
 
diff --git a/apps/regression/go_to_parameter_controller.cpp b/apps/regression/go_to_parameter_controller.cpp
index 1b004f1e3..a7e5be7d2 100644
--- a/apps/regression/go_to_parameter_controller.cpp
+++ b/apps/regression/go_to_parameter_controller.cpp
@@ -3,6 +3,7 @@
 #include "../apps_container.h"
 #include <assert.h>
 #include <float.h>
+#include <cmath>
 
 using namespace Shared;
 using namespace Poincare;
@@ -38,7 +39,7 @@ float GoToParameterController::parameterAtIndex(int index) {
 
 bool GoToParameterController::setParameterAtIndex(int parameterIndex, float f) {
   assert(parameterIndex == 0);
-  if (fabsf(f) > k_maxDisplayableFloat) {
+  if (std::fabs(f) > k_maxDisplayableFloat) {
     app()->displayWarning(I18n::Message::ForbiddenValue);
     return false;
   }
@@ -46,7 +47,7 @@ bool GoToParameterController::setParameterAtIndex(int parameterIndex, float f) {
   if (m_xPrediction) {
     x = m_store->yValueForXValue(f);
   }
-  if (fabsf(x) > k_maxDisplayableFloat) {
+  if (std::fabs(x) > k_maxDisplayableFloat) {
     app()->displayWarning(I18n::Message::ForbiddenValue);
     return false;
   }
diff --git a/apps/regression/graph_controller.cpp b/apps/regression/graph_controller.cpp
index 455587417..6567c7bb0 100644
--- a/apps/regression/graph_controller.cpp
+++ b/apps/regression/graph_controller.cpp
@@ -1,5 +1,6 @@
 #include "graph_controller.h"
 #include "../apps_container.h"
+#include <cmath>
 
 using namespace Poincare;
 using namespace Shared;
@@ -77,7 +78,7 @@ void GraphController::reloadBannerView() {
     strlcpy(buffer+numberOfChar, legend, legendLength+1);
     numberOfChar += legendLength;
   } else {
-    numberOfChar += Complex::convertFloatToText(roundf((float)*m_selectedDotIndex+1.0f), buffer+numberOfChar, Complex::bufferSizeForFloatsWithPrecision(Constant::ShortNumberOfSignificantDigits), Constant::ShortNumberOfSignificantDigits, Expression::FloatDisplayMode::Decimal);
+    numberOfChar += Complex::convertFloatToText(std::round((float)*m_selectedDotIndex+1.0f), buffer+numberOfChar, Complex::bufferSizeForFloatsWithPrecision(Constant::ShortNumberOfSignificantDigits), Constant::ShortNumberOfSignificantDigits, Expression::FloatDisplayMode::Decimal);
   }
   legend = ")  ";
   legendLength = strlen(legend);
diff --git a/apps/regression/graph_view.cpp b/apps/regression/graph_view.cpp
index 4c57ad5cb..97b22873c 100644
--- a/apps/regression/graph_view.cpp
+++ b/apps/regression/graph_view.cpp
@@ -1,6 +1,5 @@
 #include "graph_view.h"
 #include <assert.h>
-#include <math.h>
 
 using namespace Shared;
 
diff --git a/apps/regression/initialisation_parameter_controller.cpp b/apps/regression/initialisation_parameter_controller.cpp
index 07a8c9569..4df1f6b11 100644
--- a/apps/regression/initialisation_parameter_controller.cpp
+++ b/apps/regression/initialisation_parameter_controller.cpp
@@ -1,6 +1,5 @@
 #include "initialisation_parameter_controller.h"
 #include <assert.h>
-#include <math.h>
 
 using namespace Shared;
 
diff --git a/apps/regression/store.cpp b/apps/regression/store.cpp
index b88effbd8..9926d8eeb 100644
--- a/apps/regression/store.cpp
+++ b/apps/regression/store.cpp
@@ -1,7 +1,7 @@
 #include "store.h"
 #include <assert.h>
 #include <float.h>
-#include <math.h>
+#include <cmath>
 #include <string.h>
 
 using namespace Shared;
@@ -27,7 +27,7 @@ int Store::closestVerticalDot(int direction, float x) {
   * otherwise */
   for (int index = 0; index < m_numberOfPairs; index++) {
     if ((m_xMin <= m_data[0][index] && m_data[0][index] <= m_xMax) &&
-        (fabsf(m_data[0][index] - x) < fabsf(nextX - x)) &&
+        (std::fabs(m_data[0][index] - x) < std::fabs(nextX - x)) &&
         ((m_data[1][index] - yValueForXValue(m_data[0][index]) >= 0) == (direction > 0))) {
       // Handle edge case: if 2 dots have the same abscissa but different ordinates
       if (nextX != m_data[0][index] || ((nextY - m_data[1][index] >= 0) == (direction > 0))) {
@@ -39,7 +39,7 @@ int Store::closestVerticalDot(int direction, float x) {
   }
   // Compare with the mean dot
   if (m_xMin <= meanOfColumn(0) && meanOfColumn(0) <= m_xMax &&
-      (fabsf(meanOfColumn(0) - x) < fabsf(nextX - x)) &&
+      (std::fabs(meanOfColumn(0) - x) < std::fabs(nextX - x)) &&
       ((meanOfColumn(1) - yValueForXValue(meanOfColumn(0)) >= 0) == (direction > 0))) {
     if (nextX != meanOfColumn(0) || ((nextY - meanOfColumn(1) >= 0) == (direction > 0))) {
       selectedDot = m_numberOfPairs;
@@ -63,7 +63,7 @@ int Store::nextDot(int direction, int dot) {
        * - the next dot is the closest one in abscissa to x
        * - the next dot is not the same as the selected one
        * - the next dot is at the right of the selected one */
-      if (fabsf(m_data[0][index] - x) < fabsf(nextX - x) &&
+      if (std::fabs(m_data[0][index] - x) < std::fabs(nextX - x) &&
           (index != dot) &&
           (m_data[0][index] >= x)) {
         // Handle edge case: 2 dots have same abscissa
@@ -74,7 +74,7 @@ int Store::nextDot(int direction, int dot) {
       }
     }
     // Compare with the mean dot
-    if (fabsf(meanOfColumn(0) - x) < fabsf(nextX - x) &&
+    if (std::fabs(meanOfColumn(0) - x) < std::fabs(nextX - x) &&
           (m_numberOfPairs != dot) &&
           (meanOfColumn(0) >= x)) {
       if (meanOfColumn(0) != x || (x > dot)) {
@@ -83,7 +83,7 @@ int Store::nextDot(int direction, int dot) {
     }
   } else {
     // Compare with the mean dot
-    if (fabsf(meanOfColumn(0) - x) < fabsf(nextX - x) &&
+    if (std::fabs(meanOfColumn(0) - x) < std::fabs(nextX - x) &&
           (m_numberOfPairs != dot) &&
           (meanOfColumn(0) <= x)) {
       if (meanOfColumn(0) != x || (m_numberOfPairs < dot)) {
@@ -92,7 +92,7 @@ int Store::nextDot(int direction, int dot) {
       }
     }
     for (int index = m_numberOfPairs-1; index >= 0; index--) {
-      if (fabsf(m_data[0][index] - x) < fabsf(nextX - x) &&
+      if (std::fabs(m_data[0][index] - x) < std::fabs(nextX - x) &&
           (index != dot) &&
           (m_data[0][index] <= x)) {
         // Handle edge case: 2 dots have same abscissa
@@ -169,7 +169,7 @@ float Store::varianceOfColumn(int i) {
 }
 
 float Store::standardDeviationOfColumn(int i) {
-  return sqrtf(varianceOfColumn(i));
+  return std::sqrt(varianceOfColumn(i));
 }
 
 float Store::covariance() {
@@ -189,7 +189,7 @@ float Store::yValueForXValue(float x) {
 }
 
 float Store::xValueForYValue(float y) {
-  if (fabsf(slope()) < FLT_EPSILON) {
+  if (std::fabs(slope()) < FLT_EPSILON) {
     return NAN;
   }
   return (y - yIntercept())/slope();
diff --git a/apps/sequence/graph/curve_view_range.cpp b/apps/sequence/graph/curve_view_range.cpp
index 08c8b0510..20ce70441 100644
--- a/apps/sequence/graph/curve_view_range.cpp
+++ b/apps/sequence/graph/curve_view_range.cpp
@@ -1,5 +1,5 @@
 #include "curve_view_range.h"
-#include <math.h>
+#include <cmath>
 #include <ion.h>
 #include <poincare.h>
 
@@ -17,8 +17,8 @@ CurveViewRange::CurveViewRange(CurveViewCursor * cursor, InteractiveCurveViewRan
 void CurveViewRange::roundAbscissa() {
   float xMin = m_xMin;
   float xMax = m_xMax;
-  float newXMin = clipped(roundf((xMin+xMax)/2) - (float)Ion::Display::Width/2.0f, false);
-  float newXMax = clipped(roundf((xMin+xMax)/2) + (float)Ion::Display::Width/2.0f-1.0f, true);
+  float newXMin = clipped(std::round((xMin+xMax)/2) - (float)Ion::Display::Width/2.0f, false);
+  float newXMax = clipped(std::round((xMin+xMax)/2) + (float)Ion::Display::Width/2.0f-1.0f, true);
   if (isnan(newXMin) || isnan(newXMax)) {
     return;
   }
diff --git a/apps/sequence/graph/go_to_parameter_controller.cpp b/apps/sequence/graph/go_to_parameter_controller.cpp
index d2d36758b..66b8a40fa 100644
--- a/apps/sequence/graph/go_to_parameter_controller.cpp
+++ b/apps/sequence/graph/go_to_parameter_controller.cpp
@@ -1,12 +1,13 @@
 #include "go_to_parameter_controller.h"
 #include "../app.h"
 #include <assert.h>
+#include <cmath>
 
 namespace Sequence {
 
 bool GoToParameterController::setParameterAtIndex(int parameterIndex, float f) {
   assert(parameterIndex == 0);
-  return Shared::FunctionGoToParameterController::setParameterAtIndex(parameterIndex, roundf(f));
+  return Shared::FunctionGoToParameterController::setParameterAtIndex(parameterIndex, std::round(f));
 }
 
 }
diff --git a/apps/sequence/graph/graph_controller.cpp b/apps/sequence/graph/graph_controller.cpp
index f7b59f227..0c1e0cc44 100644
--- a/apps/sequence/graph/graph_controller.cpp
+++ b/apps/sequence/graph/graph_controller.cpp
@@ -1,4 +1,5 @@
 #include "graph_controller.h"
+#include <cmath>
 
 using namespace Shared;
 
@@ -45,14 +46,14 @@ bool GraphController::handleEnter() {
 }
 
 bool GraphController::moveCursorHorizontally(int direction) {
-  float xCursorPosition = roundf(m_cursor->x());
+  float xCursorPosition = std::round(m_cursor->x());
   if (direction < 0 && xCursorPosition <= 0) {
     return false;
   }
   /* The cursor moves by step of at minimum 1. If the windowRange is to large
    * compared to the resolution, the cursor takes bigger round step to cross
    * the window in approximatively resolution steps. */
-  float step = ceilf((interactiveCurveViewRange()->xMax()-interactiveCurveViewRange()->xMin())/m_view.resolution());
+  float step = std::ceil((interactiveCurveViewRange()->xMax()-interactiveCurveViewRange()->xMin())/m_view.resolution());
   step = step < 1.0f ? 1.0f : step;
   float x = direction > 0 ? xCursorPosition + step:
     xCursorPosition -  step;
@@ -68,7 +69,7 @@ bool GraphController::moveCursorHorizontally(int direction) {
 }
 
 void GraphController::initCursorParameters() {
-  float x = roundf((interactiveCurveViewRange()->xMin()+interactiveCurveViewRange()->xMax())/2.0f);
+  float x = std::round((interactiveCurveViewRange()->xMin()+interactiveCurveViewRange()->xMax())/2.0f);
   m_indexFunctionSelectedByCursor = 0;
   TextFieldDelegateApp * myApp = (TextFieldDelegateApp *)app();
   int functionIndex = 0;
diff --git a/apps/sequence/graph/graph_view.cpp b/apps/sequence/graph/graph_view.cpp
index a4fc7d168..aefce2c01 100644
--- a/apps/sequence/graph/graph_view.cpp
+++ b/apps/sequence/graph/graph_view.cpp
@@ -1,4 +1,5 @@
 #include "graph_view.h"
+#include <cmath>
 
 using namespace Shared;
 
@@ -26,7 +27,7 @@ void GraphView::drawRect(KDContext * ctx, KDRect rect) const {
     /* We draw a dot at every integer if WindowRange/Resolution < 1. Otherwise,
      * we draw a dot at every step where step is an integer wider than 1. */
     float windowRange = pixelToFloat(Axis::Horizontal, bounds().width()) - pixelToFloat(Axis::Horizontal, 0);
-    int step = ceilf(windowRange/resolution());
+    int step = std::ceil(windowRange/resolution());
     for (int x = rectXMin; x < rectXMax; x += step) {
       float y = evaluateModelWithParameter(s, x);
       if (isnan(y)) {
diff --git a/apps/sequence/graph/term_sum_controller.cpp b/apps/sequence/graph/term_sum_controller.cpp
index f7ef67f30..9b607a678 100644
--- a/apps/sequence/graph/term_sum_controller.cpp
+++ b/apps/sequence/graph/term_sum_controller.cpp
@@ -6,7 +6,7 @@
 #include "../../../poincare/src/layout/horizontal_layout.h"
 
 #include <assert.h>
-#include <math.h>
+#include <cmath>
 #include <stdlib.h>
 
 using namespace Shared;
@@ -64,14 +64,14 @@ bool TermSumController::handleEvent(Ion::Events::Event event) {
     if (m_step > 0 && m_startSum >= m_cursor->x()) {
       return false;
     }
-    if (moveCursorHorizontallyToPosition(roundf(m_cursor->x()-1.0f))) {
+    if (moveCursorHorizontallyToPosition(std::round(m_cursor->x()-1.0f))) {
       m_graphView->reload();
       return true;
     }
     return false;
   }
   if (event == Ion::Events::Right) {
-    if (moveCursorHorizontallyToPosition(roundf(m_cursor->x()+1.0f))) {
+    if (moveCursorHorizontallyToPosition(std::round(m_cursor->x()+1.0f))) {
       m_graphView->reload();
       return true;
     }
diff --git a/apps/sequence/local_context.cpp b/apps/sequence/local_context.cpp
index 604362555..7218eddc2 100644
--- a/apps/sequence/local_context.cpp
+++ b/apps/sequence/local_context.cpp
@@ -1,4 +1,5 @@
 #include "local_context.h"
+#include <math.h>
 
 using namespace Poincare;
 
diff --git a/apps/sequence/sequence.cpp b/apps/sequence/sequence.cpp
index 5155d1069..029e449e6 100644
--- a/apps/sequence/sequence.cpp
+++ b/apps/sequence/sequence.cpp
@@ -4,6 +4,7 @@
 #include "../../poincare/src/layout/baseline_relative_layout.h"
 #include <assert.h>
 #include <string.h>
+#include <cmath>
 
 using namespace Shared;
 using namespace Poincare;
@@ -272,7 +273,7 @@ bool Sequence::isEmpty() {
 }
 
 float Sequence::evaluateAtAbscissa(float x, Poincare::Context * context) const {
-  float n = roundf(x);
+  float n = std::round(x);
   switch (m_type) {
     case Type::Explicite:
       if (n < 0) {
@@ -345,7 +346,7 @@ float Sequence::sumOfTermsBetweenAbscissa(float start, float end, Context * cont
   if (end-start > k_maxNumberOfTermsInSum || start + 1.0f == start) {
     return NAN;
   }
-  for (float i = roundf(start); i <= roundf(end); i = i + 1.0f) {
+  for (float i = std::round(start); i <= std::round(end); i = i + 1.0f) {
     /* When |start| >> 1.0f, start + 1.0f = start. In that case, quit the
      * infinite loop. */
     if (i == i-1.0f || i == i+1.0f) {
diff --git a/apps/sequence/values/interval_parameter_controller.cpp b/apps/sequence/values/interval_parameter_controller.cpp
index 9ca05d64e..dcfb55b7c 100644
--- a/apps/sequence/values/interval_parameter_controller.cpp
+++ b/apps/sequence/values/interval_parameter_controller.cpp
@@ -1,4 +1,5 @@
 #include "interval_parameter_controller.h"
+#include <cmath>
 
 using namespace Shared;
 
@@ -24,7 +25,7 @@ bool IntervalParameterController::setParameterAtIndex(int parameterIndex, float
     app()->displayWarning(I18n::Message::ForbiddenValue);
     return false;
   }
-  float parameter = roundf(f);
+  float parameter = std::round(f);
   if (parameterIndex == 2 && parameter == 0.0f) {
     parameter = 1.0f;
   }
diff --git a/apps/sequence/values/values_controller.cpp b/apps/sequence/values/values_controller.cpp
index bf2278a32..fe4526e9d 100644
--- a/apps/sequence/values/values_controller.cpp
+++ b/apps/sequence/values/values_controller.cpp
@@ -1,5 +1,6 @@
 #include "values_controller.h"
 #include <assert.h>
+#include <cmath>
 
 using namespace Shared;
 
@@ -49,7 +50,7 @@ bool ValuesController::setDataAtLocation(float floatBody, int columnIndex, int r
   if (floatBody < 0) {
       return false;
   }
-  return Shared::ValuesController::setDataAtLocation(roundf(floatBody), columnIndex, rowIndex);
+  return Shared::ValuesController::setDataAtLocation(std::round(floatBody), columnIndex, rowIndex);
 }
 
 int ValuesController::maxNumberOfCells() {
diff --git a/apps/shared/curve_view.cpp b/apps/shared/curve_view.cpp
index 0a9031b39..1f0c0ec79 100644
--- a/apps/shared/curve_view.cpp
+++ b/apps/shared/curve_view.cpp
@@ -2,7 +2,7 @@
 #include "../constant.h"
 #include <assert.h>
 #include <string.h>
-#include <math.h>
+#include <cmath>
 #include <float.h>
 
 using namespace Poincare;
@@ -117,7 +117,7 @@ void CurveView::computeLabels(Axis axis) {
   char buffer[Complex::bufferSizeForFloatsWithPrecision(Constant::ShortNumberOfSignificantDigits)];
   float step = gridUnit(axis);
   for (int index = 0; index < numberOfLabels(axis); index++) {
-    float labelValue = 2.0f*step*(ceilf(min(axis)/(2.0f*step)))+index*2.0f*step;
+    float labelValue = 2.0f*step*(std::ceil(min(axis)/(2.0f*step)))+index*2.0f*step;
     if (labelValue < step && labelValue > -step) {
       labelValue = 0.0f;
     }
@@ -131,7 +131,7 @@ void CurveView::computeLabels(Axis axis) {
 
 void CurveView::drawLabels(KDContext * ctx, KDRect rect, Axis axis, bool shiftOrigin) const {
   float step = gridUnit(axis);
-  float start = 2.0f*step*(ceilf(min(axis)/(2.0f*step)));
+  float start = 2.0f*step*(std::ceil(min(axis)/(2.0f*step)));
   float end = max(axis);
   int i = 0;
   for (float x = start; x < end; x += 2.0f*step) {
@@ -184,14 +184,14 @@ void CurveView::drawSegment(KDContext * ctx, KDRect rect, Axis axis, float coord
   switch(axis) {
     case Axis::Horizontal:
       lineRect = KDRect(
-          roundf(floatToPixel(Axis::Horizontal, lowerBound)), roundf(floatToPixel(Axis::Vertical, coordinate)),
-          roundf(floatToPixel(Axis::Horizontal, upperBound) - floatToPixel(Axis::Horizontal, lowerBound)), thickness
+          std::round(floatToPixel(Axis::Horizontal, lowerBound)), std::round(floatToPixel(Axis::Vertical, coordinate)),
+          std::round(floatToPixel(Axis::Horizontal, upperBound) - floatToPixel(Axis::Horizontal, lowerBound)), thickness
           );
       break;
     case Axis::Vertical:
       lineRect = KDRect(
-          roundf(floatToPixel(Axis::Horizontal, coordinate)), roundf(floatToPixel(Axis::Vertical, upperBound)),
-          thickness,  roundf(floatToPixel(Axis::Vertical, lowerBound) - floatToPixel(Axis::Vertical, upperBound))
+          std::round(floatToPixel(Axis::Horizontal, coordinate)), std::round(floatToPixel(Axis::Vertical, upperBound)),
+          thickness,  std::round(floatToPixel(Axis::Vertical, lowerBound) - floatToPixel(Axis::Vertical, upperBound))
       );
       break;
   }
@@ -225,8 +225,8 @@ KDColor s_dotWorkingBuffer[dotDiameter*dotDiameter];
 KDColor s_oversizeDotWorkingBuffer[oversizeDotDiameter*oversizeDotDiameter];
 
 void CurveView::drawDot(KDContext * ctx, KDRect rect, float x, float y, KDColor color, bool oversize) const {
-  KDCoordinate px = roundf(floatToPixel(Axis::Horizontal, x));
-  KDCoordinate py = roundf(floatToPixel(Axis::Vertical, y));
+  KDCoordinate px = std::round(floatToPixel(Axis::Horizontal, x));
+  KDCoordinate py = std::round(floatToPixel(Axis::Vertical, y));
   if ((px + dotDiameter < rect.left() - k_externRectMargin || px - dotDiameter > rect.right() + k_externRectMargin) ||
       (py + dotDiameter < rect.top() - k_externRectMargin || py - dotDiameter > rect.bottom() + k_externRectMargin)) {
     return;
@@ -320,9 +320,9 @@ void CurveView::drawCurve(KDContext * ctx, KDRect rect, Model * curve, KDColor c
     float pxf = floatToPixel(Axis::Horizontal, x);
     float pyf = floatToPixel(Axis::Vertical, y);
     if (colorUnderCurve && x > colorLowerBound && x < colorUpperBound) {
-      KDRect colorRect((int)pxf, roundf(pyf), 1, floatToPixel(Axis::Vertical, 0.0f) - roundf(pyf));
-      if (floatToPixel(Axis::Vertical, 0.0f) < roundf(pyf)) {
-        colorRect = KDRect((int)pxf, floatToPixel(Axis::Vertical, 0.0f), 1, roundf(pyf) - floatToPixel(Axis::Vertical, 0.0f));
+      KDRect colorRect((int)pxf, std::round(pyf), 1, floatToPixel(Axis::Vertical, 0.0f) - std::round(pyf));
+      if (floatToPixel(Axis::Vertical, 0.0f) < std::round(pyf)) {
+        colorRect = KDRect((int)pxf, floatToPixel(Axis::Vertical, 0.0f), 1, std::round(pyf) - floatToPixel(Axis::Vertical, 0.0f));
       }
       ctx->fillRect(colorRect, color);
     }
@@ -343,10 +343,10 @@ void CurveView::drawCurve(KDContext * ctx, KDRect rect, Model * curve, KDColor c
 void CurveView::drawHistogram(KDContext * ctx, KDRect rect, Model * model, float firstBarAbscissa, float barWidth,
     bool fillBar, KDColor defaultColor, KDColor highlightColor,  float highlightLowerBound, float highlightUpperBound) const {
   float rectMin = pixelToFloat(Axis::Horizontal, rect.left());
-  int rectMinBinNumber = floorf((rectMin - firstBarAbscissa)/barWidth);
+  int rectMinBinNumber = std::floor((rectMin - firstBarAbscissa)/barWidth);
   float rectMinLowerBound = firstBarAbscissa + rectMinBinNumber*barWidth;
   float rectMax = pixelToFloat(Axis::Horizontal, rect.right());
-  int rectMaxBinNumber = floorf((rectMax - firstBarAbscissa)/barWidth);
+  int rectMaxBinNumber = std::floor((rectMax - firstBarAbscissa)/barWidth);
   float rectMaxUpperBound = firstBarAbscissa + (rectMaxBinNumber+1)*barWidth + barWidth;
   float pHighlightLowerBound = floatToPixel(Axis::Horizontal, highlightLowerBound);
   float pHighlightUpperBound = floatToPixel(Axis::Horizontal, highlightUpperBound);
@@ -361,15 +361,15 @@ void CurveView::drawHistogram(KDContext * ctx, KDRect rect, Model * model, float
     if (isnan(y)) {
       continue;
     }
-    KDCoordinate pxf = roundf(floatToPixel(Axis::Horizontal, x));
-    KDCoordinate pyf = roundf(floatToPixel(Axis::Vertical, y));
-    KDCoordinate pixelBarWidth = fillBar ? roundf(floatToPixel(Axis::Horizontal, x+barWidth)) - roundf(floatToPixel(Axis::Horizontal, x))-1 : 2;
+    KDCoordinate pxf = std::round(floatToPixel(Axis::Horizontal, x));
+    KDCoordinate pyf = std::round(floatToPixel(Axis::Vertical, y));
+    KDCoordinate pixelBarWidth = fillBar ? std::round(floatToPixel(Axis::Horizontal, x+barWidth)) - std::round(floatToPixel(Axis::Horizontal, x))-1 : 2;
     KDRect binRect(pxf, pyf, pixelBarWidth, floatToPixel(Axis::Vertical, 0.0f) - pyf);
     if (floatToPixel(Axis::Vertical, 0.0f) < pyf) {
       binRect = KDRect(pxf, floatToPixel(Axis::Vertical, 0.0f), pixelBarWidth+1, pyf - floatToPixel(Axis::Vertical, 0.0f));
     }
     KDColor binColor = defaultColor;
-    if (pxf >= floorf(pHighlightLowerBound) && pxf <= floorf(pHighlightUpperBound)) {
+    if (pxf >= std::floor(pHighlightLowerBound) && pxf <= std::floor(pHighlightUpperBound)) {
       binColor = highlightColor;
     }
     ctx->fillRect(binRect, binColor);
@@ -381,7 +381,7 @@ int CurveView::numberOfLabels(Axis axis) const {
   if (min(otherAxis) > 0.0f || max(otherAxis) < 0.0f) {
     return 0;
   }
-  return ceilf((max(axis) - min(axis))/(2*gridUnit(axis)));
+  return std::ceil((max(axis) - min(axis))/(2*gridUnit(axis)));
 }
 
 float CurveView::evaluateModelWithParameter(Model * curve, float t) const {
@@ -460,8 +460,8 @@ void CurveView::stampAtLocation(KDContext * ctx, KDRect rect, float pxf, float p
   }
   uint8_t shiftedMask[stampSize][stampSize];
   KDColor workingBuffer[stampSize*stampSize];
-  float dx = pxf - floorf(pxf);
-  float dy = pyf - floorf(pyf);
+  float dx = pxf - std::floor(pxf);
+  float dy = pyf - std::floor(pyf);
   /* TODO: this could be optimized by precomputing 10 or 100 shifted masks. The
    * dx and dy would be rounded to one tenth or one hundredth to choose the
    * right shifted mask. */
@@ -476,8 +476,8 @@ void CurveView::stampAtLocation(KDContext * ctx, KDRect rect, float pxf, float p
 
 void CurveView::layoutSubviews() {
   if (m_curveViewCursor != nullptr && m_cursorView != nullptr) {
-    KDCoordinate xCursorPixelPosition = roundf(floatToPixel(Axis::Horizontal, m_curveViewCursor->x()));
-    KDCoordinate yCursorPixelPosition = roundf(floatToPixel(Axis::Vertical, m_curveViewCursor->y()));
+    KDCoordinate xCursorPixelPosition = std::round(floatToPixel(Axis::Horizontal, m_curveViewCursor->x()));
+    KDCoordinate yCursorPixelPosition = std::round(floatToPixel(Axis::Vertical, m_curveViewCursor->y()));
     KDRect cursorFrame(xCursorPixelPosition - cursorSize().width()/2, yCursorPixelPosition - cursorSize().height()/2, cursorSize().width(), cursorSize().height());
     if (cursorSize().height() == 0) {
       KDCoordinate bannerHeight = m_bannerView != nullptr ? m_bannerView->minimalSizeForOptimalDisplay().height() : 0;
diff --git a/apps/shared/curve_view.h b/apps/shared/curve_view.h
index ba7477e59..56e075965 100644
--- a/apps/shared/curve_view.h
+++ b/apps/shared/curve_view.h
@@ -3,10 +3,10 @@
 
 #include <escher.h>
 #include <poincare.h>
+#include <math.h>
 #include "curve_view_range.h"
 #include "curve_view_cursor.h"
 #include "banner_view.h"
-#include <math.h>
 
 namespace Shared {
 
diff --git a/apps/shared/curve_view_range.cpp b/apps/shared/curve_view_range.cpp
index 1c3ddafc4..62a688612 100644
--- a/apps/shared/curve_view_range.cpp
+++ b/apps/shared/curve_view_range.cpp
@@ -1,5 +1,5 @@
 #include "curve_view_range.h"
-#include <math.h>
+#include <cmath>
 #include <ion.h>
 #include <assert.h>
 #include <stddef.h>
@@ -31,12 +31,12 @@ float CurveViewRange::computeGridUnit(Axis axis, float min, float max) {
   float units[3] = {k_smallGridUnitMantissa, k_mediumGridUnitMantissa, k_largeGridUnitMantissa};
   for (int k = 0; k < 3; k++) {
     float unit = units[k];
-    if (floorf(log10f(d/(unit*maxNumberOfUnits))) != floorf(log10f(d/(unit*minNumberOfUnits)))) {
-      b = floorf(log10f(d/(unit*minNumberOfUnits)));
+    if (std::floor(std::log10(d/(unit*maxNumberOfUnits))) != std::floor(std::log10(d/(unit*minNumberOfUnits)))) {
+      b = std::floor(std::log10(d/(unit*minNumberOfUnits)));
       a = unit;
     }
   }
-  return a*powf(10,b);
+  return a*std::pow(10.0f,b);
 }
 
 }
diff --git a/apps/shared/function_go_to_parameter_controller.cpp b/apps/shared/function_go_to_parameter_controller.cpp
index 89aeb8866..34d355701 100644
--- a/apps/shared/function_go_to_parameter_controller.cpp
+++ b/apps/shared/function_go_to_parameter_controller.cpp
@@ -1,6 +1,7 @@
 #include "function_go_to_parameter_controller.h"
 #include "text_field_delegate_app.h"
 #include <assert.h>
+#include <cmath>
 
 namespace Shared {
 
@@ -23,7 +24,7 @@ bool FunctionGoToParameterController::setParameterAtIndex(int parameterIndex, fl
   assert(parameterIndex == 0);
   TextFieldDelegateApp * myApp = (TextFieldDelegateApp *)app();
   float y = m_function->evaluateAtAbscissa(f, myApp->localContext());
-  if (fabsf(f) > k_maxDisplayableFloat || fabsf(y) > k_maxDisplayableFloat) {
+  if (std::fabs(f) > k_maxDisplayableFloat || std::fabs(y) > k_maxDisplayableFloat) {
     app()->displayWarning(I18n::Message::ForbiddenValue);
     return false;
   }
diff --git a/apps/shared/interactive_curve_view_range.cpp b/apps/shared/interactive_curve_view_range.cpp
index c0da85988..538e7c8bf 100644
--- a/apps/shared/interactive_curve_view_range.cpp
+++ b/apps/shared/interactive_curve_view_range.cpp
@@ -1,7 +1,7 @@
 #include "interactive_curve_view_range.h"
 #include <poincare.h>
 #include <ion.h>
-#include <math.h>
+#include <cmath>
 #include <stddef.h>
 #include <assert.h>
 
@@ -90,7 +90,7 @@ void InteractiveCurveViewRange::zoom(float ratio, float x, float y) {
   float xMax = m_xMax;
   float yMin = m_yMin;
   float yMax = m_yMax;
-  if (ratio*fabsf(xMax-xMin) < k_minFloat || ratio*fabsf(yMax-yMin) < k_minFloat) {
+  if (ratio*std::fabs(xMax-xMin) < k_minFloat || ratio*std::fabs(yMax-yMin) < k_minFloat) {
     return;
   }
   float newXMin = clipped(x*(1.0f-ratio)+ratio*xMin, false);
@@ -122,8 +122,8 @@ void InteractiveCurveViewRange::panWithVector(float x, float y) {
 void InteractiveCurveViewRange::roundAbscissa() {
   float xMin = m_xMin;
   float xMax = m_xMax;
-  float newXMin = clipped(roundf((xMin+xMax)/2) - (float)Ion::Display::Width/2.0f, false);
-  float newXMax = clipped(roundf((xMin+xMax)/2) + (float)Ion::Display::Width/2.0f-1.0f, true);
+  float newXMin = clipped(std::round((xMin+xMax)/2) - (float)Ion::Display::Width/2.0f, false);
+  float newXMax = clipped(std::round((xMin+xMax)/2) + (float)Ion::Display::Width/2.0f-1.0f, true);
   if (isnan(newXMin) || isnan(newXMax)) {
     return;
   }
@@ -178,16 +178,16 @@ void InteractiveCurveViewRange::centerAxisAround(Axis axis, float position) {
   }
   if (axis == Axis::X) {
     float range = m_xMax - m_xMin;
-    if (fabsf(position/range) > k_maxRatioPositionRange) {
-      range = powf(10.0f, floorf(log10f(fabsf(position)))-1.0f);
+    if (std::fabs(position/range) > k_maxRatioPositionRange) {
+      range = std::pow(10.0f, std::floor(std::log10(std::fabs(position)))-1.0f);
     }
     m_xMax = clipped(position + range/2.0f, true);
     MemoizedCurveViewRange::setXMin(clipped(position - range/2.0f, false));
   } else {
     m_yAuto = false;
     float range = m_yMax - m_yMin;
-    if (fabsf(position/range) > k_maxRatioPositionRange) {
-      range = powf(10.0f, floorf(log10f(fabsf(position)))-1.0f);
+    if (std::fabs(position/range) > k_maxRatioPositionRange) {
+      range = std::pow(10.0f, std::floor(std::log10(std::fabs(position)))-1.0f);
     }
     m_yMax = clipped(position + range/2.0f, true);
     MemoizedCurveViewRange::setYMin(clipped(position - range/2.0f, false));
diff --git a/apps/shared/interactive_curve_view_range_delegate.cpp b/apps/shared/interactive_curve_view_range_delegate.cpp
index 482367d9b..3f1b1f4e0 100644
--- a/apps/shared/interactive_curve_view_range_delegate.cpp
+++ b/apps/shared/interactive_curve_view_range_delegate.cpp
@@ -1,7 +1,7 @@
 #include "interactive_curve_view_range_delegate.h"
 #include "interactive_curve_view_range.h"
 #include <float.h>
-#include <math.h>
+#include <cmath>
 
 namespace Shared {
 
@@ -30,11 +30,11 @@ bool InteractiveCurveViewRangeDelegate::didChangeRange(InteractiveCurveViewRange
     max = 1.0f;
   }
   if (min == FLT_MAX) {
-    float step = max != 0.0f ? interactiveCurveViewRange->computeGridUnit(CurveViewRange::Axis::Y, 0.0f, fabsf(max)) : 1.0f;
+    float step = max != 0.0f ? interactiveCurveViewRange->computeGridUnit(CurveViewRange::Axis::Y, 0.0f, std::fabs(max)) : 1.0f;
     min = max-step;
   }
    if (max == -FLT_MAX) {
-    float step = min != 0.0f ? interactiveCurveViewRange->computeGridUnit(CurveViewRange::Axis::Y, 0.0f, fabsf(min)) : 1.0f;
+    float step = min != 0.0f ? interactiveCurveViewRange->computeGridUnit(CurveViewRange::Axis::Y, 0.0f, std::fabs(min)) : 1.0f;
     max = min+step;
   }
   interactiveCurveViewRange->setYMin(addMargin(min, range, true));
diff --git a/apps/shared/memoized_curve_view_range.cpp b/apps/shared/memoized_curve_view_range.cpp
index 53e89810f..b69e00798 100644
--- a/apps/shared/memoized_curve_view_range.cpp
+++ b/apps/shared/memoized_curve_view_range.cpp
@@ -1,5 +1,5 @@
 #include "memoized_curve_view_range.h"
-#include <math.h>
+#include <cmath>
 #include <assert.h>
 #include <ion.h>
 
@@ -45,7 +45,7 @@ void MemoizedCurveViewRange::setXMin(float xMin) {
   }
   m_xMin = xMin;
   if (m_xMin >= m_xMax) {
-    m_xMax = xMin + powf(10.0f, floorf(log10f(fabsf(xMin)))-1.0f);
+    m_xMax = xMin + std::pow(10.0f, std::floor(std::log10(std::fabs(xMin)))-1.0f);
   }
   m_xGridUnit = computeGridUnit(Axis::X, m_xMin, m_xMax);
 }
@@ -56,7 +56,7 @@ void MemoizedCurveViewRange::setXMax(float xMax) {
   }
   m_xMax = xMax;
   if (m_xMin >= m_xMax) {
-    m_xMin = xMax - powf(10.0f, floorf(log10f(fabsf(xMax)))-1.0f);
+    m_xMin = xMax - std::pow(10.0f, std::floor(std::log10(std::fabs(xMax)))-1.0f);
   }
   m_xGridUnit = computeGridUnit(Axis::X, m_xMin, m_xMax);
 }
@@ -67,7 +67,7 @@ void MemoizedCurveViewRange::setYMin(float yMin) {
   }
   m_yMin = yMin;
   if (m_yMin >= m_yMax) {
-    m_yMax = yMin + powf(10.0f, floorf(log10f(fabsf(yMin)))-1.0f);
+    m_yMax = yMin + std::pow(10.0f, std::floor(std::log10(std::fabs(yMin)))-1.0f);
   }
   m_yGridUnit = computeGridUnit(Axis::Y, m_yMin, m_yMax);
 }
@@ -78,7 +78,7 @@ void MemoizedCurveViewRange::setYMax(float yMax) {
   }
   m_yMax = yMax;
   if (m_yMin >= m_yMax) {
-    m_yMin = yMax - + powf(10.0f, floorf(log10f(fabsf(yMax)))-1.0f);
+    m_yMin = yMax - + std::pow(10.0f, std::floor(std::log10(std::fabs(yMax)))-1.0f);
 
   }
   m_yGridUnit = computeGridUnit(Axis::Y, m_yMin, m_yMax);
diff --git a/apps/statistics/box_controller.cpp b/apps/statistics/box_controller.cpp
index cbdc9efee..a686fe6a7 100644
--- a/apps/statistics/box_controller.cpp
+++ b/apps/statistics/box_controller.cpp
@@ -1,7 +1,6 @@
 #include "box_controller.h"
 #include "app.h"
 #include "../apps_container.h"
-#include <math.h>
 
 using namespace Poincare;
 
diff --git a/apps/statistics/box_view.cpp b/apps/statistics/box_view.cpp
index 690f96be0..921efedcc 100644
--- a/apps/statistics/box_view.cpp
+++ b/apps/statistics/box_view.cpp
@@ -1,6 +1,6 @@
 #include "box_view.h"
 #include <assert.h>
-#include <math.h>
+#include <cmath>
 
 using namespace Shared;
 
@@ -50,8 +50,8 @@ void BoxView::drawRect(KDContext * ctx, KDRect rect) const {
   float lowBound = 0.35f;
   float upBound = 0.65f;
   // Draw the main box
-  KDCoordinate firstQuartilePixels = roundf(floatToPixel(Axis::Horizontal, m_store->firstQuartile()));
-  KDCoordinate thirdQuartilePixels = roundf(floatToPixel(Axis::Horizontal, m_store->thirdQuartile()));
+  KDCoordinate firstQuartilePixels = std::round(floatToPixel(Axis::Horizontal, m_store->firstQuartile()));
+  KDCoordinate thirdQuartilePixels = std::round(floatToPixel(Axis::Horizontal, m_store->thirdQuartile()));
   KDCoordinate lowBoundPixel = floatToPixel(Axis::Vertical, upBound);
   KDCoordinate upBoundPixel = floatToPixel(Axis::Vertical, lowBound);
   ctx->fillRect(KDRect(firstQuartilePixels, lowBoundPixel, thirdQuartilePixels - firstQuartilePixels+2,
diff --git a/apps/statistics/histogram_controller.cpp b/apps/statistics/histogram_controller.cpp
index 7cebf0a68..164f08939 100644
--- a/apps/statistics/histogram_controller.cpp
+++ b/apps/statistics/histogram_controller.cpp
@@ -2,7 +2,6 @@
 #include "../apps_container.h"
 #include "app.h"
 #include <assert.h>
-#include <math.h>
 #include <float.h>
 
 using namespace Poincare;
diff --git a/apps/statistics/histogram_parameter_controller.cpp b/apps/statistics/histogram_parameter_controller.cpp
index 0f4f15b97..7f4a31fbe 100644
--- a/apps/statistics/histogram_parameter_controller.cpp
+++ b/apps/statistics/histogram_parameter_controller.cpp
@@ -1,6 +1,7 @@
 #include "histogram_parameter_controller.h"
 #include "app.h"
 #include <assert.h>
+#include <cmath>
 
 using namespace Shared;
 
@@ -42,7 +43,7 @@ float HistogramParameterController::parameterAtIndex(int index) {
 bool HistogramParameterController::setParameterAtIndex(int parameterIndex, float f) {
   assert(parameterIndex >= 0 && parameterIndex < k_numberOfCells);
   if (parameterIndex == 0) {
-    float newNumberOfBars = ceilf((m_store->maxValue() - m_store->minValue())/f);
+    float newNumberOfBars = std::ceil((m_store->maxValue() - m_store->minValue())/f);
     if (f <= 0.0f || newNumberOfBars > Store::k_maxNumberOfBars) {
       app()->displayWarning(I18n::Message::ForbiddenValue);
       return false;
diff --git a/apps/statistics/store.cpp b/apps/statistics/store.cpp
index a0c3e0668..908aed90b 100644
--- a/apps/statistics/store.cpp
+++ b/apps/statistics/store.cpp
@@ -1,7 +1,7 @@
 #include "store.h"
 #include <assert.h>
 #include <float.h>
-#include <math.h>
+#include <cmath>
 #include <string.h>
 #include <ion.h>
 
@@ -51,14 +51,14 @@ float Store::heightOfBarAtIndex(int index) {
 
 float Store::heightOfBarAtValue(float value) {
   float width = barWidth();
-  int barNumber = floorf((value - m_firstDrawnBarAbscissa)/width);
+  int barNumber = std::floor((value - m_firstDrawnBarAbscissa)/width);
   float lowerBound = m_firstDrawnBarAbscissa + barNumber*width;
   float upperBound = m_firstDrawnBarAbscissa + (barNumber+1)*width;
   return sumOfValuesBetween(lowerBound, upperBound);
 }
 
 float Store::startOfBarAtIndex(int index) {
-  float firstBarAbscissa = m_firstDrawnBarAbscissa + m_barWidth*floorf((minValue()- m_firstDrawnBarAbscissa)/m_barWidth);
+  float firstBarAbscissa = m_firstDrawnBarAbscissa + m_barWidth*std::floor((minValue()- m_firstDrawnBarAbscissa)/m_barWidth);
   return firstBarAbscissa + index * m_barWidth;
 }
 
@@ -67,8 +67,8 @@ float Store::endOfBarAtIndex(int index) {
 }
 
 int Store::numberOfBars() {
-  float firstBarAbscissa = m_firstDrawnBarAbscissa + m_barWidth*floorf((minValue()- m_firstDrawnBarAbscissa)/m_barWidth);
-  return ceilf((maxValue() - firstBarAbscissa)/m_barWidth)+1;
+  float firstBarAbscissa = m_firstDrawnBarAbscissa + m_barWidth*std::floor((minValue()- m_firstDrawnBarAbscissa)/m_barWidth);
+  return std::ceil((maxValue() - firstBarAbscissa)/m_barWidth)+1;
 }
 
 bool Store::scrollToSelectedBarIndex(int index) {
@@ -129,16 +129,16 @@ float Store::variance() {
 }
 
 float Store::standardDeviation() {
-  return sqrtf(variance());
+  return std::sqrt(variance());
 }
 
 float Store::firstQuartile() {
-  int firstQuartileIndex = ceilf(sumOfColumn(1)/4);
+  int firstQuartileIndex = std::ceil(sumOfColumn(1)/4);
   return sortedElementNumber(firstQuartileIndex);
 }
 
 float Store::thirdQuartile() {
-  int thirdQuartileIndex = ceilf(3*sumOfColumn(1)/4);
+  int thirdQuartileIndex = std::ceil(3*sumOfColumn(1)/4);
   return sortedElementNumber(thirdQuartileIndex);
 }
 
diff --git a/apps/statistics/store_controller.cpp b/apps/statistics/store_controller.cpp
index 65848f7b8..86f2264cf 100644
--- a/apps/statistics/store_controller.cpp
+++ b/apps/statistics/store_controller.cpp
@@ -3,6 +3,7 @@
 #include "../apps_container.h"
 #include "../constant.h"
 #include <assert.h>
+#include <cmath>
 
 using namespace Shared;
 
@@ -37,7 +38,7 @@ bool StoreController::setDataAtLocation(float floatBody, int columnIndex, int ro
     if (floatBody < 0) {
       return false;
     }
-    m_store->set(roundf(floatBody), columnIndex, rowIndex-1);
+    m_store->set(std::round(floatBody), columnIndex, rowIndex-1);
     return true;
   }
   return Shared::StoreController::setDataAtLocation(floatBody, columnIndex, rowIndex);
diff --git a/escher/src/button_row_controller.cpp b/escher/src/button_row_controller.cpp
index 8775766c8..537a41c53 100644
--- a/escher/src/button_row_controller.cpp
+++ b/escher/src/button_row_controller.cpp
@@ -1,7 +1,7 @@
 #include <escher/button_row_controller.h>
 #include <escher/palette.h>
 #include <assert.h>
-#include <math.h>
+#include <cmath>
 
 ButtonRowDelegate::ButtonRowDelegate(ButtonRowController * header, ButtonRowController * footer) :
   m_header(header),
@@ -85,7 +85,7 @@ void ButtonRowController::ContentView::layoutSubviews() {
       Button * button = buttonAtIndex(i);
       totalButtonWidth += button->minimalSizeForOptimalDisplay().width();
     }
-    widthMargin = roundf((bounds().width() - totalButtonWidth)/(nbOfButtons+1));
+    widthMargin = std::round((float)((bounds().width() - totalButtonWidth)/(nbOfButtons+1)));
     buttonHeightMargin = k_embossedStyleHeightMargin;
     buttonHeight = rowHeight- 2*k_embossedStyleHeightMargin;
   }
@@ -131,7 +131,7 @@ void ButtonRowController::ContentView::drawRect(KDContext * ctx, KDRect rect) co
     Button * button = buttonAtIndex(i);
     totalButtonWidth += button->minimalSizeForOptimalDisplay().width();
   }
-  KDCoordinate widthMargin = roundf((bounds().width() - totalButtonWidth)/(numberOfButtons()+1));
+  KDCoordinate widthMargin = std::round((float)((bounds().width() - totalButtonWidth)/(numberOfButtons()+1)));
 
   int currentXOrigin = widthMargin-1;
   for (int i = 0; i < numberOfButtons(); i++) {
diff --git a/liba/include/math.h b/liba/include/math.h
index a91df66fd..a9f7ec0e5 100644
--- a/liba/include/math.h
+++ b/liba/include/math.h
@@ -8,8 +8,8 @@ LIBA_BEGIN_DECLS
 
 #define NAN (0.0f/0.0f)
 #define INFINITY __builtin_inff()
-#define M_E 2.71828182845904523536028747135266250f
-#define M_PI 3.14159265358979323846264338327950288f
+#define M_E 2.71828182845904523536028747135266250
+#define M_PI 3.14159265358979323846264338327950288
 
 /* The C99 standard requires isinf and isnan to be defined as macros that can
  * handle arbitrary precision float numbers. The names of the functions called
diff --git a/libaxx/include/cmath b/libaxx/include/cmath
new file mode 100644
index 000000000..1807614ae
--- /dev/null
+++ b/libaxx/include/cmath
@@ -0,0 +1,59 @@
+#ifndef LIBAXX_CMATH
+#define LIBAXX_CMATH
+
+extern "C" {
+#include <math.h>
+}
+
+namespace std {
+
+static inline double acos(double x) { return ::acos(x); }
+static inline float acos(float x) { return ::acosf(x); }
+static inline double acosh(double x) { return ::acosh(x); }
+static inline float acosh(float x) { return ::acoshf(x); }
+static inline double asin(double x) { return ::asin(x); }
+static inline float asin(float x) { return ::asinf(x); }
+static inline double asinh(double x) { return ::asinh(x); }
+static inline float asinh(float x) { return ::asinhf(x); }
+static inline double atan(double x) { return ::atan(x); }
+static inline float atan(float x) { return ::atanf(x); }
+static inline double atanh(double x) { return ::atanh(x); }
+static inline float atanh(float x) { return ::atanhf(x); }
+static inline double ceil(double x) { return ::ceil(x); }
+static inline float ceil(float x) { return ::ceilf(x); }
+static inline double copysign(double x, double y) { return ::copysign(x, y); }
+static inline float copysign(float x, float y) { return ::copysignf(x, y); }
+static inline double cos(double x) { return ::cos(x); }
+static inline float cos(float x) { return ::cosf(x); }
+static inline double cosh(double x) { return ::cosh(x); }
+static inline float cosh(float x) { return ::coshf(x); }
+static inline double exp(double x) { return ::exp(x); }
+static inline float exp(float x) { return ::expf(x); }
+static inline double fabs(double x) { return ::fabs(x); }
+static inline float fabs(float x) { return ::fabsf(x); }
+static inline double floor(double x) { return ::floor(x); }
+static inline float floor(float x) { return ::floorf(x); }
+static inline double lgamma(double x) { return ::lgamma(x); }
+static inline float lgamma(float x) { return ::lgammaf(x); }
+static inline double log10(double x) { return ::log10(x); }
+static inline float log10(float x) { return ::log10f(x); }
+static inline double log(double x) { return ::log(x); }
+static inline float log(float x) { return ::logf(x); }
+static inline double pow(double x, double y) { return ::pow(x, y); }
+static inline float pow(float x, float y) { return ::powf(x, y); }
+static inline double round(double x) { return ::round(x); }
+static inline float round(float x) { return ::roundf(x); }
+static inline double sin(double x) { return ::sin(x); }
+static inline float sin(float x) { return ::sinf(x); }
+static inline double sinh(double x) { return ::sinh(x); }
+static inline float sinh(float x) { return ::sinhf(x); }
+static inline double sqrt(double x) { return ::sqrt(x); }
+static inline float sqrt(float x) { return ::sqrtf(x); }
+static inline double tan(double x) { return ::tan(x); }
+static inline float tan(float x) { return ::tanf(x); }
+static inline double tanh(double x) { return ::tanh(x); }
+static inline float tanh(float x) { return ::tanhf(x); }
+
+}
+
+#endif
diff --git a/poincare/include/poincare/complex.h b/poincare/include/poincare/complex.h
index 31a5d3c24..61f94c7a7 100644
--- a/poincare/include/poincare/complex.h
+++ b/poincare/include/poincare/complex.h
@@ -3,7 +3,6 @@
 
 #include <poincare/evaluation.h>
 #include <poincare/preferences.h>
-#include <math.h>
 
 namespace Poincare {
 
diff --git a/poincare/src/absolute_value.cpp b/poincare/src/absolute_value.cpp
index 9827cbe98..66673600e 100644
--- a/poincare/src/absolute_value.cpp
+++ b/poincare/src/absolute_value.cpp
@@ -4,8 +4,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/arc_cosine.cpp b/poincare/src/arc_cosine.cpp
index 33062c46d..b47525e43 100644
--- a/poincare/src/arc_cosine.cpp
+++ b/poincare/src/arc_cosine.cpp
@@ -1,8 +1,8 @@
 #include <poincare/arc_cosine.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -28,7 +28,7 @@ Complex ArcCosine::computeComplex(const Complex c, AngleUnit angleUnit) const {
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  float result = acosf(c.a());
+  float result = std::acos(c.a());
   if (angleUnit == AngleUnit::Degree) {
     return Complex::Float(result*180.0f/M_PI);
   }
diff --git a/poincare/src/arc_sine.cpp b/poincare/src/arc_sine.cpp
index 86a637b95..e940bc03c 100644
--- a/poincare/src/arc_sine.cpp
+++ b/poincare/src/arc_sine.cpp
@@ -1,8 +1,8 @@
 #include <poincare/arc_sine.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -28,7 +28,7 @@ Complex ArcSine::computeComplex(const Complex c, AngleUnit angleUnit) const {
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  float result = asinf(c.a());
+  float result = std::asin(c.a());
   if (angleUnit == AngleUnit::Degree) {
     return Complex::Float(result*180.0f/M_PI);
   }
diff --git a/poincare/src/arc_tangent.cpp b/poincare/src/arc_tangent.cpp
index 2334e7295..7ef3db844 100644
--- a/poincare/src/arc_tangent.cpp
+++ b/poincare/src/arc_tangent.cpp
@@ -1,8 +1,8 @@
 #include <poincare/arc_tangent.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -28,7 +28,7 @@ Complex ArcTangent::computeComplex(const Complex c, AngleUnit angleUnit) const {
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  float result = atanf(c.a());
+  float result = std::atan(c.a());
   if (angleUnit == AngleUnit::Degree) {
     return Complex::Float(result*180.0f/M_PI);
   }
diff --git a/poincare/src/binary_operation.cpp b/poincare/src/binary_operation.cpp
index fc243a327..94b39db55 100644
--- a/poincare/src/binary_operation.cpp
+++ b/poincare/src/binary_operation.cpp
@@ -1,8 +1,8 @@
 #include <poincare/binary_operation.h>
 #include <poincare/complex_matrix.h>
+#include <cmath>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 #include <stdlib.h>
 }
 
diff --git a/poincare/src/binomial_coefficient.cpp b/poincare/src/binomial_coefficient.cpp
index ca63c81e0..074d66e78 100644
--- a/poincare/src/binomial_coefficient.cpp
+++ b/poincare/src/binomial_coefficient.cpp
@@ -7,8 +7,8 @@
 extern "C" {
 #include <stdlib.h>
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -43,7 +43,7 @@ Evaluation * BinomialCoefficient::privateEvaluate(Context& context, AngleUnit an
   for (int i = 0; i < (int)k; i++) {
     result *= (n-(float)i)/(k-(float)i);
   }
-  return new Complex(Complex::Float(roundf(result)));
+  return new Complex(Complex::Float(std::round(result)));
 }
 
 ExpressionLayout * BinomialCoefficient::privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const {
diff --git a/poincare/src/ceiling.cpp b/poincare/src/ceiling.cpp
index 75e74e274..31750f21d 100644
--- a/poincare/src/ceiling.cpp
+++ b/poincare/src/ceiling.cpp
@@ -2,8 +2,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -28,7 +28,7 @@ Complex Ceiling::computeComplex(const Complex c, AngleUnit angleUnit) const {
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  return Complex::Float(ceilf(c.a()));
+  return Complex::Float(std::ceil(c.a()));
 }
 
 }
diff --git a/poincare/src/complex.cpp b/poincare/src/complex.cpp
index 96ed47a7e..47a75a9f2 100644
--- a/poincare/src/complex.cpp
+++ b/poincare/src/complex.cpp
@@ -3,9 +3,9 @@ extern "C" {
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
-#include <math.h>
 #include <float.h>
 }
+#include <cmath>
 #include <poincare/complex_matrix.h>
 #include "layout/string_layout.h"
 #include "layout/baseline_relative_layout.h"
@@ -22,7 +22,7 @@ Complex Complex::Cartesian(float a, float b) {
 }
 
 Complex Complex::Polar(float r, float th)  {
-  return Complex(r*cosf(th),r*sinf(th));
+  return Complex(r*std::cos(th),r*std::sin(th));
 }
 
 static inline float setSign(float f, bool negative) {
@@ -53,7 +53,7 @@ Complex::Complex(const char * integralPart, int integralPartLength, bool integra
   float j = digitsToFloat(fractionalPart, fractionalPartLength);
   float l = setSign(digitsToFloat(exponent, exponentLength), exponentNegative);
 
-  m_a = setSign((i + j*powf(10.0f, -ceilf(fractionalPartLength)))* powf(10.0f, l), integralNegative);
+  m_a = setSign((i + j*std::pow(10.0f, -std::ceil((float)fractionalPartLength)))* std::pow(10.0f, l), integralNegative);
   m_b = 0.0f;
 }
 
@@ -103,16 +103,16 @@ float Complex::b() const {
 
 float Complex::r() const {
   if (m_b == 0) {
-    return fabsf(m_a);
+    return std::fabs(m_a);
   }
-  return sqrtf(m_a*m_a + m_b*m_b);
+  return std::sqrt(m_a*m_a + m_b*m_b);
 }
 
 float Complex::th() const {
-  float result = atanf(m_b/m_a) + M_PI;
+  float result = std::atan(m_b/m_a) + M_PI;
   if (m_a >= 0.0f) {
     float a = m_a == 0.0f ? 0.0f : m_a;
-    result = atanf(m_b/a);
+    result = std::atan(m_b/a);
   }
   if (result > M_PI + FLT_EPSILON) {
     result = result - 2.0f*M_PI;
@@ -255,11 +255,11 @@ int Complex::convertFloatToTextPrivate(float f, char * buffer, int numberOfSigni
     return currentChar;
   }
 
-  float logBase10 = f != 0.0f ? log10f(fabsf(f)) : 0;
-  int exponentInBase10 = floorf(logBase10);
+  float logBase10 = f != 0.0f ? std::log10(std::fabs(f)) : 0;
+  int exponentInBase10 = std::floor(logBase10);
   /* Correct the exponent in base 10: sometines the exact log10 of f is 6.999999
    * but is stored as 7 in hardware. We catch these cases here. */
-  if (f != 0.0f && logBase10 == (int)logBase10 && fabsf(f) < powf(10.0f, logBase10)) {
+  if (f != 0.0f && logBase10 == (int)logBase10 && std::fabs(f) < std::pow(10.0f, logBase10)) {
     exponentInBase10--;
   }
 
@@ -276,49 +276,49 @@ int Complex::convertFloatToTextPrivate(float f, char * buffer, int numberOfSigni
   /* The number of digits in an integer is capped because the maximal integer is
    * 2^31 - 1. As our mantissa is an integer, we assert that we stay beyond this
    * threshold during computation. */
-  assert(availableCharsForMantissaWithoutSign - 1 < log10f(powf(2, 31)));
+  assert(availableCharsForMantissaWithoutSign - 1 < std::log10(std::pow(2.0f, 31.0f)));
 
   int numberOfDigitBeforeDecimal = exponentInBase10 >= 0 || displayMode == FloatDisplayMode::Scientific ?
                                    exponentInBase10 + 1 : 1;
-  float mantissa = roundf(f * powf(10.0f, availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal));
+  float mantissa = std::round(f * std::pow(10.0f, availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal));
   /* if availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal
    * is too big (or too small), mantissa is now inf. We handle this case by
    * using logarithm function. */
   if (isnan(mantissa) || isinf(mantissa)) {
-    mantissa = roundf(powf(10.0f, log10f(fabsf(f))+(float)(availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal)));
-    mantissa = copysignf(mantissa, f);
+    mantissa = std::round(std::pow(10.0f, std::log10(std::fabs(f))+(float)(availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal)));
+    mantissa = std::copysign(mantissa, f);
   }
   /* We update the exponent in base 10 (if 0.99999999 was rounded to 1 for
    * instance) */
-  float truncatedMantissa = (int)(f * powf(10, availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal));
+  float truncatedMantissa = (int)(f * std::pow(10.0f, availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal));
   if (isinf(truncatedMantissa) || isnan(truncatedMantissa)) {
-    truncatedMantissa = (int)(powf(10.0f, log10f(fabsf(f))+(float)(availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal)));
-    truncatedMantissa = copysignf(truncatedMantissa, f);
+    truncatedMantissa = (int)(std::pow(10.0f, std::log10(std::fabs(f))+(float)(availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal)));
+    truncatedMantissa = std::copysign(truncatedMantissa, f);
   }
   if (mantissa != truncatedMantissa) {
-    float newLogBase10 = mantissa != 0.0f ? log10f(fabsf(mantissa/powf(10, availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal))) : 0.0f;
+    float newLogBase10 = mantissa != 0.0f ? std::log10(std::fabs(mantissa/std::pow(10.0f, availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal))) : 0.0f;
     if (isnan(newLogBase10) || isinf(newLogBase10)) {
-      newLogBase10 = log10f(fabsf(mantissa)) - (float)(availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal);
+      newLogBase10 = std::log10(std::fabs(mantissa)) - (float)(availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal);
     }
-    exponentInBase10 = floorf(newLogBase10);
+    exponentInBase10 = std::floor(newLogBase10);
   }
   int decimalMarkerPosition = exponentInBase10 < 0 || displayMode == FloatDisplayMode::Scientific ?
     1 : exponentInBase10+1;
 
   // Correct the number of digits in mantissa after rounding
   int mantissaExponentInBase10 = exponentInBase10 > 0 || displayMode == FloatDisplayMode::Scientific ? availableCharsForMantissaWithoutSign - 1 : availableCharsForMantissaWithoutSign + exponentInBase10;
-  if ((int)(fabsf(mantissa) * powf(10, - mantissaExponentInBase10)) > 0) {
+  if ((int)(std::fabs(mantissa) * std::pow(10.0f, - mantissaExponentInBase10)) > 0) {
     mantissa = mantissa/10;
   }
 
-  int numberOfCharExponent = exponentInBase10 != 0 ? log10f(fabsf((float)exponentInBase10)) + 1 : 1;
+  int numberOfCharExponent = exponentInBase10 != 0 ? std::log10(std::fabs((float)exponentInBase10)) + 1 : 1;
   if (exponentInBase10 < 0){
     // If the exponent is < 0, we need a additional char for the sign
     numberOfCharExponent++;
   }
 
   // Supress the 0 on the right side of the mantissa
-  int dividend = fabsf((float)mantissa);
+  int dividend = std::fabs((float)mantissa);
   int quotien = dividend/10;
   int digit = dividend - quotien*10;
   int minimumNumberOfCharsInMantissa = 1;
diff --git a/poincare/src/complex_argument.cpp b/poincare/src/complex_argument.cpp
index ba3f24eaf..7ae51889c 100644
--- a/poincare/src/complex_argument.cpp
+++ b/poincare/src/complex_argument.cpp
@@ -3,8 +3,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/complex_matrix.cpp b/poincare/src/complex_matrix.cpp
index 23912627f..9590b29f5 100644
--- a/poincare/src/complex_matrix.cpp
+++ b/poincare/src/complex_matrix.cpp
@@ -6,7 +6,7 @@ extern "C" {
 #include <poincare/complex.h>
 #include "layout/grid_layout.h"
 #include "layout/bracket_layout.h"
-#include <math.h>
+#include <cmath>
 #include <float.h>
 #include <string.h>
 
diff --git a/poincare/src/confidence_interval.cpp b/poincare/src/confidence_interval.cpp
index f17ef57a9..386ea624a 100644
--- a/poincare/src/confidence_interval.cpp
+++ b/poincare/src/confidence_interval.cpp
@@ -3,8 +3,8 @@
 #include <poincare/evaluation.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -36,8 +36,8 @@ Evaluation * ConfidenceInterval::privateEvaluate(Context& context, AngleUnit ang
     return new Complex(Complex::Float(NAN));
   }
   Complex operands[2];
-  operands[0] = Complex::Float(f - 1.0f/sqrtf(n));
-  operands[1] = Complex::Float(f + 1.0f/sqrtf(n));
+  operands[0] = Complex::Float(f - 1.0f/std::sqrt(n));
+  operands[1] = Complex::Float(f + 1.0f/std::sqrt(n));
   return new ComplexMatrix(operands, 2, 1);
 }
 
diff --git a/poincare/src/conjugate.cpp b/poincare/src/conjugate.cpp
index aab872d61..7273b16ed 100644
--- a/poincare/src/conjugate.cpp
+++ b/poincare/src/conjugate.cpp
@@ -4,8 +4,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/cosine.cpp b/poincare/src/cosine.cpp
index f7baa3f30..bd88612d5 100644
--- a/poincare/src/cosine.cpp
+++ b/poincare/src/cosine.cpp
@@ -3,8 +3,8 @@
 #include <poincare/complex.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -31,7 +31,7 @@ Complex Cosine::compute(const Complex c) {
 }
 
 float Cosine::computeForRadianReal(float x) const {
-  return cosf(x);
+  return std::cos(x);
 }
 
 }
diff --git a/poincare/src/derivative.cpp b/poincare/src/derivative.cpp
index c2856771d..e0cf804e5 100644
--- a/poincare/src/derivative.cpp
+++ b/poincare/src/derivative.cpp
@@ -1,10 +1,9 @@
 #include <poincare/derivative.h>
 #include <poincare/symbol.h>
 #include <poincare/complex.h>
-
+#include <cmath>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 #include <float.h>
 }
 
@@ -52,11 +51,11 @@ Evaluation * Derivative::privateEvaluate(Context& context, AngleUnit angleUnit)
    * pp. 75–76. */
 
   // Initiate hh
-  float h = fabsf(x) < FLT_MIN ? k_minInitialRate : x/1000.0f;
+  float h = std::fabs(x) < FLT_MIN ? k_minInitialRate : x/1000.0f;
   float f2 = approximateDerivate2(x, h, xContext, angleUnit);
-  f2 = fabsf(f2) < FLT_MIN ? k_minInitialRate : f2;
-  float hh = sqrtf(fabsf(functionValue/(f2/(powf(h,2.0f)))))/10.0f;
-  hh = fabsf(hh) <FLT_MIN ? k_minInitialRate : hh;
+  f2 = std::fabs(f2) < FLT_MIN ? k_minInitialRate : f2;
+  float hh = std::sqrt(std::fabs(functionValue/(f2/(std::pow(h,2.0f)))))/10.0f;
+  hh = std::fabs(hh) <FLT_MIN ? k_minInitialRate : hh;
   /* Make hh an exactly representable number */
   volatile float temp =  x+hh;
   hh = temp - x;
@@ -84,7 +83,7 @@ Evaluation * Derivative::privateEvaluate(Context& context, AngleUnit angleUnit)
     for (int j = 1; j < 10; j++) {
       a[j][i] = (a[j-1][i]*fac-a[j-1][i-1])/(fac-1.0f);
       fac = k_rateStepSize*k_rateStepSize*fac;
-      errt = fabsf(a[j][i]-a[j-1][i]) > fabsf(a[j][i]-a[j-1][i-1]) ? fabsf(a[j][i]-a[j-1][i]) : fabsf(a[j][i]-a[j-1][i-1]);
+      errt = std::fabs(a[j][i]-a[j-1][i]) > std::fabs(a[j][i]-a[j-1][i-1]) ? std::fabs(a[j][i]-a[j-1][i]) : std::fabs(a[j][i]-a[j-1][i-1]);
       /* Update error and answer if error decreases */
       if (errt < err) {
         err = errt;
@@ -93,7 +92,7 @@ Evaluation * Derivative::privateEvaluate(Context& context, AngleUnit angleUnit)
     }
     /* If higher extrapolation order significantly increases the error, return
      * early */
-    if (fabsf(a[i][i]-a[i-1][i-1]) > 2.0f*err) {
+    if (std::fabs(a[i][i]-a[i-1][i-1]) > 2.0f*err) {
       break;
     }
   }
@@ -104,8 +103,8 @@ Evaluation * Derivative::privateEvaluate(Context& context, AngleUnit angleUnit)
   if (err < FLT_MIN) {
     return new Complex(Complex::Float(ans));
   }
-  err = powf(10.0f, (int)log10f(fabsf(err))+2.0f);
-  return new Complex(Complex::Float(roundf(ans/err)*err));
+  err = std::pow(10.0f, (int)std::log10(std::fabs(err))+2.0f);
+  return new Complex(Complex::Float(std::round(ans/err)*err));
 }
 
 float Derivative::growthRateAroundAbscissa(float x, float h, VariableContext xContext, AngleUnit angleUnit) const {
diff --git a/poincare/src/determinant.cpp b/poincare/src/determinant.cpp
index 0a46eb5e9..69fc00056 100644
--- a/poincare/src/determinant.cpp
+++ b/poincare/src/determinant.cpp
@@ -2,8 +2,8 @@
 #include <poincare/matrix.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/division_quotient.cpp b/poincare/src/division_quotient.cpp
index c54328266..933dfda5f 100644
--- a/poincare/src/division_quotient.cpp
+++ b/poincare/src/division_quotient.cpp
@@ -2,8 +2,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -34,7 +34,7 @@ Evaluation * DivisionQuotient::privateEvaluate(Context & context, AngleUnit angl
   if (isnan(f1) || isnan(f2) || f1 != (int)f1 || f2 != (int)f2) {
     return new Complex(Complex::Float(NAN));
   }
-  return new Complex(Complex::Float(floorf(f1/f2)));
+  return new Complex(Complex::Float(std::floor(f1/f2)));
 }
 
 }
diff --git a/poincare/src/division_remainder.cpp b/poincare/src/division_remainder.cpp
index ed57de154..52f236767 100644
--- a/poincare/src/division_remainder.cpp
+++ b/poincare/src/division_remainder.cpp
@@ -2,8 +2,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -34,7 +34,7 @@ Evaluation * DivisionRemainder::privateEvaluate(Context & context, AngleUnit ang
   if (isnan(f1) || isnan(f2) || f1 != (int)f1 || f2 != (int)f2) {
     return new Complex(Complex::Float(NAN));
   }
-  return new Complex(Complex::Float(roundf(f1-f2*floorf(f1/f2))));
+  return new Complex(Complex::Float(std::round(f1-f2*std::floor(f1/f2))));
 }
 
 }
diff --git a/poincare/src/evaluation.cpp b/poincare/src/evaluation.cpp
index c40148d86..70e8ebe7f 100644
--- a/poincare/src/evaluation.cpp
+++ b/poincare/src/evaluation.cpp
@@ -8,7 +8,7 @@ extern "C" {
 #include <poincare/complex.h>
 #include "layout/grid_layout.h"
 #include "layout/bracket_layout.h"
-#include <math.h>
+#include <cmath>
 #include <float.h>
 #include <string.h>
 
@@ -66,13 +66,13 @@ Evaluation * Evaluation::createDeterminant() const {
     /* Search for pivot */
     int rowWithPivot = i;
     for (int row = i+1; row < dim; row++) {
-      if (fabsf(tempMat[rowWithPivot][i]) < fabsf(tempMat[row][i])) {
+      if (std::fabs(tempMat[rowWithPivot][i]) < std::fabs(tempMat[row][i])) {
         rowWithPivot = row;
       }
     }
     float valuePivot = tempMat[rowWithPivot][i];
     /* if the pivot is null, det = 0. */
-    if (fabsf(valuePivot) <= FLT_EPSILON) {
+    if (std::fabs(valuePivot) <= FLT_EPSILON) {
       for (int i = 0; i < dim; i++) {
         free(tempMat[i]);
       }
@@ -128,13 +128,13 @@ Evaluation * Evaluation::createInverse() const {
     /* Search for pivot */
     int rowWithPivot = i;
     for (int row = i+1; row < dim; row++) {
-      if (fabsf(inv[rowWithPivot][i]) < fabsf(inv[row][i])) {
+      if (std::fabs(inv[rowWithPivot][i]) < std::fabs(inv[row][i])) {
         rowWithPivot = row;
       }
     }
     float valuePivot = inv[rowWithPivot][i];
     /* if the pivot is null, the matrix in not invertible. */
-    if (fabsf(valuePivot) <= FLT_EPSILON) {
+    if (std::fabs(valuePivot) <= FLT_EPSILON) {
       for (int i = 0; i < dim; i++) {
         free(inv[i]);
       }
diff --git a/poincare/src/expression.cpp b/poincare/src/expression.cpp
index 55a157ccb..2eaed2f59 100644
--- a/poincare/src/expression.cpp
+++ b/poincare/src/expression.cpp
@@ -5,6 +5,7 @@
 #include <poincare/list_data.h>
 #include <poincare/matrix_data.h>
 #include <poincare/evaluation.h>
+#include <cmath>
 #include "expression_parser.hpp"
 #include "expression_lexer.hpp"
 extern "C" {
diff --git a/poincare/src/expression_lexer.l b/poincare/src/expression_lexer.l
index 70b6e19de..88a201532 100644
--- a/poincare/src/expression_lexer.l
+++ b/poincare/src/expression_lexer.l
@@ -38,6 +38,7 @@
  * which is not installed by default on MacOS, we thus made the choice to prefer
  * compatibility with MacOS's default version (2.3) instead of using the code
  * requires feature. */
+#include <math.h>
 #include <poincare.h>
 #include "expression_parser.hpp"
 using namespace Poincare;
diff --git a/poincare/src/expression_matrix.cpp b/poincare/src/expression_matrix.cpp
index 61f9487c5..3ca13226e 100644
--- a/poincare/src/expression_matrix.cpp
+++ b/poincare/src/expression_matrix.cpp
@@ -5,7 +5,7 @@ extern "C" {
 #include <poincare/expression_matrix.h>
 #include <poincare/complex_matrix.h>
 #include <poincare/complex.h>
-#include <math.h>
+#include <cmath>
 #include <float.h>
 #include <string.h>
 
diff --git a/poincare/src/factorial.cpp b/poincare/src/factorial.cpp
index c5b32daac..05ee87e91 100644
--- a/poincare/src/factorial.cpp
+++ b/poincare/src/factorial.cpp
@@ -3,8 +3,8 @@
 #include "layout/horizontal_layout.h"
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -38,7 +38,7 @@ Complex Factorial::computeComplex(const Complex c, AngleUnit angleUnit) const {
       return Complex::Float(result);
     }
   }
-  return Complex::Float(roundf(result));
+  return Complex::Float(std::round(result));
 }
 
 ExpressionLayout * Factorial::privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const {
diff --git a/poincare/src/floor.cpp b/poincare/src/floor.cpp
index 788c930c2..2651100a2 100644
--- a/poincare/src/floor.cpp
+++ b/poincare/src/floor.cpp
@@ -2,8 +2,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -28,7 +28,7 @@ Complex Floor::computeComplex(const Complex c, AngleUnit angleUnit) const {
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  return Complex::Float(floorf(c.a()));
+  return Complex::Float(std::floor(c.a()));
 }
 
 }
diff --git a/poincare/src/frac_part.cpp b/poincare/src/frac_part.cpp
index 464a5794e..da41f7cef 100644
--- a/poincare/src/frac_part.cpp
+++ b/poincare/src/frac_part.cpp
@@ -2,8 +2,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -28,7 +28,7 @@ Complex FracPart::computeComplex(const Complex c, AngleUnit angleUnit) const {
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  return Complex::Float(c.a()-floorf(c.a()));
+  return Complex::Float(c.a()-std::floor(c.a()));
 }
 
 }
diff --git a/poincare/src/function.cpp b/poincare/src/function.cpp
index 970207173..103efe77c 100644
--- a/poincare/src/function.cpp
+++ b/poincare/src/function.cpp
@@ -2,6 +2,7 @@ extern "C" {
 #include <assert.h>
 #include <stdlib.h>
 }
+#include <cmath>
 #include <poincare/function.h>
 #include <poincare/complex.h>
 #include "layout/horizontal_layout.h"
diff --git a/poincare/src/global_context.cpp b/poincare/src/global_context.cpp
index 8328006ee..e6f61a9d0 100644
--- a/poincare/src/global_context.cpp
+++ b/poincare/src/global_context.cpp
@@ -1,7 +1,7 @@
 #include <poincare/global_context.h>
 #include <poincare/matrix.h>
 #include <assert.h>
-#include <math.h>
+#include <cmath>
 #include <ion.h>
 
 namespace Poincare {
diff --git a/poincare/src/great_common_divisor.cpp b/poincare/src/great_common_divisor.cpp
index aca9014ba..719b2dd2f 100644
--- a/poincare/src/great_common_divisor.cpp
+++ b/poincare/src/great_common_divisor.cpp
@@ -3,8 +3,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -47,7 +47,7 @@ Evaluation * GreatCommonDivisor::privateEvaluate(Context & context, AngleUnit an
     a = b;
     b = r;
   }
-  return new Complex(Complex::Float(roundf((float)a)));
+  return new Complex(Complex::Float(std::round((float)a)));
 
 }
 
diff --git a/poincare/src/hyperbolic_arc_cosine.cpp b/poincare/src/hyperbolic_arc_cosine.cpp
index 7c71094d1..30e86f2f2 100644
--- a/poincare/src/hyperbolic_arc_cosine.cpp
+++ b/poincare/src/hyperbolic_arc_cosine.cpp
@@ -1,8 +1,8 @@
 #include <poincare/hyperbolic_arc_cosine.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -27,7 +27,7 @@ Complex HyperbolicArcCosine::computeComplex(const Complex c, AngleUnit angleUnit
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  return Complex::Float(acoshf(c.a()));
+  return Complex::Float(std::acosh(c.a()));
 }
 
 }
diff --git a/poincare/src/hyperbolic_arc_sine.cpp b/poincare/src/hyperbolic_arc_sine.cpp
index 8b7d932fc..de1d08d40 100644
--- a/poincare/src/hyperbolic_arc_sine.cpp
+++ b/poincare/src/hyperbolic_arc_sine.cpp
@@ -1,8 +1,8 @@
 #include <poincare/hyperbolic_arc_sine.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -27,7 +27,7 @@ Complex HyperbolicArcSine::computeComplex(const Complex c, AngleUnit angleUnit)
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  return Complex::Float(asinhf(c.a()));
+  return Complex::Float(std::asinh(c.a()));
 }
 
 }
diff --git a/poincare/src/hyperbolic_arc_tangent.cpp b/poincare/src/hyperbolic_arc_tangent.cpp
index d73c1dcfd..a7be7cfcd 100644
--- a/poincare/src/hyperbolic_arc_tangent.cpp
+++ b/poincare/src/hyperbolic_arc_tangent.cpp
@@ -1,8 +1,8 @@
 #include <poincare/hyperbolic_arc_tangent.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -27,7 +27,7 @@ Complex HyperbolicArcTangent::computeComplex(const Complex c, AngleUnit angleUni
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  return Complex::Float(atanhf(c.a()));
+  return Complex::Float(std::atanh(c.a()));
 }
 
 }
diff --git a/poincare/src/hyperbolic_cosine.cpp b/poincare/src/hyperbolic_cosine.cpp
index abbb9ed4a..33683bcdf 100644
--- a/poincare/src/hyperbolic_cosine.cpp
+++ b/poincare/src/hyperbolic_cosine.cpp
@@ -6,8 +6,8 @@
 #include <poincare/opposite.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -30,7 +30,7 @@ Expression * HyperbolicCosine::cloneWithDifferentOperands(Expression** newOperan
 
 Complex HyperbolicCosine::compute(const Complex c) {
   if (c.b() == 0.0f) {
-    return Complex::Float(coshf(c.a()));
+    return Complex::Float(std::cosh(c.a()));
   }
   Complex e = Complex::Float(M_E);
   Complex exp1 = Power::compute(e, c);
diff --git a/poincare/src/hyperbolic_sine.cpp b/poincare/src/hyperbolic_sine.cpp
index 54f77a6aa..c3ad78239 100644
--- a/poincare/src/hyperbolic_sine.cpp
+++ b/poincare/src/hyperbolic_sine.cpp
@@ -6,8 +6,8 @@
 #include <poincare/opposite.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -30,7 +30,7 @@ Expression * HyperbolicSine::cloneWithDifferentOperands(Expression** newOperands
 
 Complex HyperbolicSine::compute(const Complex c) {
   if (c.b() == 0.0f) {
-    return Complex::Float(sinhf(c.a()));
+    return Complex::Float(std::sinh(c.a()));
   }
   Complex e = Complex::Float(M_E);
   Complex exp1 = Power::compute(e, c);
diff --git a/poincare/src/hyperbolic_tangent.cpp b/poincare/src/hyperbolic_tangent.cpp
index d171ec16c..f01515b8f 100644
--- a/poincare/src/hyperbolic_tangent.cpp
+++ b/poincare/src/hyperbolic_tangent.cpp
@@ -5,8 +5,8 @@
 #include <poincare/fraction.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -28,7 +28,7 @@ Expression * HyperbolicTangent::cloneWithDifferentOperands(Expression** newOpera
 
 Complex HyperbolicTangent::compute(const Complex c) {
   if (c.b() == 0.0f) {
-    return Complex::Float(tanhf(c.a()));
+    return Complex::Float(std::tanh(c.a()));
   }
   Complex arg1 = HyperbolicSine::compute(c);
   Complex arg2 = HyperbolicCosine::compute(c);
diff --git a/poincare/src/imaginary_part.cpp b/poincare/src/imaginary_part.cpp
index a9b3e532b..e0b9bd126 100644
--- a/poincare/src/imaginary_part.cpp
+++ b/poincare/src/imaginary_part.cpp
@@ -1,8 +1,7 @@
 #include <poincare/imaginary_part.h>
 #include <poincare/complex.h>
-
+#include <cmath>
 extern "C" {
-#include <math.h>
 #include <assert.h>
 }
 
diff --git a/poincare/src/integer.cpp b/poincare/src/integer.cpp
index 9a15a21be..62d3f8430 100644
--- a/poincare/src/integer.cpp
+++ b/poincare/src/integer.cpp
@@ -1,7 +1,10 @@
 #include <poincare/integer.h>
+extern "C" {
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+#include <math.h>
+}
 #include <poincare/complex.h>
 #include "layout/string_layout.h"
 
diff --git a/poincare/src/integral.cpp b/poincare/src/integral.cpp
index 32475a607..446c5fe8c 100644
--- a/poincare/src/integral.cpp
+++ b/poincare/src/integral.cpp
@@ -2,9 +2,9 @@
 #include <poincare/symbol.h>
 #include <poincare/complex.h>
 #include <poincare/context.h>
+#include <cmath>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 #include <float.h>
 #include <stdlib.h>
 }
@@ -111,12 +111,12 @@ Integral::DetailedResult Integral::kronrodGaussQuadrature(float a, float b, Vari
 
   float centr = 0.5f*(a+b);
   float hlgth = 0.5f*(b-a);
-  float dhlgth = fabsf(hlgth);
+  float dhlgth = std::fabs(hlgth);
 
   float resg =0.0f;
   float fc = functionValueAtAbscissa(centr, xContext, angleUnit);
   float resk = wgk[10]*fc;
-  float resabs = fabsf(resk);
+  float resabs = std::fabs(resk);
   for (int j = 0; j < 5; j++) {
     int jtw = 2*j+1;
     float absc = hlgth*xgk[jtw];
@@ -127,7 +127,7 @@ Integral::DetailedResult Integral::kronrodGaussQuadrature(float a, float b, Vari
     float fsum = fval1+fval2;
     resg += wg[j]*fsum;
     resk += wgk[jtw]*fsum;
-    resabs += wgk[jtw]*(fabsf(fval1)+fabsf(fval2));
+    resabs += wgk[jtw]*(std::fabs(fval1)+std::fabs(fval2));
   }
   for (int j = 0; j < 5; j++) {
     int jtwm1 = 2*j;
@@ -138,19 +138,19 @@ Integral::DetailedResult Integral::kronrodGaussQuadrature(float a, float b, Vari
     fv2[jtwm1] = fval2;
     float fsum = fval1+fval2;
     resk += wgk[jtwm1]*fsum;
-    resabs += wgk[jtwm1]*(fabsf(fval1)+fabsf(fval2));
+    resabs += wgk[jtwm1]*(std::fabs(fval1)+std::fabs(fval2));
   }
   float reskh = resk*0.5f;
-  float resasc = wgk[10]*fabsf(fc-reskh);
+  float resasc = wgk[10]*std::fabs(fc-reskh);
   for (int j = 0; j < 10; j++) {
-    resasc += wgk[j]*(fabsf(fv1[j]-reskh)+fabsf(fv2[j]-reskh));
+    resasc += wgk[j]*(std::fabs(fv1[j]-reskh)+std::fabs(fv2[j]-reskh));
   }
   float integral = resk*hlgth;
   resabs = resabs*dhlgth;
   resasc = resasc*dhlgth;
-  float abserr = fabsf((resk-resg)*hlgth);
+  float abserr = std::fabs((resk-resg)*hlgth);
   if (resasc != 0.0f && abserr != 0.0f) {
-    abserr = 1.0f > powf(200.0f*abserr/resasc, 1.5f)? resasc*powf(200.0f*abserr/resasc, 1.5f) : resasc;
+    abserr = 1.0f > std::pow(200.0f*abserr/resasc, 1.5f)? resasc*std::pow(200.0f*abserr/resasc, 1.5f) : resasc;
   }
   if (resabs > FLT_MAX/(50.0f*FLT_EPSILON)) {
     abserr = abserr > FLT_EPSILON*50.0f*resabs ? abserr : FLT_EPSILON*50.0f*resabs;
diff --git a/poincare/src/least_common_multiple.cpp b/poincare/src/least_common_multiple.cpp
index ba2dd554b..68c1dbf3d 100644
--- a/poincare/src/least_common_multiple.cpp
+++ b/poincare/src/least_common_multiple.cpp
@@ -3,8 +3,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -48,7 +48,7 @@ Evaluation * LeastCommonMultiple::privateEvaluate(Context & context, AngleUnit a
     a = b;
     b = r;
   }
-  return new Complex(Complex::Float(roundf((float)(product/a))));
+  return new Complex(Complex::Float(std::round((float)(product/a))));
 }
 
 }
diff --git a/poincare/src/logarithm.cpp b/poincare/src/logarithm.cpp
index 0c9f662c7..8d69860b5 100644
--- a/poincare/src/logarithm.cpp
+++ b/poincare/src/logarithm.cpp
@@ -1,8 +1,8 @@
 #include <poincare/logarithm.h>
 #include <poincare/fraction.h>
+#include <cmath>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 #include <stdlib.h>
 }
 #include "layout/baseline_relative_layout.h"
@@ -45,7 +45,7 @@ Complex Logarithm::computeComplex(const Complex c, AngleUnit angleUnit) const {
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  return Complex::Float(log10f(c.a()));
+  return Complex::Float(std::log10(c.a()));
 }
 
 Evaluation * Logarithm::privateEvaluate(Context & context, AngleUnit angleUnit) const {
diff --git a/poincare/src/matrix.cpp b/poincare/src/matrix.cpp
index 7c6b88ab1..4e2b9ca28 100644
--- a/poincare/src/matrix.cpp
+++ b/poincare/src/matrix.cpp
@@ -6,7 +6,7 @@ extern "C" {
 #include <poincare/complex.h>
 #include "layout/grid_layout.h"
 #include "layout/bracket_layout.h"
-#include <math.h>
+#include <cmath>
 #include <float.h>
 #include <string.h>
 
diff --git a/poincare/src/matrix_dimension.cpp b/poincare/src/matrix_dimension.cpp
index 873415513..d9d352726 100644
--- a/poincare/src/matrix_dimension.cpp
+++ b/poincare/src/matrix_dimension.cpp
@@ -2,8 +2,8 @@
 #include <poincare/matrix.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/matrix_inverse.cpp b/poincare/src/matrix_inverse.cpp
index 91ec3d04e..957d2805e 100644
--- a/poincare/src/matrix_inverse.cpp
+++ b/poincare/src/matrix_inverse.cpp
@@ -4,8 +4,8 @@
 #include <poincare/fraction.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/matrix_trace.cpp b/poincare/src/matrix_trace.cpp
index 1f565f26a..7d2104667 100644
--- a/poincare/src/matrix_trace.cpp
+++ b/poincare/src/matrix_trace.cpp
@@ -2,8 +2,8 @@
 #include <poincare/matrix.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/matrix_transpose.cpp b/poincare/src/matrix_transpose.cpp
index 1657157a1..8b8637ae3 100644
--- a/poincare/src/matrix_transpose.cpp
+++ b/poincare/src/matrix_transpose.cpp
@@ -4,8 +4,8 @@
 #include <poincare/fraction.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/multiplication.cpp b/poincare/src/multiplication.cpp
index a9bda3fe7..5364c6317 100644
--- a/poincare/src/multiplication.cpp
+++ b/poincare/src/multiplication.cpp
@@ -1,8 +1,8 @@
 extern "C" {
 #include <assert.h>
 #include <stdlib.h>
-#include <math.h>
 }
+#include <cmath>
 
 #include <poincare/multiplication.h>
 #include "layout/string_layout.h"
diff --git a/poincare/src/naperian_logarithm.cpp b/poincare/src/naperian_logarithm.cpp
index bbdd87069..4e727df0f 100644
--- a/poincare/src/naperian_logarithm.cpp
+++ b/poincare/src/naperian_logarithm.cpp
@@ -1,9 +1,9 @@
 #include <poincare/naperian_logarithm.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 #include <stdlib.h>
 }
+#include <cmath>
 #include "layout/horizontal_layout.h"
 #include "layout/parenthesis_layout.h"
 #include "layout/string_layout.h"
@@ -31,7 +31,7 @@ Complex NaperianLogarithm::computeComplex(const Complex c, AngleUnit angleUnit)
   if (c.b() != 0.0f) {
     return Complex::Float(NAN);
   }
-  return Complex::Float(logf(c.a()));
+  return Complex::Float(std::log(c.a()));
 }
 
 }
diff --git a/poincare/src/nth_root.cpp b/poincare/src/nth_root.cpp
index 23ee6ac2b..deb7d1e7a 100644
--- a/poincare/src/nth_root.cpp
+++ b/poincare/src/nth_root.cpp
@@ -6,8 +6,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -48,7 +48,7 @@ Evaluation * NthRoot::privateEvaluate(Context& context, AngleUnit angleUnit) con
 
 Complex NthRoot::compute(const Complex c, const Complex d) const {
   if (c.b() == 0.0f && d.b() == 0.0f) {
-    return Complex::Float(powf(c.a(), 1.0f/d.a()));
+    return Complex::Float(std::pow(c.a(), 1.0f/d.a()));
   }
   Complex invIndex = Fraction::compute(Complex::Float(1.0f), d);
   return Power::compute(c, invIndex);
diff --git a/poincare/src/opposite.cpp b/poincare/src/opposite.cpp
index 7f5ad4471..30a7fd4a6 100644
--- a/poincare/src/opposite.cpp
+++ b/poincare/src/opposite.cpp
@@ -4,8 +4,8 @@
 extern "C" {
 #include <assert.h>
 #include <stdlib.h>
-#include <math.h>
 }
+#include <cmath>
 #include "layout/horizontal_layout.h"
 #include "layout/parenthesis_layout.h"
 #include "layout/string_layout.h"
diff --git a/poincare/src/permute_coefficient.cpp b/poincare/src/permute_coefficient.cpp
index 6c57ae133..afbb5362f 100644
--- a/poincare/src/permute_coefficient.cpp
+++ b/poincare/src/permute_coefficient.cpp
@@ -3,8 +3,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -43,7 +43,7 @@ Evaluation * PermuteCoefficient::privateEvaluate(Context& context, AngleUnit ang
   for (int i = (int)n-(int)k+1; i <= (int)n; i++) {
     result *= i;
   }
-  return new Complex(Complex::Float(roundf(result)));
+  return new Complex(Complex::Float(std::round(result)));
 }
 
 }
diff --git a/poincare/src/power.cpp b/poincare/src/power.cpp
index 26239f5de..22052941a 100644
--- a/poincare/src/power.cpp
+++ b/poincare/src/power.cpp
@@ -1,8 +1,8 @@
 extern "C" {
 #include <assert.h>
 #include <stdlib.h>
-#include <math.h>
 }
+#include <cmath>
 #include <poincare/power.h>
 #include <poincare/multiplication.h>
 #include <poincare/opposite.h>
@@ -38,13 +38,13 @@ Complex Power::compute(const Complex c, const Complex d) {
       return Complex::Float(NAN);
     }
     /* Second case only d is complex */
-    float radius = powf(c.a(), d.a());
-    float theta = d.b()*logf(c.a());
+    float radius = std::pow(c.a(), d.a());
+    float theta = d.b()*std::log(c.a());
     return Complex::Polar(radius, theta);
   }
   /* Third case only c is complex */
-  float radius = powf(c.r(), d.a());
-  if (c.b() == 0 && d.a() == roundf(d.a())) {
+  float radius = std::pow(c.r(), d.a());
+  if (c.b() == 0 && d.a() == std::round(d.a())) {
     /* We handle the case "c float and d integer" separatly to avoid getting
      * complex result due to float representation: a float power an integer is
      * always real. */
@@ -66,7 +66,7 @@ Evaluation * Power::computeOnComplexMatrixAndComplex(Evaluation * m, const Compl
     return new Complex(Complex::Float(NAN));
   }
   float power = c->toFloat();
-  if (isnan(power) || isinf(power) || power != (int)power || fabsf(power) > k_maxNumberOfSteps) {
+  if (isnan(power) || isinf(power) || power != (int)power || std::fabs(power) > k_maxNumberOfSteps) {
     return new Complex(Complex::Float(NAN));
   }
   if (power < 0.0f) {
diff --git a/poincare/src/prediction_interval.cpp b/poincare/src/prediction_interval.cpp
index f9d4deb20..6d6154b09 100644
--- a/poincare/src/prediction_interval.cpp
+++ b/poincare/src/prediction_interval.cpp
@@ -2,8 +2,8 @@
 #include <poincare/matrix.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -35,8 +35,8 @@ Evaluation * PredictionInterval::privateEvaluate(Context& context, AngleUnit ang
     return new Complex(Complex::Float(NAN));
   }
   Complex operands[2];
-  operands[0] = Complex::Float(p - 1.96f*sqrtf(p*(1.0f-p))/sqrtf(n));
-  operands[1] = Complex::Float(p + 1.96f*sqrtf(p*(1.0f-p))/sqrtf(n));
+  operands[0] = Complex::Float(p - 1.96f*std::sqrt(p*(1.0f-p))/std::sqrt(n));
+  operands[1] = Complex::Float(p + 1.96f*std::sqrt(p*(1.0f-p))/std::sqrt(n));
   return new ComplexMatrix(operands, 2, 1);
 }
 
diff --git a/poincare/src/product.cpp b/poincare/src/product.cpp
index 0b0b03a2f..8734f51c0 100644
--- a/poincare/src/product.cpp
+++ b/poincare/src/product.cpp
@@ -4,8 +4,8 @@
 extern "C" {
 #include <assert.h>
 #include <stdlib.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/reel_part.cpp b/poincare/src/reel_part.cpp
index 9bbe25a61..0784ed134 100644
--- a/poincare/src/reel_part.cpp
+++ b/poincare/src/reel_part.cpp
@@ -3,8 +3,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/round.cpp b/poincare/src/round.cpp
index 999988ca8..bc4299fe6 100644
--- a/poincare/src/round.cpp
+++ b/poincare/src/round.cpp
@@ -2,8 +2,8 @@
 
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -34,8 +34,8 @@ Evaluation * Round::privateEvaluate(Context & context, AngleUnit angleUnit) cons
   if (isnan(f2) || f2 != (int)f2) {
     return new Complex(Complex::Float(NAN));
   }
-  float err = powf(10.0f, (int)f2);
-  return new Complex(Complex::Float(roundf(f1*err)/err));
+  float err = std::pow(10.0f, (int)f2);
+  return new Complex(Complex::Float(std::round(f1*err)/err));
 }
 
 }
diff --git a/poincare/src/sequence.cpp b/poincare/src/sequence.cpp
index 758b5ea3d..e566c4492 100644
--- a/poincare/src/sequence.cpp
+++ b/poincare/src/sequence.cpp
@@ -6,9 +6,9 @@
 #include "layout/horizontal_layout.h"
 extern "C" {
 #include <assert.h>
-#include <math.h>
 #include <stdlib.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/sine.cpp b/poincare/src/sine.cpp
index 1aaad5d5c..ffa2a5536 100644
--- a/poincare/src/sine.cpp
+++ b/poincare/src/sine.cpp
@@ -4,8 +4,8 @@
 #include <poincare/multiplication.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -33,7 +33,7 @@ Complex Sine::compute(const Complex c) {
 }
 
 float Sine::computeForRadianReal(float x) const {
-  return sinf(x);
+  return std::sin(x);
 }
 
 }
diff --git a/poincare/src/square_root.cpp b/poincare/src/square_root.cpp
index ba15c9ac6..c1e0f63a7 100644
--- a/poincare/src/square_root.cpp
+++ b/poincare/src/square_root.cpp
@@ -4,8 +4,8 @@
 #include "layout/nth_root_layout.h"
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -34,7 +34,7 @@ ExpressionLayout * SquareRoot::privateCreateLayout(FloatDisplayMode floatDisplay
 
 Complex SquareRoot::computeComplex(const Complex c, AngleUnit angleUnit) const {
   if (c.b() == 0.0f) {
-    return Complex::Float(sqrtf(c.a()));
+    return Complex::Float(std::sqrt(c.a()));
   }
   return Power::compute(c, Complex::Float(0.5f));
 }
diff --git a/poincare/src/store.cpp b/poincare/src/store.cpp
index 920053aa0..9ce30acfe 100644
--- a/poincare/src/store.cpp
+++ b/poincare/src/store.cpp
@@ -1,6 +1,7 @@
 extern "C" {
 #include <assert.h>
 #include <stdlib.h>
+#include <math.h>
 }
 #include <poincare/store.h>
 #include <ion.h>
diff --git a/poincare/src/sum.cpp b/poincare/src/sum.cpp
index 45a0dbeb8..221bcd19c 100644
--- a/poincare/src/sum.cpp
+++ b/poincare/src/sum.cpp
@@ -3,9 +3,9 @@
 #include "layout/sum_layout.h"
 extern "C" {
 #include <assert.h>
-#include <math.h>
 #include <stdlib.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/symbol.cpp b/poincare/src/symbol.cpp
index 2c4d00624..295325d59 100644
--- a/poincare/src/symbol.cpp
+++ b/poincare/src/symbol.cpp
@@ -6,8 +6,8 @@
 #include <poincare/complex_matrix.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
diff --git a/poincare/src/tangent.cpp b/poincare/src/tangent.cpp
index 4a5206ba7..45e379203 100644
--- a/poincare/src/tangent.cpp
+++ b/poincare/src/tangent.cpp
@@ -7,8 +7,8 @@
 #include <poincare/hyperbolic_tangent.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -30,7 +30,7 @@ Expression::Type Tangent::type() const {
 }
 
 float Tangent::computeForRadianReal(float x) const {
-  return tanf(x);
+  return std::tan(x);
 }
 
 Complex Tangent::privateCompute(const Complex c, AngleUnit angleUnit) const {
diff --git a/poincare/src/trigonometric_function.cpp b/poincare/src/trigonometric_function.cpp
index d5c1ffefd..c0960639e 100644
--- a/poincare/src/trigonometric_function.cpp
+++ b/poincare/src/trigonometric_function.cpp
@@ -2,8 +2,8 @@
 #include <poincare/complex.h>
 extern "C" {
 #include <assert.h>
-#include <math.h>
 }
+#include <cmath>
 
 namespace Poincare {
 
@@ -20,7 +20,7 @@ Complex TrigonometricFunction::computeComplex(const Complex c, AngleUnit angleUn
       input *= M_PI/180.0f;
     }
     float result = computeForRadianReal(input);
-    if (input !=  0.0f && fabsf(result/input) <= 1E-7f) {
+    if (input !=  0.0f && std::fabs(result/input) <= 1E-7f) {
       return Complex::Float(0.0f);
     }
     return Complex::Float(result);
diff --git a/poincare/src/variable_context.cpp b/poincare/src/variable_context.cpp
index e2ef5e24e..ffd35b68b 100644
--- a/poincare/src/variable_context.cpp
+++ b/poincare/src/variable_context.cpp
@@ -1,6 +1,9 @@
 #include <poincare/variable_context.h>
 #include <poincare/preferences.h>
 #include <assert.h>
+extern "C" {
+#include <math.h>
+}
 
 namespace Poincare {
 
diff --git a/poincare/test/complex.cpp b/poincare/test/complex.cpp
index c4b135124..36c750590 100644
--- a/poincare/test/complex.cpp
+++ b/poincare/test/complex.cpp
@@ -4,6 +4,7 @@
 #include <ion.h>
 #include <stdlib.h>
 #include <assert.h>
+#include <cmath>
 
 using namespace Poincare;
 constexpr Expression::FloatDisplayMode Decimal = Expression::FloatDisplayMode::Decimal;
@@ -72,10 +73,7 @@ QUIZ_CASE(poincare_complex_to_text) {
   /* Converting 0.00000001f into a decimal display would also overflow the
    * number of significant digits set to 7. */
   assert_cartesian_complex_converts_to(0.0000001f, 0.0f, "1E-7", Decimal);
-  /* The conversion of -0.00000000000000000000000000000000909090964f does not
-   * give the exact right number because of float represention. The closest
-   * exact representation is -9.090897E-33. */
-  assert_cartesian_complex_converts_to(-0.00000000000000000000000000000000909090964f, 0.0f, "-9.090897E-33");
+  assert_cartesian_complex_converts_to(-0.000000000000000000000000000000009090018f, 0.0f, "-9.090018E-33");
   assert_cartesian_complex_converts_to(123.421f, 0.0f, "123.4", Decimal, Cartesian, 4, 6);
   assert_cartesian_complex_converts_to(123.421f, 0.0f, "1.2E2", Decimal, Cartesian, 5, 6);
   assert_cartesian_complex_converts_to(9.999999f, 0.0f, "10", Decimal, Cartesian, 6);
@@ -106,11 +104,11 @@ QUIZ_CASE(poincare_complex_evaluate) {
 
 QUIZ_CASE(poincare_complex_constructor) {
   Complex * a = new Complex(Complex::Cartesian(2.0f, 3.0f));
-  assert(fabsf(a->a() - 2.0f) < 0.00001f && fabsf(a->b()-3.0f) < 0.00001f);
+  assert(std::fabs(a->a() - 2.0f) < 0.00001f && std::fabs(a->b()-3.0f) < 0.00001f);
   assert(a->r() == 3.60555124f && a->th() == 0.982793748f);
   delete a;
 
   a = new Complex(Complex::Polar(3.60555124f, 0.982793748f));
-  assert(fabsf(a->a() - 2.0f) < 0.00001f && fabsf(a->b()-3.0f) < 0.00001f);
+  assert(std::fabs(a->a() - 2.0f) < 0.00001f && std::fabs(a->b()-3.0f) < 0.00001f);
   delete a;
 }
diff --git a/poincare/test/fraction.cpp b/poincare/test/fraction.cpp
index e56f2da01..3aac15e37 100644
--- a/poincare/test/fraction.cpp
+++ b/poincare/test/fraction.cpp
@@ -1,7 +1,7 @@
 #include <quiz.h>
 #include <poincare.h>
 #include <ion.h>
-#include <math.h>
+#include <cmath>
 #include <assert.h>
 #include "helper.h"
 
diff --git a/poincare/test/function.cpp b/poincare/test/function.cpp
index 58610f5c7..b1507a040 100644
--- a/poincare/test/function.cpp
+++ b/poincare/test/function.cpp
@@ -1,6 +1,6 @@
 #include <quiz.h>
 #include <poincare.h>
-#include <math.h>
+#include <cmath>
 #include <ion.h>
 #include <assert.h>
 #include "helper.h"
@@ -148,13 +148,13 @@ QUIZ_CASE(poincare_function_evaluate) {
   Complex a0[1] = {Complex::Float(1.0f)};
   assert_parsed_expression_evaluate_to("abs(-1)", a0, 1);
 
-  Complex a1[1] = {Complex::Float(sqrtf(3.0f*3.0f+2.0f*2.0f))};
+  Complex a1[1] = {Complex::Float(std::sqrt(3.0f*3.0f+2.0f*2.0f))};
   assert_parsed_expression_evaluate_to("abs(3+2I)", a1, 1);
 
   Complex a2[4] = {Complex::Float(1.0f), Complex::Float(2.0f), Complex::Float(3.0f), Complex::Float(4.0f)};
   assert_parsed_expression_evaluate_to("abs([[1,-2][3,-4]])", a2, 4);
 
-  Complex a3[4] = {Complex::Float(sqrtf(3.0f*3.0f+2.0f*2.0f)), Complex::Float(sqrtf(3.0f*3.0f+4.0f*4.0f)), Complex::Float(sqrtf(5.0f*5.0f+2.0f*2.0f)), Complex::Float(sqrtf(3.0f*3.0f+2.0f*2.0f))};
+  Complex a3[4] = {Complex::Float(std::sqrt(3.0f*3.0f+2.0f*2.0f)), Complex::Float(std::sqrt(3.0f*3.0f+4.0f*4.0f)), Complex::Float(std::sqrt(5.0f*5.0f+2.0f*2.0f)), Complex::Float(std::sqrt(3.0f*3.0f+2.0f*2.0f))};
   assert_parsed_expression_evaluate_to("abs([[3+2I,3+4I][5+2I,3+2I]])", a3, 4);
 
   Complex b[1] = {Complex::Float(210.0f)};
@@ -189,10 +189,10 @@ QUIZ_CASE(poincare_function_evaluate) {
   Complex k[1] = {Complex::Float(46098.0f)};
   assert_parsed_expression_evaluate_to("lcm(234,394)", k, 1);
 
-  Complex l[1] = {Complex::Float(logf(2.0f))};
+  Complex l[1] = {Complex::Float(std::log(2.0f))};
   assert_parsed_expression_evaluate_to("ln(2)", l, 1);
 
-  Complex m[1] = {Complex::Float(log10f(2.0f))};
+  Complex m[1] = {Complex::Float(std::log10(2.0f))};
   assert_parsed_expression_evaluate_to("log(2)", m, 1);
 
   Complex n[1] = {Complex::Float(5040.0f)};
@@ -207,10 +207,10 @@ QUIZ_CASE(poincare_function_evaluate) {
   Complex q[1] = {Complex::Float(9.0f)};
   assert_parsed_expression_evaluate_to("rem(29, 10)", q, 1);
 
-  Complex r[1] = {Complex::Float(powf(2.0f, 1.0f/3.0f))};
+  Complex r[1] = {Complex::Float(std::pow(2.0f, 1.0f/3.0f))};
   assert_parsed_expression_evaluate_to("root(2,3)", r, 1);
 
-  Complex s[1] = {Complex::Float(sqrtf(2.0f))};
+  Complex s[1] = {Complex::Float(std::sqrt(2.0f))};
   assert_parsed_expression_evaluate_to("R(2)", s, 1);
 
   Complex t[1] = {Complex::Float(49.0f)};
@@ -221,7 +221,7 @@ QUIZ_CASE(poincare_function_evaluate) {
   assert_parsed_expression_evaluate_to("trace([[1,2,3][4,5,6][7,8,9]])", u, 1);
 #endif
 
-  Complex v[2] = {Complex::Float(0.1f - sqrtf(1.0f/100.0f)), Complex::Float(0.1f + sqrtf(1.0f/100.0f))};
+  Complex v[2] = {Complex::Float(0.1f - std::sqrt(1.0f/100.0f)), Complex::Float(0.1f + std::sqrt(1.0f/100.0f))};
   assert_parsed_expression_evaluate_to("confidence(0.1, 100)", v, 2);
 
 #if MATRICES_ARE_DEFINED
@@ -237,10 +237,10 @@ QUIZ_CASE(poincare_function_evaluate) {
   assert_parsed_expression_evaluate_to("inverse([[1,2,3][4,5,-6][7,8,9]])", y, 9);
 #endif
 
-  Complex z[2] = {Complex::Float(0.1f-sqrtf(1.0f/100.0f)), Complex::Float(0.1f+sqrtf(1.0f/100.0f))};
+  Complex z[2] = {Complex::Float(0.1f-std::sqrt(1.0f/100.0f)), Complex::Float(0.1f+std::sqrt(1.0f/100.0f))};
   assert_parsed_expression_evaluate_to("prediction(0.1, 100)", z, 2);
 
-  Complex aa[2] = {Complex::Float(0.1f-1.96f*sqrtf((0.1f*(1.0f-0.1f))/100.0f)), Complex::Float(0.1f+1.96f*sqrtf((0.1f*(1.0f-0.1f))/100.0f))};
+  Complex aa[2] = {Complex::Float(0.1f-1.96f*std::sqrt((0.1f*(1.0f-0.1f))/100.0f)), Complex::Float(0.1f+1.96f*std::sqrt((0.1f*(1.0f-0.1f))/100.0f))};
   assert_parsed_expression_evaluate_to("prediction95(0.1, 100)", aa, 2);
 
   Complex ab[1] = {Complex::Cartesian(-100.0f, -540.0f)};
diff --git a/poincare/test/helper.cpp b/poincare/test/helper.cpp
index efc85ed47..41baa308d 100644
--- a/poincare/test/helper.cpp
+++ b/poincare/test/helper.cpp
@@ -4,6 +4,7 @@
 #include <ion.h>
 #include <stdlib.h>
 #include <assert.h>
+#include <cmath>
 
 using namespace Poincare;
 
@@ -31,8 +32,8 @@ void assert_parsed_expression_evaluate_to(const char * expression, Complex * res
   Expression * a = Expression::parse(buffer);
   Evaluation * m = a->evaluate(globalContext, angleUnit);
   for (int i = 0; i < numberOfEntries; i++) {
-    assert(fabsf(m->complexOperand(i)->a() - results[i].a()) < 0.0001f);
-    assert(fabsf(m->complexOperand(i)->b() - results[i].b()) < 0.0001f);
+    assert(std::fabs(m->complexOperand(i)->a() - results[i].a()) < 0.0001f);
+    assert(std::fabs(m->complexOperand(i)->b() - results[i].b()) < 0.0001f);
   }
   delete a;
   delete m;
diff --git a/poincare/test/parser.cpp b/poincare/test/parser.cpp
index 2ee8e23db..6d2b37118 100644
--- a/poincare/test/parser.cpp
+++ b/poincare/test/parser.cpp
@@ -1,7 +1,7 @@
 #include <quiz.h>
 #include <poincare.h>
 #include <ion.h>
-#include <math.h>
+#include <cmath>
 #include <assert.h>
 #include "helper.h"
 
@@ -10,13 +10,13 @@ using namespace Poincare;
 QUIZ_CASE(poincare_parser) {
   Complex a[1] = {Complex::Float(1.2f*M_E)};
   assert_parsed_expression_evaluate_to("1.2*X^(1)", a, 1);
-  Complex b[1] = {Complex::Float(powf(M_E, 2.0f)*M_E)};
+  Complex b[1] = {Complex::Float(std::pow((float)M_E, 2.0f)*M_E)};
   assert_parsed_expression_evaluate_to("X^2*X^(1)", b, 1);
-  Complex c[1] = {Complex::Float(2.0f*powf(3.0f, 4.0f)+2.0f)};
+  Complex c[1] = {Complex::Float(2.0f*std::pow(3.0f, 4.0f)+2.0f)};
   assert_parsed_expression_evaluate_to("2*3^4+2", c, 1);
-  Complex d[1] = {Complex::Float(-2.0f*powf(3.0f, 4.0f)+2.0f)};
+  Complex d[1] = {Complex::Float(-2.0f*std::pow(3.0f, 4.0f)+2.0f)};
   assert_parsed_expression_evaluate_to("-2*3^4+2", d,1);
-  Complex e[1] = {Complex::Float(-sinf(3.0f)*2.0f-3.0f)};
+  Complex e[1] = {Complex::Float(-std::sin(3.0f)*2.0f-3.0f)};
   assert_parsed_expression_evaluate_to("-sin(3)*2-3", e, 1, Radian);
   Complex f[1] = {Complex::Float(-0.003f)};
   assert_parsed_expression_evaluate_to("-.003", f, 1);
@@ -28,7 +28,7 @@ QUIZ_CASE(poincare_parser) {
   assert_parsed_expression_evaluate_to("2/3-5", i, 1);
   Complex j[1] = {Complex::Float(-2.0f/3.0f-5.0f)};
   assert_parsed_expression_evaluate_to("-2/3-5", j, 1);
-  Complex k[1] = {Complex::Float(sinf(3.0f)*2.0f*(4.0f+2.0f))};
+  Complex k[1] = {Complex::Float(std::sin(3.0f)*2.0f*(4.0f+2.0f))};
   assert_parsed_expression_evaluate_to("sin(3)2(4+2)", k, 1, Radian);
   Complex l[1] = {Complex::Float(4.0f/2.0f*(2.0f+3.0f))};
   assert_parsed_expression_evaluate_to("4/2*(2+3)", l, 1, Radian);
diff --git a/poincare/test/symbol.cpp b/poincare/test/symbol.cpp
index 07afde663..929d994a4 100644
--- a/poincare/test/symbol.cpp
+++ b/poincare/test/symbol.cpp
@@ -1,6 +1,6 @@
 #include <quiz.h>
 #include <poincare.h>
-#include <math.h>
+#include <cmath>
 #include <ion.h>
 #include <assert.h>
 #include "helper.h"