diff --git a/apps/probability/Makefile b/apps/probability/Makefile
index 6d5880d95..ed3e3fd39 100644
--- a/apps/probability/Makefile
+++ b/apps/probability/Makefile
@@ -2,14 +2,14 @@ apps += Probability::App
 app_headers += apps/probability/app.h
 
 app_probability_test_src = $(addprefix apps/probability/,\
-  law/chi_squared_law.cpp \
-  law/erf_inv.cpp \
-  law/geometric_law.cpp \
-  law/helper.cpp \
-  law/incomplete_beta_function.cpp \
-  law/law.cpp \
-  law/regularized_gamma.cpp \
-  law/student_law.cpp \
+  distribution/chi_squared_distribution.cpp \
+  distribution/erf_inv.cpp \
+  distribution/geometric_distribution.cpp \
+  distribution/helper.cpp \
+  distribution/incomplete_beta_function.cpp \
+  distribution/distribution.cpp \
+  distribution/regularized_gamma.cpp \
+  distribution/student_distribution.cpp \
 )
 
 app_probability_src = $(addprefix apps/probability/,\
@@ -24,15 +24,15 @@ app_probability_src = $(addprefix apps/probability/,\
   calculation_type_controller.cpp \
   cell.cpp \
   image_cell.cpp \
-  law/binomial_law.cpp \
-  law/exponential_law.cpp \
-  law/normal_law.cpp \
-  law/poisson_law.cpp \
-  law/regularized_gamma.cpp \
-  law/two_parameter_law.cpp \
-  law/uniform_law.cpp \
-  law_controller.cpp \
-  law_curve_view.cpp \
+  distribution/binomial_distribution.cpp \
+  distribution/exponential_distribution.cpp \
+  distribution/normal_distribution.cpp \
+  distribution/poisson_distribution.cpp \
+  distribution/regularized_gamma.cpp \
+  distribution/two_parameter_distribution.cpp \
+  distribution/uniform_distribution.cpp \
+  distribution_controller.cpp \
+  distribution_curve_view.cpp \
   parameters_controller.cpp \
   responder_image_cell.cpp \
 )
@@ -49,13 +49,13 @@ i18n_files += $(addprefix apps/probability/,\
   base.universal.i18n\
 )
 
-tests_src += $(addprefix apps/probability/law/,\
+tests_src += $(addprefix apps/probability/distribution/,\
   hypergeometric_function.cpp\
 )
 tests_src += $(addprefix apps/probability/test/,\
   erf_inv.cpp\
   hypergeometric_function.cpp\
-  laws.cpp\
+  distributions.cpp\
   regularized_gamma.cpp \
 )
 
@@ -63,7 +63,7 @@ tests_src += $(addprefix apps/probability/test/,\
 
 $(eval $(call depends_on_image,apps/probability/app.cpp,apps/probability/probability_icon.png))
 
-$(eval $(call depends_on_image,apps/probability/law_controller.cpp,$(addprefix apps/probability/images/, \
+$(eval $(call depends_on_image,apps/probability/distribution_controller.cpp,$(addprefix apps/probability/images/, \
   binomial_icon.png \
   chi_squared_icon.png \
   exponential_icon.png \
diff --git a/apps/probability/app.cpp b/apps/probability/app.cpp
index cda4348d5..7b840ce50 100644
--- a/apps/probability/app.cpp
+++ b/apps/probability/app.cpp
@@ -20,17 +20,17 @@ const Image * App::Descriptor::icon() {
 }
 
 App::Snapshot::Snapshot() :
-  m_law{},
+  m_distribution{},
   m_calculation{},
-  m_activePage(Page::Law)
+  m_activePage(Page::Distribution)
 {
-  new(m_law) BinomialLaw();
+  new(m_distribution) BinomialDistribution();
   new(m_calculation) LeftIntegralCalculation();
-  calculation()->setLaw(law());
+  calculation()->setDistribution(distribution());
 }
 
 App::Snapshot::~Snapshot() {
-  law()->~Law();
+  distribution()->~Distribution();
   calculation()->~Calculation();
 }
 
@@ -44,15 +44,15 @@ App::Descriptor * App::Snapshot::descriptor() {
 }
 
 void App::Snapshot::reset() {
-  law()->~Law();
-  new(m_law) BinomialLaw();
+  distribution()->~Distribution();
+  new(m_distribution) BinomialDistribution();
   calculation()->~Calculation();
   new(m_calculation) LeftIntegralCalculation();
-  m_activePage = Page::Law;
+  m_activePage = Page::Distribution;
 }
 
-Law * App::Snapshot::law() {
-  return (Law *)m_law;
+Distribution * App::Snapshot::distribution() {
+  return (Distribution *)m_distribution;
 }
 
 Calculation * App::Snapshot::calculation() {
@@ -69,10 +69,10 @@ App::Snapshot::Page App::Snapshot::activePage() {
 
 App::App(Snapshot * snapshot) :
   TextFieldDelegateApp(snapshot, &m_stackViewController),
-  m_calculationController(&m_stackViewController, this, snapshot->law(), snapshot->calculation()),
-  m_parametersController(&m_stackViewController, this, snapshot->law(), &m_calculationController),
-  m_lawController(&m_stackViewController, snapshot->law(), &m_parametersController),
-  m_stackViewController(&m_modalViewController, &m_lawController)
+  m_calculationController(&m_stackViewController, this, snapshot->distribution(), snapshot->calculation()),
+  m_parametersController(&m_stackViewController, this, snapshot->distribution(), &m_calculationController),
+  m_distributionController(&m_stackViewController, snapshot->distribution(), &m_parametersController),
+  m_stackViewController(&m_modalViewController, &m_distributionController)
 {
     switch (snapshot->activePage()) {
     case Snapshot::Page::Parameters:
diff --git a/apps/probability/app.h b/apps/probability/app.h
index 1bb342d42..a4a45f6d4 100644
--- a/apps/probability/app.h
+++ b/apps/probability/app.h
@@ -2,15 +2,15 @@
 #define PROBABILITY_PROBABILITY_APP_H
 
 #include <escher.h>
-#include "law_controller.h"
+#include "distribution_controller.h"
 #include "calculation_controller.h"
 #include "parameters_controller.h"
 #include "../shared/text_field_delegate_app.h"
-#include "law/binomial_law.h"
-#include "law/exponential_law.h"
-#include "law/normal_law.h"
-#include "law/poisson_law.h"
-#include "law/uniform_law.h"
+#include "distribution/binomial_distribution.h"
+#include "distribution/exponential_distribution.h"
+#include "distribution/normal_distribution.h"
+#include "distribution/poisson_distribution.h"
+#include "distribution/uniform_distribution.h"
 #include "calculation/left_integral_calculation.h"
 #include "calculation/right_integral_calculation.h"
 #include "calculation/finite_integral_calculation.h"
@@ -32,7 +32,7 @@ public:
   class Snapshot : public ::App::Snapshot {
   public:
     enum class Page {
-      Law,
+      Distribution,
       Parameters,
       Calculations
     };
@@ -41,14 +41,14 @@ public:
     App * unpack(Container * container) override;
     Descriptor * descriptor() override;
     void reset() override;
-    Law * law();
+    Distribution * distribution();
     Calculation * calculation();
     Page activePage();
     void setActivePage(Page activePage);
   private:
-    constexpr static int k_lawSizes[] = {sizeof(BinomialLaw),sizeof(ExponentialLaw), sizeof(NormalLaw), sizeof(PoissonLaw), sizeof(UniformLaw), 0};
-    constexpr static size_t k_lawSize = max(k_lawSizes);
-    char m_law[k_lawSize];
+    constexpr static int k_distributionSizes[] = {sizeof(BinomialDistribution),sizeof(ExponentialDistribution), sizeof(NormalDistribution), sizeof(PoissonDistribution), sizeof(UniformDistribution), 0};
+    constexpr static size_t k_distributionSize = max(k_distributionSizes);
+    char m_distribution[k_distributionSize];
     constexpr static int k_calculationSizes[] = {sizeof(LeftIntegralCalculation),sizeof(FiniteIntegralCalculation), sizeof(RightIntegralCalculation), 0};
     constexpr static size_t k_calculationSize = max(k_calculationSizes);
     char m_calculation[k_calculationSize];
@@ -62,7 +62,7 @@ private:
   App(Snapshot * snapshot);
   CalculationController m_calculationController;
   ParametersController m_parametersController;
-  LawController m_lawController;
+  DistributionController m_distributionController;
   StackViewController m_stackViewController;
 };
 
diff --git a/apps/probability/base.de.i18n b/apps/probability/base.de.i18n
index d24c5648f..1a5a599c8 100644
--- a/apps/probability/base.de.i18n
+++ b/apps/probability/base.de.i18n
@@ -1,6 +1,6 @@
 ProbaApp = "Wahrsch."
 ProbaAppCapital = "WAHRSCHEINLICHKEIT"
-ChooseLaw = "Wählen Sie eine Verteilung"
+ChooseDistribution = "Wählen Sie eine Verteilung"
 Binomial = "Binomial"
 Geometric = "Geometrische"
 Uniforme = "Uniform"
@@ -8,14 +8,14 @@ Normal = "Normal"
 Poisson = "Poisson"
 ChiSquared = "Chi-Quadrat"
 Student = "Student"
-BinomialLaw = "Binomialverteilung"
-UniformLaw = "Uniformverteilung"
-ExponentialLaw = "Exponentialverteilung"
-GeometricLaw = "Geometrischeverteilung"
-NormalLaw = "Normalverteilung"
-PoissonLaw = "Poisson-Verteilung"
-ChiSquaredLaw = "Chi-Quadrat-Verteilung"
-StudentLaw = "Student-Verteilung"
+BinomialDistribution = "Binomialverteilung"
+UniformDistribution = "Uniformverteilung"
+ExponentialDistribution = "Exponentialverteilung"
+GeometricDistribution = "Geometrischeverteilung"
+NormalDistribution = "Normalverteilung"
+PoissonDistribution = "Poisson-Verteilung"
+ChiSquaredDistribution = "Chi-Quadrat-Verteilung"
+StudentDistribution = "Student-Verteilung"
 ChooseParameters = "Parameter auswählen"
 RepetitionNumber = "n: Anzahl der Versuche"
 SuccessProbability = "p: Erfolgswahrscheinlichkeit"
diff --git a/apps/probability/base.en.i18n b/apps/probability/base.en.i18n
index 6d7b8b102..8a95a3ac0 100644
--- a/apps/probability/base.en.i18n
+++ b/apps/probability/base.en.i18n
@@ -1,6 +1,6 @@
 ProbaApp = "Probability"
 ProbaAppCapital = "PROBABILITY"
-ChooseLaw = "Choose the distribution"
+ChooseDistribution = "Choose the distribution"
 Binomial = "Binomial"
 Geometric = "Geometric"
 Uniforme = "Uniform"
@@ -8,14 +8,14 @@ Normal = "Normal"
 Poisson = "Poisson"
 ChiSquared = "Chi-squared"
 Student = "Student"
-BinomialLaw = "Binomial distribution"
-UniformLaw = "Uniform distribution"
-ExponentialLaw = "Exponential distribution"
-GeometricLaw = "Geometric distribution"
-NormalLaw = "Normal distribution"
-PoissonLaw = "Poisson distribution"
-ChiSquaredLaw = "Chi-squared distribution"
-StudentLaw = "Student's distribution"
+BinomialDistribution = "Binomial distribution"
+UniformDistribution = "Uniform distribution"
+ExponentialDistribution = "Exponential distribution"
+GeometricDistribution = "Geometric distribution"
+NormalDistribution = "Normal distribution"
+PoissonDistribution = "Poisson distribution"
+ChiSquaredDistribution = "Chi-squared distribution"
+StudentDistribution = "Student's distribution"
 ChooseParameters = "Choose parameters"
 RepetitionNumber = "n: Number of trials"
 SuccessProbability = "p: Success probability"
diff --git a/apps/probability/base.es.i18n b/apps/probability/base.es.i18n
index 14024ab7f..87f5f8e05 100644
--- a/apps/probability/base.es.i18n
+++ b/apps/probability/base.es.i18n
@@ -1,6 +1,6 @@
 ProbaApp = "Probabilidad"
 ProbaAppCapital = "PROBABILIDAD"
-ChooseLaw = "Seleccionar la distribución"
+ChooseDistribution = "Seleccionar la distribución"
 Binomial = "Binomial"
 Geometric = "Geométrica"
 Uniforme = "Uniforme"
@@ -8,14 +8,14 @@ Normal = "Normal"
 Poisson = "Poisson"
 ChiSquared = "Chi-cuadrado"
 Student = "Student"
-BinomialLaw = "Distribución binomial"
-UniformLaw = "Distribución uniforme"
-ExponentialLaw = "Distribución exponencial"
-GeometricLaw = "Distribución geométrica"
-NormalLaw = "Distribución normal"
-PoissonLaw = "Distribución de Poisson"
-ChiSquaredLaw = "Distribución chi-cuadrado"
-StudentLaw = "Distribución de Student"
+BinomialDistribution = "Distribución binomial"
+UniformDistribution = "Distribución uniforme"
+ExponentialDistribution = "Distribución exponencial"
+GeometricDistribution = "Distribución geométrica"
+NormalDistribution = "Distribución normal"
+PoissonDistribution = "Distribución de Poisson"
+ChiSquaredDistribution = "Distribución chi-cuadrado"
+StudentDistribution = "Distribución de Student"
 ChooseParameters = "Seleccionar parámetros"
 RepetitionNumber = "n : Número de ensayos "
 SuccessProbability = "p : Probabilidad de éxito "
diff --git a/apps/probability/base.fr.i18n b/apps/probability/base.fr.i18n
index 6e35adf32..74af267e8 100644
--- a/apps/probability/base.fr.i18n
+++ b/apps/probability/base.fr.i18n
@@ -1,6 +1,6 @@
 ProbaApp = "Probabilités"
 ProbaAppCapital = "PROBABILITÉS"
-ChooseLaw = "Choisir le type de loi"
+ChooseDistribution = "Choisir le type de loi"
 Binomial = "Binomiale"
 Geometric = "Géométrique"
 Uniforme = "Uniforme"
@@ -8,14 +8,14 @@ Normal = "Normale"
 Poisson = "Poisson"
 ChiSquared = "Chi2"
 Student = "Student"
-BinomialLaw = "Loi binomiale"
-UniformLaw = "Loi uniforme"
-ExponentialLaw = "Loi exponentielle"
-GeometricLaw = "Loi géométrique"
-NormalLaw = "Loi normale"
-PoissonLaw = "Loi de Poisson"
-ChiSquaredLaw = "Loi du chi2"
-StudentLaw = "Loi de Student"
+BinomialDistribution = "Loi binomiale"
+UniformDistribution = "Loi uniforme"
+ExponentialDistribution = "Loi exponentielle"
+GeometricDistribution = "Loi géométrique"
+NormalDistribution = "Loi normale"
+PoissonDistribution = "Loi de Poisson"
+ChiSquaredDistribution = "Loi du chi2"
+StudentDistribution = "Loi de Student"
 ChooseParameters = "Choisir les paramètres"
 RepetitionNumber = "n : Nombre de répétitions"
 SuccessProbability = "p : Probabilité de succès"
diff --git a/apps/probability/base.pt.i18n b/apps/probability/base.pt.i18n
index f273d27e4..21290a404 100644
--- a/apps/probability/base.pt.i18n
+++ b/apps/probability/base.pt.i18n
@@ -1,6 +1,6 @@
 ProbaApp = "Probabilidade"
 ProbaAppCapital = "PROBABILIDADE"
-ChooseLaw = "Selecionar a distribuição"
+ChooseDistribution = "Selecionar a distribuição"
 Binomial = "Binomial"
 Geometric = "Geométrica"
 Uniforme = "Uniforme"
@@ -8,14 +8,14 @@ Normal = "Normal"
 Poisson = "Poisson"
 ChiSquared = "Qui-quadrado"
 Student = "Student"
-BinomialLaw = "Distribuição binomial"
-UniformLaw = "Distribuição uniforme"
-ExponentialLaw = "Distribuição exponencial"
-GeometricLaw = "Distribuição geométrica"
-NormalLaw = "Distribuição normal"
-PoissonLaw = "Distribuição de Poisson"
-ChiSquaredLaw = "Distribuição qui-quadrado"
-StudentLaw = "Distribuição de Student"
+BinomialDistribution = "Distribuição binomial"
+UniformDistribution = "Distribuição uniforme"
+ExponentialDistribution = "Distribuição exponencial"
+GeometricDistribution = "Distribuição geométrica"
+NormalDistribution = "Distribuição normal"
+PoissonDistribution = "Distribuição de Poisson"
+ChiSquaredDistribution = "Distribuição qui-quadrado"
+StudentDistribution = "Distribuição de Student"
 ChooseParameters = "Selecionar os parâmetros"
 RepetitionNumber = "n : Número de ensaios"
 SuccessProbability = "p : Probabilidade de sucesso"
diff --git a/apps/probability/calculation/calculation.cpp b/apps/probability/calculation/calculation.cpp
index d3e66b30a..f45f31460 100644
--- a/apps/probability/calculation/calculation.cpp
+++ b/apps/probability/calculation/calculation.cpp
@@ -4,8 +4,8 @@
 
 namespace Probability {
 
-void Calculation::setLaw(Law * law) {
-  m_law = law;
+void Calculation::setDistribution(Distribution * distribution) {
+  m_distribution = distribution;
   compute(0);
 }
 
diff --git a/apps/probability/calculation/calculation.h b/apps/probability/calculation/calculation.h
index 49283b945..215daece6 100644
--- a/apps/probability/calculation/calculation.h
+++ b/apps/probability/calculation/calculation.h
@@ -1,7 +1,7 @@
 #ifndef PROBABILITE_CALCULATION_H
 #define PROBABILITE_CALCULATION_H
 
-#include "../law/law.h"
+#include "../distribution/distribution.h"
 
 namespace Probability {
 
@@ -13,10 +13,10 @@ public:
     RightIntegral,
     Discrete,
   };
-  Calculation() : m_law(nullptr) {}
+  Calculation() : m_distribution(nullptr) {}
   virtual ~Calculation() = default;
   virtual Type type() = 0;
-  void setLaw(Law * law);
+  void setDistribution(Distribution * distribution);
   virtual int numberOfParameters() = 0;
   virtual I18n::Message legendForParameterAtIndex(int index) = 0;
   virtual void setParameterAtIndex(double f, int index) = 0;
@@ -25,7 +25,7 @@ public:
   virtual double upperBound();
 protected:
   virtual void compute(int indexKnownElement) = 0;
-  Law * m_law;
+  Distribution * m_distribution;
 };
 
 }
diff --git a/apps/probability/calculation/discrete_calculation.cpp b/apps/probability/calculation/discrete_calculation.cpp
index 46a166b7f..075038512 100644
--- a/apps/probability/calculation/discrete_calculation.cpp
+++ b/apps/probability/calculation/discrete_calculation.cpp
@@ -38,10 +38,10 @@ double DiscreteCalculation::parameterAtIndex(int index) {
 }
 
 void DiscreteCalculation::compute(int indexKnownElement) {
-  if (m_law == nullptr) {
+  if (m_distribution == nullptr) {
     return;
   }
-  m_result = m_law->evaluateAtDiscreteAbscissa(m_abscissa);
+  m_result = m_distribution->evaluateAtDiscreteAbscissa(m_abscissa);
 }
 
 }
diff --git a/apps/probability/calculation/finite_integral_calculation.cpp b/apps/probability/calculation/finite_integral_calculation.cpp
index 1a9e1ad1b..a1ac5d9c8 100644
--- a/apps/probability/calculation/finite_integral_calculation.cpp
+++ b/apps/probability/calculation/finite_integral_calculation.cpp
@@ -1,5 +1,5 @@
 #include "finite_integral_calculation.h"
-#include "../law/normal_law.h"
+#include "../distribution/normal_distribution.h"
 #include <assert.h>
 #include <ion.h>
 #include <cmath>
@@ -53,16 +53,16 @@ double FiniteIntegralCalculation::parameterAtIndex(int index) {
 }
 
 void FiniteIntegralCalculation::compute(int indexKnownElement) {
-  if (m_law == nullptr) {
+  if (m_distribution == nullptr) {
     return;
   }
   if (indexKnownElement == 2) {
-    assert(m_law->type() == Law::Type::Normal);
+    assert(m_distribution->type() == Distribution::Type::Normal);
     double p = (1.0+m_result)/2.0;
-    m_upperBound = ((NormalLaw *)m_law)->cumulativeDistributiveInverseForProbability(&p);
-    m_lowerBound = 2.0*m_law->parameterValueAtIndex(0)-m_upperBound;
+    m_upperBound = ((NormalDistribution *)m_distribution)->cumulativeDistributiveInverseForProbability(&p);
+    m_lowerBound = 2.0*m_distribution->parameterValueAtIndex(0)-m_upperBound;
   }
-  m_result = m_law->finiteIntegralBetweenAbscissas(m_lowerBound, m_upperBound);
+  m_result = m_distribution->finiteIntegralBetweenAbscissas(m_lowerBound, m_upperBound);
 }
 
 }
diff --git a/apps/probability/calculation/left_integral_calculation.cpp b/apps/probability/calculation/left_integral_calculation.cpp
index f0ccc8198..d1de80e16 100644
--- a/apps/probability/calculation/left_integral_calculation.cpp
+++ b/apps/probability/calculation/left_integral_calculation.cpp
@@ -41,17 +41,17 @@ double LeftIntegralCalculation::parameterAtIndex(int index) {
 }
 
 void LeftIntegralCalculation::compute(int indexKnownElement) {
-  if (m_law == nullptr) {
+  if (m_distribution == nullptr) {
     return;
   }
   if (indexKnownElement == 0) {
-    m_result = m_law->cumulativeDistributiveFunctionAtAbscissa(m_upperBound);
+    m_result = m_distribution->cumulativeDistributiveFunctionAtAbscissa(m_upperBound);
   } else {
-    double currentResult = m_law->cumulativeDistributiveFunctionAtAbscissa(m_upperBound);
+    double currentResult = m_distribution->cumulativeDistributiveFunctionAtAbscissa(m_upperBound);
     if (std::fabs(currentResult - m_result) < std::pow(10.0, - Constant::LargeNumberOfSignificantDigits)) {
       return;
     }
-    m_upperBound = m_law->cumulativeDistributiveInverseForProbability(&m_result);
+    m_upperBound = m_distribution->cumulativeDistributiveInverseForProbability(&m_result);
   }
 }
 
diff --git a/apps/probability/calculation/right_integral_calculation.cpp b/apps/probability/calculation/right_integral_calculation.cpp
index 83a82436f..04f79e7ff 100644
--- a/apps/probability/calculation/right_integral_calculation.cpp
+++ b/apps/probability/calculation/right_integral_calculation.cpp
@@ -41,17 +41,17 @@ double RightIntegralCalculation::parameterAtIndex(int index) {
 }
 
 void RightIntegralCalculation::compute(int indexKnownElement) {
-  if (m_law == nullptr) {
+  if (m_distribution == nullptr) {
     return;
   }
   if (indexKnownElement == 0) {
-    m_result = m_law->rightIntegralFromAbscissa(m_lowerBound);
+    m_result = m_distribution->rightIntegralFromAbscissa(m_lowerBound);
   } else {
-    double currentResult = m_law->rightIntegralFromAbscissa(m_lowerBound);
+    double currentResult = m_distribution->rightIntegralFromAbscissa(m_lowerBound);
     if (std::fabs(currentResult - m_result) < std::pow(10.0, - Constant::LargeNumberOfSignificantDigits)) {
       return;
     }
-    m_lowerBound = m_law->rightIntegralInverseForProbability(&m_result);
+    m_lowerBound = m_distribution->rightIntegralInverseForProbability(&m_result);
   }
 }
 
diff --git a/apps/probability/calculation_controller.cpp b/apps/probability/calculation_controller.cpp
index 09c905cfd..c91f91409 100644
--- a/apps/probability/calculation_controller.cpp
+++ b/apps/probability/calculation_controller.cpp
@@ -24,10 +24,10 @@ namespace Probability {
 
 static inline int minInt(int x, int y) { return x < y ? x : y; }
 
-CalculationController::ContentView::ContentView(SelectableTableView * selectableTableView, Law * law, Calculation * calculation) :
+CalculationController::ContentView::ContentView(SelectableTableView * selectableTableView, Distribution * distribution, Calculation * calculation) :
   m_titleView(KDFont::SmallFont, I18n::Message::ComputeProbability, 0.5f, 0.5f, Palette::GreyDark, Palette::WallScreen),
   m_selectableTableView(selectableTableView),
-  m_lawCurveView(law, calculation)
+  m_distributionCurveView(distribution, calculation)
 {
 }
 
@@ -43,7 +43,7 @@ View * CalculationController::ContentView::subviewAtIndex(int index) {
   if (index == 1) {
     return m_selectableTableView;
   }
-  return &m_lawCurveView;
+  return &m_distributionCurveView;
 }
 
 void CalculationController::ContentView::layoutSubviews() {
@@ -51,18 +51,18 @@ void CalculationController::ContentView::layoutSubviews() {
   m_titleView.setFrame(KDRect(0, 0, bounds().width(), titleHeight));
   KDCoordinate calculationHeight = ResponderImageCell::k_oneCellHeight+2*k_tableMargin;
   m_selectableTableView->setFrame(KDRect(0,  titleHeight, bounds().width(), calculationHeight));
-  m_lawCurveView.setFrame(KDRect(0,  titleHeight+calculationHeight, bounds().width(), bounds().height() - calculationHeight - titleHeight));
+  m_distributionCurveView.setFrame(KDRect(0,  titleHeight+calculationHeight, bounds().width(), bounds().height() - calculationHeight - titleHeight));
 }
 
-CalculationController::CalculationController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Law * law, Calculation * calculation) :
+CalculationController::CalculationController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Distribution * distribution, Calculation * calculation) :
   ViewController(parentResponder),
-  m_contentView(&m_selectableTableView, law, calculation),
+  m_contentView(&m_selectableTableView, distribution, calculation),
   m_selectableTableView(this),
-  m_imageCell(&m_selectableTableView, law, calculation, this),
+  m_imageCell(&m_selectableTableView, distribution, calculation, this),
   m_calculation(calculation),
-  m_law(law)
+  m_distribution(distribution)
 {
-  assert(law != nullptr);
+  assert(distribution != nullptr);
   assert(calculation != nullptr);
   m_selectableTableView.setMargins(k_tableMargin);
   m_selectableTableView.setVerticalCellOverlap(0);
@@ -79,7 +79,7 @@ CalculationController::CalculationController(Responder * parentResponder, InputE
 void CalculationController::didEnterResponderChain(Responder * previousResponder) {
   App::app()->snapshot()->setActivePage(App::Snapshot::Page::Calculations);
   updateTitle();
-  reloadLawCurveView();
+  reloadDistributionCurveView();
   m_selectableTableView.reloadData();
 }
 
@@ -171,7 +171,7 @@ void CalculationController::willDisplayCellAtLocation(HighlightCell * cell, int
     CalculationCell * myCell = static_cast<CalculationCell *>(cell);
     myCell->messageTextView()->setMessage(m_calculation->legendForParameterAtIndex(i-1));
     bool calculationCellIsResponder = true;
-    if ((m_law->type() != Law::Type::Normal && i == 3) || (m_calculation->type() == Calculation::Type::Discrete && i == 2)) {
+    if ((m_distribution->type() != Distribution::Type::Normal && i == 3) || (m_calculation->type() == Calculation::Type::Discrete && i == 2)) {
       calculationCellIsResponder = false;
     }
     myCell->setResponder(calculationCellIsResponder);
@@ -222,7 +222,7 @@ bool CalculationController::textFieldDidFinishEditing(TextField * textField, con
       floatBody = 1.0;
     }
   }
-  if (!m_law->isContinuous() && (selectedColumn() == 1 || m_calculation->type() == Calculation::Type::FiniteIntegral)) {
+  if (!m_distribution->isContinuous() && (selectedColumn() == 1 || m_calculation->type() == Calculation::Type::FiniteIntegral)) {
     floatBody = std::round(floatBody);
   }
   m_calculation->setParameterAtIndex(floatBody, selectedColumn()-1);
@@ -233,13 +233,13 @@ bool CalculationController::textFieldDidFinishEditing(TextField * textField, con
   return true;
 }
 
-void CalculationController::reloadLawCurveView() {
-  m_contentView.lawCurveView()->reload();
+void CalculationController::reloadDistributionCurveView() {
+  m_contentView.distributionCurveView()->reload();
 }
 
 void CalculationController::reload() {
   m_selectableTableView.reloadData();
-  reloadLawCurveView();
+  reloadDistributionCurveView();
 }
 
 void CalculationController::setCalculationAccordingToIndex(int index, bool forceReinitialisation) {
@@ -263,18 +263,18 @@ void CalculationController::setCalculationAccordingToIndex(int index, bool force
     default:
      return;
   }
-  m_calculation->setLaw(m_law);
+  m_calculation->setDistribution(m_distribution);
 }
 
 void CalculationController::updateTitle() {
   int currentChar = 0;
-  for (int index = 0; index < m_law->numberOfParameter(); index++) {
+  for (int index = 0; index < m_distribution->numberOfParameter(); index++) {
     if (currentChar >= k_titleBufferSize) {
       break;
     }
     /* strlcpy returns the size of src, not the size copied, but it is not a
      * problem here. */
-    currentChar += strlcpy(m_titleBuffer+currentChar, I18n::translate(m_law->parameterNameAtIndex(index)), k_titleBufferSize - currentChar);
+    currentChar += strlcpy(m_titleBuffer+currentChar, I18n::translate(m_distribution->parameterNameAtIndex(index)), k_titleBufferSize - currentChar);
     if (currentChar >= k_titleBufferSize) {
       break;
     }
@@ -285,7 +285,7 @@ void CalculationController::updateTitle() {
     constexpr int precision = Constant::ShortNumberOfSignificantDigits;
     constexpr size_t bufferSize = PrintFloat::bufferSizeForFloatsWithPrecision(precision);
     char buffer[bufferSize];
-    PrintFloat::ConvertFloatToText<double>(m_law->parameterValueAtIndex(index), buffer, bufferSize, precision, Preferences::PrintFloatMode::Decimal);
+    PrintFloat::ConvertFloatToText<double>(m_distribution->parameterValueAtIndex(index), buffer, bufferSize, precision, Preferences::PrintFloatMode::Decimal);
     currentChar += strlcpy(m_titleBuffer+currentChar, buffer, k_titleBufferSize - currentChar);
     if (currentChar >= k_titleBufferSize) {
       break;
diff --git a/apps/probability/calculation_controller.h b/apps/probability/calculation_controller.h
index bd1705dfb..e785b7321 100644
--- a/apps/probability/calculation_controller.h
+++ b/apps/probability/calculation_controller.h
@@ -2,8 +2,8 @@
 #define PROBABILITY_CALCULATION_CONTROLLER_H
 
 #include <escher.h>
-#include "law/law.h"
-#include "law_curve_view.h"
+#include "distribution/distribution.h"
+#include "distribution_curve_view.h"
 #include "calculation_cell.h"
 #include "responder_image_cell.h"
 #include "calculation/calculation.h"
@@ -13,7 +13,7 @@ namespace Probability {
 
 class CalculationController : public ViewController, public TableViewDataSource, public SelectableTableViewDataSource, public Shared::ParameterTextFieldDelegate {
 public:
-  CalculationController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Law * law, Calculation * calculation);
+  CalculationController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Distribution * distribution, Calculation * calculation);
   /* Responder */
   void didEnterResponderChain(Responder * previousResponder) override;
   void didBecomeFirstResponder() override;
@@ -41,7 +41,7 @@ public:
   bool textFieldShouldFinishEditing(TextField * textField, Ion::Events::Event event) override;
   bool textFieldDidFinishEditing(TextField * textField, const char * text, Ion::Events::Event event) override;
 
-  void reloadLawCurveView();
+  void reloadDistributionCurveView();
   void reload();
   void setCalculationAccordingToIndex(int index, bool forceReinitialisation = false);
 private:
@@ -50,9 +50,9 @@ private:
   void updateTitle();
   class ContentView : public View {
   public:
-    ContentView(SelectableTableView * selectableTableView, Law * law, Calculation * calculation);
-    LawCurveView * lawCurveView() {
-      return &m_lawCurveView;
+    ContentView(SelectableTableView * selectableTableView, Distribution * distribution, Calculation * calculation);
+    DistributionCurveView * distributionCurveView() {
+      return &m_distributionCurveView;
     }
   private:
     constexpr static KDCoordinate k_titleHeightMargin = 5;
@@ -61,14 +61,14 @@ private:
     void layoutSubviews() override;
     MessageTextView m_titleView;
     SelectableTableView * m_selectableTableView;
-    LawCurveView m_lawCurveView;
+    DistributionCurveView m_distributionCurveView;
   };
   ContentView m_contentView;
   SelectableTableView m_selectableTableView;
   ResponderImageCell m_imageCell;
   CalculationCell m_calculationCells[k_numberOfCalculationCells];
   Calculation * m_calculation;
-  Law * m_law;
+  Distribution * m_distribution;
   constexpr static int k_titleBufferSize = 30;
   char m_titleBuffer[k_titleBufferSize];
 };
diff --git a/apps/probability/calculation_type_controller.cpp b/apps/probability/calculation_type_controller.cpp
index b793277f4..6e3504d0b 100644
--- a/apps/probability/calculation_type_controller.cpp
+++ b/apps/probability/calculation_type_controller.cpp
@@ -12,10 +12,10 @@
 
 namespace Probability {
 
-CalculationTypeController::CalculationTypeController(Responder * parentResponder, Law * law, Calculation * calculation, CalculationController * calculationController) :
+CalculationTypeController::CalculationTypeController(Responder * parentResponder, Distribution * distribution, Calculation * calculation, CalculationController * calculationController) :
   ViewController(parentResponder),
   m_selectableTableView(this),
-  m_law(law),
+  m_distribution(distribution),
   m_calculation(calculation),
   m_calculationController(calculationController)
 {
@@ -60,7 +60,7 @@ bool CalculationTypeController::handleEvent(Ion::Events::Event event) {
 }
 
 int CalculationTypeController::numberOfRows() {
-  if (m_law->isContinuous()) {
+  if (m_distribution->isContinuous()) {
     return k_numberOfImages-1;
   }
   return k_numberOfImages;
diff --git a/apps/probability/calculation_type_controller.h b/apps/probability/calculation_type_controller.h
index 440a7d3f8..94f655120 100644
--- a/apps/probability/calculation_type_controller.h
+++ b/apps/probability/calculation_type_controller.h
@@ -3,7 +3,7 @@
 
 #include <escher.h>
 #include "calculation/calculation.h"
-#include "law/law.h"
+#include "distribution/distribution.h"
 #include "image_cell.h"
 
 namespace Probability {
@@ -12,7 +12,7 @@ class CalculationController;
 
 class CalculationTypeController : public ViewController, public SimpleListViewDataSource, public SelectableTableViewDataSource {
 public:
-  CalculationTypeController(Responder * parentResponder, Law * law, Calculation * calculation, CalculationController * calculationController);
+  CalculationTypeController(Responder * parentResponder, Distribution * distribution, Calculation * calculation, CalculationController * calculationController);
   View * view() override;
   void viewWillAppear() override;
   void viewDidDisappear() override;
@@ -28,7 +28,7 @@ public:
 private:
   ImageCell m_imageCells[k_numberOfImages];
   SelectableTableView m_selectableTableView;
-  Law * m_law;
+  Distribution * m_distribution;
   Calculation * m_calculation;
   CalculationController * m_calculationController;
 };
diff --git a/apps/probability/law/binomial_law.cpp b/apps/probability/distribution/binomial_distribution.cpp
similarity index 73%
rename from apps/probability/law/binomial_law.cpp
rename to apps/probability/distribution/binomial_distribution.cpp
index e5988c6b6..76f3e22f4 100644
--- a/apps/probability/law/binomial_law.cpp
+++ b/apps/probability/distribution/binomial_distribution.cpp
@@ -1,10 +1,10 @@
-#include "binomial_law.h"
+#include "binomial_distribution.h"
 #include <assert.h>
 #include <cmath>
 
 namespace Probability {
 
-I18n::Message BinomialLaw::parameterNameAtIndex(int index) {
+I18n::Message BinomialDistribution::parameterNameAtIndex(int index) {
   assert(index >= 0 && index < 2);
   if (index == 0) {
     return I18n::Message::N;
@@ -13,7 +13,7 @@ I18n::Message BinomialLaw::parameterNameAtIndex(int index) {
   }
 }
 
-I18n::Message BinomialLaw::parameterDefinitionAtIndex(int index) {
+I18n::Message BinomialDistribution::parameterDefinitionAtIndex(int index) {
   assert(index >= 0 && index < 2);
   if (index == 0) {
     return I18n::Message::RepetitionNumber;
@@ -22,13 +22,13 @@ I18n::Message BinomialLaw::parameterDefinitionAtIndex(int index) {
   }
 }
 
-float BinomialLaw::xMin() const {
+float BinomialDistribution::xMin() const {
   float min = 0.0f;
   float max = m_parameter1 > 0.0f ? m_parameter1 : 1.0f;
   return min - k_displayLeftMarginRatio * (max - min);
 }
 
-float BinomialLaw::xMax() const {
+float BinomialDistribution::xMax() const {
   float min = 0.0f;
   float max = m_parameter1;
   if (max <= min) {
@@ -37,7 +37,7 @@ float BinomialLaw::xMax() const {
   return max + k_displayRightMarginRatio*(max - min);
 }
 
-float BinomialLaw::yMax() const {
+float BinomialDistribution::yMax() const {
   int maxAbscissa = m_parameter2 < 1.0f ? (m_parameter1+1)*m_parameter2 : m_parameter1;
   float result = evaluateAtAbscissa(maxAbscissa);
   if (result <= 0.0f || std::isnan(result)) {
@@ -47,7 +47,7 @@ float BinomialLaw::yMax() const {
 }
 
 
-bool BinomialLaw::authorizedValueAtIndex(float x, int index) const {
+bool BinomialDistribution::authorizedValueAtIndex(float x, int index) const {
   if (index == 0) {
     /* As the cumulative probability are computed by looping over all discrete
      * abscissa within the interesting range, the complexity of the cumulative
@@ -67,28 +67,28 @@ bool BinomialLaw::authorizedValueAtIndex(float x, int index) const {
   return true;
 }
 
-double BinomialLaw::cumulativeDistributiveInverseForProbability(double * probability) {
+double BinomialDistribution::cumulativeDistributiveInverseForProbability(double * probability) {
   if (m_parameter1 == 0.0 && (m_parameter2 == 0.0 || m_parameter2 == 1.0)) {
     return NAN;
   }
   if (*probability >= 1.0) {
     return m_parameter1;
   }
-  return Law::cumulativeDistributiveInverseForProbability(probability);
+  return Distribution::cumulativeDistributiveInverseForProbability(probability);
 }
 
-double BinomialLaw::rightIntegralInverseForProbability(double * probability) {
+double BinomialDistribution::rightIntegralInverseForProbability(double * probability) {
   if (m_parameter1 == 0.0 && (m_parameter2 == 0.0 || m_parameter2 == 1.0)) {
     return NAN;
   }
   if (*probability <= 0.0) {
     return m_parameter1;
   }
-  return Law::rightIntegralInverseForProbability(probability);
+  return Distribution::rightIntegralInverseForProbability(probability);
 }
 
 template<typename T>
-T BinomialLaw::templatedApproximateAtAbscissa(T x) const {
+T BinomialDistribution::templatedApproximateAtAbscissa(T x) const {
   if (m_parameter1 == 0) {
     if (m_parameter2 == 0 || m_parameter2 == 1) {
       return NAN;
@@ -120,5 +120,5 @@ T BinomialLaw::templatedApproximateAtAbscissa(T x) const {
 
 }
 
-template float Probability::BinomialLaw::templatedApproximateAtAbscissa(float x) const;
-template double Probability::BinomialLaw::templatedApproximateAtAbscissa(double x) const;
+template float Probability::BinomialDistribution::templatedApproximateAtAbscissa(float x) const;
+template double Probability::BinomialDistribution::templatedApproximateAtAbscissa(double x) const;
diff --git a/apps/probability/law/binomial_law.h b/apps/probability/distribution/binomial_distribution.h
similarity index 77%
rename from apps/probability/law/binomial_law.h
rename to apps/probability/distribution/binomial_distribution.h
index 4d488ea3d..7b8811d4e 100644
--- a/apps/probability/law/binomial_law.h
+++ b/apps/probability/distribution/binomial_distribution.h
@@ -1,14 +1,14 @@
-#ifndef PROBABILITE_BINOMIAL_LAW_H
-#define PROBABILITE_BINOMIAL_LAW_H
+#ifndef PROBABILITE_BINOMIAL_DISTRIBUTION_H
+#define PROBABILITE_BINOMIAL_DISTRIBUTION_H
 
-#include "two_parameter_law.h"
+#include "two_parameter_distribution.h"
 
 namespace Probability {
 
-class BinomialLaw final : public TwoParameterLaw {
+class BinomialDistribution final : public TwoParameterDistribution {
 public:
-  BinomialLaw() : TwoParameterLaw(20.0, 0.5) {}
-  I18n::Message title() override { return I18n::Message::BinomialLaw; }
+  BinomialDistribution() : TwoParameterDistribution(20.0, 0.5) {}
+  I18n::Message title() override { return I18n::Message::BinomialDistribution; }
   Type type() const override { return Type::Binomial; }
   bool isContinuous() const override { return false; }
   float xMin() const override;
diff --git a/apps/probability/law/chi_squared_law.cpp b/apps/probability/distribution/chi_squared_distribution.cpp
similarity index 82%
rename from apps/probability/law/chi_squared_law.cpp
rename to apps/probability/distribution/chi_squared_distribution.cpp
index e191b7abc..464c222b0 100644
--- a/apps/probability/law/chi_squared_law.cpp
+++ b/apps/probability/distribution/chi_squared_distribution.cpp
@@ -1,4 +1,4 @@
-#include "chi_squared_law.h"
+#include "chi_squared_distribution.h"
 #include "regularized_gamma.h"
 #include <cmath>
 
@@ -6,16 +6,16 @@ namespace Probability {
 
 static inline double maxDouble(double x, double y) { return x > y ? x : y; }
 
-float ChiSquaredLaw::xMin() const {
+float ChiSquaredDistribution::xMin() const {
   return -k_displayLeftMarginRatio * xMax();
 }
 
-float ChiSquaredLaw::xMax() const {
+float ChiSquaredDistribution::xMax() const {
   assert(m_parameter1 != 0);
   return (m_parameter1 + 5.0f * std::sqrt(m_parameter1)) * (1.0f + k_displayRightMarginRatio);
 }
 
-float ChiSquaredLaw::yMax() const {
+float ChiSquaredDistribution::yMax() const {
   float result;
   if (m_parameter1/2.0 <= 1 + FLT_EPSILON) {
     result = 0.5f;
@@ -25,7 +25,7 @@ float ChiSquaredLaw::yMax() const {
   return result * (1.0f + k_displayTopMarginRatio);
 }
 
-float ChiSquaredLaw::evaluateAtAbscissa(float x) const {
+float ChiSquaredDistribution::evaluateAtAbscissa(float x) const {
   if (x < 0) {
     return NAN;
   }
@@ -34,12 +34,12 @@ float ChiSquaredLaw::evaluateAtAbscissa(float x) const {
   return coefficient() * std::pow(halfX, halfk-1) * std::exp(-halfX);
 }
 
-bool ChiSquaredLaw::authorizedValueAtIndex(float x, int index) const {
+bool ChiSquaredDistribution::authorizedValueAtIndex(float x, int index) const {
   assert(index == 0);
   return x > 0 && x == (int)x;
 }
 
-double ChiSquaredLaw::cumulativeDistributiveFunctionAtAbscissa(double x) const {
+double ChiSquaredDistribution::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   if (x < 0) {
     return 0;
   }
@@ -51,7 +51,7 @@ double ChiSquaredLaw::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   return NAN;
 }
 
-double ChiSquaredLaw::cumulativeDistributiveInverseForProbability(double * probability) {
+double ChiSquaredDistribution::cumulativeDistributiveInverseForProbability(double * probability) {
   /* We have to compute the values of the interval in chich to look for x.
    * We cannot put xMin because xMin is < 0 for display purposes, and negative
    * values are not accepted.
@@ -80,7 +80,7 @@ double ChiSquaredLaw::cumulativeDistributiveInverseForProbability(double * proba
   return cumulativeDistributiveInverseForProbabilityUsingIncreasingFunctionRoot(probability, DBL_EPSILON, maxDouble(xMax(), xmax));
 }
 
-float ChiSquaredLaw::coefficient() const {
+float ChiSquaredDistribution::coefficient() const {
   const float halfk = m_parameter1/2;
   return 1 / (2 * std::exp(std::lgamma(halfk)));
 }
diff --git a/apps/probability/law/chi_squared_law.h b/apps/probability/distribution/chi_squared_distribution.h
similarity index 78%
rename from apps/probability/law/chi_squared_law.h
rename to apps/probability/distribution/chi_squared_distribution.h
index 0edd0c666..ebd6c05e1 100644
--- a/apps/probability/law/chi_squared_law.h
+++ b/apps/probability/distribution/chi_squared_distribution.h
@@ -1,18 +1,18 @@
-#ifndef PROBABILITY_CHI_SQUARED_LAW_H
-#define PROBABILITY_CHI_SQUARED_LAW_H
+#ifndef PROBABILITY_CHI_SQUARED_DISTRIBUTION_H
+#define PROBABILITY_CHI_SQUARED_DISTRIBUTION_H
 
-#include "one_parameter_law.h"
+#include "one_parameter_distribution.h"
 #include <float.h>
 
 namespace Probability {
 
-class ChiSquaredLaw : public OneParameterLaw {
+class ChiSquaredDistribution : public OneParameterDistribution {
 public:
   static constexpr int k_maxRegularizedGammaIterations = 1000;
   static constexpr double k_regularizedGammaPrecision = DBL_EPSILON;
 
-  ChiSquaredLaw() : OneParameterLaw(1.0f) {}
-  I18n::Message title() override { return I18n::Message::ChiSquaredLaw; }
+  ChiSquaredDistribution() : OneParameterDistribution(1.0f) {}
+  I18n::Message title() override { return I18n::Message::ChiSquaredDistribution; }
   Type type() const override { return Type::ChiSquared; }
   bool isContinuous() const override { return true; }
   float xMin() const override;
diff --git a/apps/probability/law/law.cpp b/apps/probability/distribution/distribution.cpp
similarity index 80%
rename from apps/probability/law/law.cpp
rename to apps/probability/distribution/distribution.cpp
index e482d8fa2..1b11da20e 100644
--- a/apps/probability/law/law.cpp
+++ b/apps/probability/distribution/distribution.cpp
@@ -1,11 +1,11 @@
-#include "law.h"
+#include "distribution.h"
 #include <poincare/solver.h>
 #include <cmath>
 #include <float.h>
 
 namespace Probability {
 
-double Law::cumulativeDistributiveFunctionAtAbscissa(double x) const {
+double Distribution::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   if (!isContinuous()) {
     int end = std::round(x);
     double result = 0.0;
@@ -26,14 +26,14 @@ double Law::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   return 0.0;
 }
 
-double Law::rightIntegralFromAbscissa(double x) const {
+double Distribution::rightIntegralFromAbscissa(double x) const {
   if (isContinuous()) {
     return 1.0 - cumulativeDistributiveFunctionAtAbscissa(x);
   }
   return 1.0 - cumulativeDistributiveFunctionAtAbscissa(x-1.0);
 }
 
-double Law::finiteIntegralBetweenAbscissas(double a, double b) const {
+double Distribution::finiteIntegralBetweenAbscissas(double a, double b) const {
   if (b < a) {
     return 0.0;
   }
@@ -57,7 +57,7 @@ double Law::finiteIntegralBetweenAbscissas(double a, double b) const {
   return result;
 }
 
-double Law::cumulativeDistributiveInverseForProbability(double * probability) {
+double Distribution::cumulativeDistributiveInverseForProbability(double * probability) {
   if (*probability >= 1.0) {
     return INFINITY;
   }
@@ -90,7 +90,7 @@ double Law::cumulativeDistributiveInverseForProbability(double * probability) {
   return k-1.0;
 }
 
-double Law::rightIntegralInverseForProbability(double * probability) {
+double Distribution::rightIntegralInverseForProbability(double * probability) {
   if (isContinuous()) {
     double f = 1.0 - *probability;
     return cumulativeDistributiveInverseForProbability(&f);
@@ -123,11 +123,11 @@ double Law::rightIntegralInverseForProbability(double * probability) {
   return k-1.0;
 }
 
-double Law::evaluateAtDiscreteAbscissa(int k) const {
+double Distribution::evaluateAtDiscreteAbscissa(int k) const {
   return 0.0;
 }
 
-double Law::cumulativeDistributiveInverseForProbabilityUsingIncreasingFunctionRoot(double * probability, double ax, double bx) {
+double Distribution::cumulativeDistributiveInverseForProbabilityUsingIncreasingFunctionRoot(double * probability, double ax, double bx) {
   assert(ax < bx);
   if (*probability >= 1) {
     return INFINITY;
@@ -140,9 +140,9 @@ double Law::cumulativeDistributiveInverseForProbabilityUsingIncreasingFunctionRo
       bx,
       DBL_EPSILON,
       [](double x, Poincare::Context * context, Poincare::Preferences::ComplexFormat complexFormat, Poincare::Preferences::AngleUnit angleUnit, const void * context1, const void * context2, const void * context3) {
-        const Law * law = reinterpret_cast<const Law *>(context1);
+        const Distribution * distribution = reinterpret_cast<const Distribution *>(context1);
         const double * proba = reinterpret_cast<const double *>(context2);
-        return law->cumulativeDistributiveFunctionAtAbscissa(x) - *proba; // This needs to be an increasing function
+        return distribution->cumulativeDistributiveFunctionAtAbscissa(x) - *proba; // This needs to be an increasing function
       },
       nullptr,
       Poincare::Preferences::sharedPreferences()->complexFormat(),
@@ -154,7 +154,7 @@ double Law::cumulativeDistributiveInverseForProbabilityUsingIncreasingFunctionRo
   return result.abscissa();
 }
 
-float Law::yMin() const {
+float Distribution::yMin() const {
   return -k_displayBottomMarginRatio * yMax();
 }
 
diff --git a/apps/probability/law/law.h b/apps/probability/distribution/distribution.h
similarity index 90%
rename from apps/probability/law/law.h
rename to apps/probability/distribution/distribution.h
index 73d58161a..fb19a1b9c 100644
--- a/apps/probability/law/law.h
+++ b/apps/probability/distribution/distribution.h
@@ -1,5 +1,5 @@
-#ifndef PROBABILITE_LAW_H
-#define PROBABILITE_LAW_H
+#ifndef PROBABILITE_DISTRIBUTION_H
+#define PROBABILITE_DISTRIBUTION_H
 
 #include <escher.h>
 #include "../../constant.h"
@@ -8,9 +8,9 @@
 
 namespace Probability {
 
-class Law : public Shared::CurveViewRange {
+class Distribution : public Shared::CurveViewRange {
 public:
-  Law() : Shared::CurveViewRange() {}
+  Distribution() : Shared::CurveViewRange() {}
   enum class Type : uint8_t{
     Binomial,
     Uniform,
@@ -21,7 +21,7 @@ public:
     Geometric,
     Poisson
   };
-  virtual ~Law() = default;
+  virtual ~Distribution() = default;
   virtual I18n::Message title() = 0;
   virtual Type type() const = 0;
   virtual bool isContinuous() const = 0;
diff --git a/apps/probability/law/erf_inv.cpp b/apps/probability/distribution/erf_inv.cpp
similarity index 97%
rename from apps/probability/law/erf_inv.cpp
rename to apps/probability/distribution/erf_inv.cpp
index 87afdd344..67632fb63 100644
--- a/apps/probability/law/erf_inv.cpp
+++ b/apps/probability/distribution/erf_inv.cpp
@@ -1,5 +1,5 @@
 #include "erf_inv.h"
-#include "law.h"
+#include "distribution.h"
 #include <cmath>
 #include <float.h>
 
@@ -13,7 +13,7 @@
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software
+ * Unless required by applicable distribution or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
diff --git a/apps/probability/law/erf_inv.h b/apps/probability/distribution/erf_inv.h
similarity index 100%
rename from apps/probability/law/erf_inv.h
rename to apps/probability/distribution/erf_inv.h
diff --git a/apps/probability/law/exponential_law.cpp b/apps/probability/distribution/exponential_distribution.cpp
similarity index 64%
rename from apps/probability/law/exponential_law.cpp
rename to apps/probability/distribution/exponential_distribution.cpp
index c2d46fbc3..5c66f6da3 100644
--- a/apps/probability/law/exponential_law.cpp
+++ b/apps/probability/distribution/exponential_distribution.cpp
@@ -1,14 +1,14 @@
-#include "exponential_law.h"
+#include "exponential_distribution.h"
 #include <cmath>
 #include <float.h>
 
 namespace Probability {
 
-float ExponentialLaw::xMin() const {
+float ExponentialDistribution::xMin() const {
   return - k_displayLeftMarginRatio * xMax();
 }
 
-float ExponentialLaw::xMax() const {
+float ExponentialDistribution::xMax() const {
   assert(m_parameter1 != 0.0f);
   float result = 5.0f/m_parameter1;
   if (result <= 0.0f) {
@@ -17,7 +17,7 @@ float ExponentialLaw::xMax() const {
   return result * (1.0f + k_displayRightMarginRatio);
 }
 
-float ExponentialLaw::yMax() const {
+float ExponentialDistribution::yMax() const {
   float result = m_parameter1;
   if (result <= 0.0f || std::isnan(result)) {
     result = 1.0f;
@@ -28,28 +28,28 @@ float ExponentialLaw::yMax() const {
   return result * (1.0f + k_displayTopMarginRatio);
 }
 
-float ExponentialLaw::evaluateAtAbscissa(float x) const {
+float ExponentialDistribution::evaluateAtAbscissa(float x) const {
   if (x < 0.0f) {
     return NAN;
   }
   return m_parameter1 * std::exp(-m_parameter1 * x);
 }
 
-bool ExponentialLaw::authorizedValueAtIndex(float x, int index) const {
+bool ExponentialDistribution::authorizedValueAtIndex(float x, int index) const {
   if (x <= 0.0f || x > 7500.0f) {
     return false;
   }
   return true;
 }
 
-double ExponentialLaw::cumulativeDistributiveFunctionAtAbscissa(double x) const {
+double ExponentialDistribution::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   if (x < 0.0) {
     return 0.0;
   }
   return 1.0 - std::exp((double)(-m_parameter1 * x));
 }
 
-double ExponentialLaw::cumulativeDistributiveInverseForProbability(double * probability) {
+double ExponentialDistribution::cumulativeDistributiveInverseForProbability(double * probability) {
   if (*probability >= 1.0) {
     return INFINITY;
   }
diff --git a/apps/probability/law/exponential_law.h b/apps/probability/distribution/exponential_distribution.h
similarity index 75%
rename from apps/probability/law/exponential_law.h
rename to apps/probability/distribution/exponential_distribution.h
index b3062d58e..97d86ac34 100644
--- a/apps/probability/law/exponential_law.h
+++ b/apps/probability/distribution/exponential_distribution.h
@@ -1,15 +1,15 @@
-#ifndef PROBABILITE_EXPONENTIAL_LAW_H
-#define PROBABILITE_EXPONENTIAL_LAW_H
+#ifndef PROBABILITE_EXPONENTIAL_DISTRIBUTION_H
+#define PROBABILITE_EXPONENTIAL_DISTRIBUTION_H
 
-#include "one_parameter_law.h"
+#include "one_parameter_distribution.h"
 #include <assert.h>
 
 namespace Probability {
 
-class ExponentialLaw final : public OneParameterLaw {
+class ExponentialDistribution final : public OneParameterDistribution {
 public:
-  ExponentialLaw() : OneParameterLaw(1.0f) {}
-  I18n::Message title() override { return I18n::Message::ExponentialLaw; }
+  ExponentialDistribution() : OneParameterDistribution(1.0f) {}
+  I18n::Message title() override { return I18n::Message::ExponentialDistribution; }
   Type type() const override { return Type::Exponential; }
   bool isContinuous() const override { return true; }
   float xMin() const override;
diff --git a/apps/probability/law/geometric_law.cpp b/apps/probability/distribution/geometric_distribution.cpp
similarity index 56%
rename from apps/probability/law/geometric_law.cpp
rename to apps/probability/distribution/geometric_distribution.cpp
index 94b380600..1ac3559cd 100644
--- a/apps/probability/law/geometric_law.cpp
+++ b/apps/probability/distribution/geometric_distribution.cpp
@@ -1,26 +1,26 @@
-#include "geometric_law.h"
+#include "geometric_distribution.h"
 #include <assert.h>
 #include <cmath>
 #include <ion.h>
 
 namespace Probability {
 
-float GeometricLaw::xMin() const {
+float GeometricDistribution::xMin() const {
   return -k_displayLeftMarginRatio * xMax();
 }
 
-float GeometricLaw::xMax() const {
+float GeometricDistribution::xMax() const {
   assert(m_parameter1 != 0);
   return 5/m_parameter1 * (1.0f + k_displayRightMarginRatio);
 }
 
-float GeometricLaw::yMax() const {
+float GeometricDistribution::yMax() const {
   int maxAbscissa = 0;
   float result = evaluateAtAbscissa(maxAbscissa);
   return result * (1.0f + k_displayTopMarginRatio);
 }
 
-bool GeometricLaw::authorizedValueAtIndex(float x, int index) const {
+bool GeometricDistribution::authorizedValueAtIndex(float x, int index) const {
   assert(index == 0);
   if (x <= 0.0f || x > 1.0f) {
     return false;
@@ -29,7 +29,7 @@ bool GeometricLaw::authorizedValueAtIndex(float x, int index) const {
 }
 
 template<typename T>
-T GeometricLaw::templatedApproximateAtAbscissa(T x) const {
+T GeometricDistribution::templatedApproximateAtAbscissa(T x) const {
   if (x < 0) {
     return NAN;
   }
@@ -43,5 +43,5 @@ T GeometricLaw::templatedApproximateAtAbscissa(T x) const {
 
 }
 
-template float Probability::GeometricLaw::templatedApproximateAtAbscissa(float x) const;
-template double Probability::GeometricLaw::templatedApproximateAtAbscissa(double x) const;
+template float Probability::GeometricDistribution::templatedApproximateAtAbscissa(float x) const;
+template double Probability::GeometricDistribution::templatedApproximateAtAbscissa(double x) const;
diff --git a/apps/probability/law/geometric_law.h b/apps/probability/distribution/geometric_distribution.h
similarity index 74%
rename from apps/probability/law/geometric_law.h
rename to apps/probability/distribution/geometric_distribution.h
index f074ba40c..035d2945e 100644
--- a/apps/probability/law/geometric_law.h
+++ b/apps/probability/distribution/geometric_distribution.h
@@ -1,20 +1,20 @@
-#ifndef PROBABILITE_GEOMETRIC_LAW_H
-#define PROBABILITE_GEOMETRIC_LAW_H
+#ifndef PROBABILITE_GEOMETRIC_DISTRIBUTION_H
+#define PROBABILITE_GEOMETRIC_DISTRIBUTION_H
 
-#include "one_parameter_law.h"
+#include "one_parameter_distribution.h"
 
 namespace Probability {
 
 /* We chose the definition:
  * 0 < p <= 1 for success probability
  * k failures where k ∈ {0, 1, 2, ... }
- * The law follows the probability distribution of the number of failures before
+ * The distribution follows the probability distribution of the number of failures before
  * the first success. */
 
-class GeometricLaw final : public OneParameterLaw {
+class GeometricDistribution final : public OneParameterDistribution {
 public:
-  GeometricLaw() : OneParameterLaw(0.5f) {}
-  I18n::Message title() override { return I18n::Message::GeometricLaw; }
+  GeometricDistribution() : OneParameterDistribution(0.5f) {}
+  I18n::Message title() override { return I18n::Message::GeometricDistribution; }
   Type type() const override { return Type::Geometric; }
   bool isContinuous() const override { return false; }
   float xMin() const override;
diff --git a/apps/probability/law/helper.cpp b/apps/probability/distribution/helper.cpp
similarity index 98%
rename from apps/probability/law/helper.cpp
rename to apps/probability/distribution/helper.cpp
index 9722ce9cf..4b777f189 100644
--- a/apps/probability/law/helper.cpp
+++ b/apps/probability/distribution/helper.cpp
@@ -1,5 +1,5 @@
 #include "helper.h"
-#include "law.h"
+#include "distribution.h"
 #include <cmath>
 #include <float.h>
 #include <assert.h>
diff --git a/apps/probability/law/helper.h b/apps/probability/distribution/helper.h
similarity index 88%
rename from apps/probability/law/helper.h
rename to apps/probability/distribution/helper.h
index c7f5b93fe..fea5afab8 100644
--- a/apps/probability/law/helper.h
+++ b/apps/probability/distribution/helper.h
@@ -1,5 +1,5 @@
-#ifndef PROBABILITY_LAW_HELPER_H
-#define PROBABILITY_LAW_HELPER_H
+#ifndef PROBABILITY_DISTRIBUTION_HELPER_H
+#define PROBABILITY_DISTRIBUTION_HELPER_H
 
 class Helper {
 public:
diff --git a/apps/probability/law/hypergeometric_function.cpp b/apps/probability/distribution/hypergeometric_function.cpp
similarity index 100%
rename from apps/probability/law/hypergeometric_function.cpp
rename to apps/probability/distribution/hypergeometric_function.cpp
diff --git a/apps/probability/law/hypergeometric_function.h b/apps/probability/distribution/hypergeometric_function.h
similarity index 87%
rename from apps/probability/law/hypergeometric_function.h
rename to apps/probability/distribution/hypergeometric_function.h
index 5579387f8..02a61809e 100644
--- a/apps/probability/law/hypergeometric_function.h
+++ b/apps/probability/distribution/hypergeometric_function.h
@@ -1,7 +1,7 @@
 #ifndef PROBABILITY_HYPERGEOMETRIC_FUNCTION_H
 #define PROBABILITY_HYPERGEOMETRIC_FUNCTION_H
 
-/* This code can be used to compute the Student law for |x| < root(k).
+/* This code can be used to compute the Student distribution for |x| < root(k).
  * We do not use it because we want to cover more x, but we keep in case we need
  * it later.  */
 
diff --git a/apps/probability/law/incomplete_beta_function.cpp b/apps/probability/distribution/incomplete_beta_function.cpp
similarity index 100%
rename from apps/probability/law/incomplete_beta_function.cpp
rename to apps/probability/distribution/incomplete_beta_function.cpp
diff --git a/apps/probability/law/incomplete_beta_function.h b/apps/probability/distribution/incomplete_beta_function.h
similarity index 100%
rename from apps/probability/law/incomplete_beta_function.h
rename to apps/probability/distribution/incomplete_beta_function.h
diff --git a/apps/probability/law/normal_law.cpp b/apps/probability/distribution/normal_distribution.cpp
similarity index 69%
rename from apps/probability/law/normal_law.cpp
rename to apps/probability/distribution/normal_distribution.cpp
index a9036394f..c3e7c8d3a 100644
--- a/apps/probability/law/normal_law.cpp
+++ b/apps/probability/distribution/normal_distribution.cpp
@@ -1,4 +1,4 @@
-#include "normal_law.h"
+#include "normal_distribution.h"
 #include "erf_inv.h"
 #include <assert.h>
 #include <cmath>
@@ -7,7 +7,7 @@
 
 namespace Probability {
 
-float NormalLaw::yMax() const {
+float NormalDistribution::yMax() const {
   float maxAbscissa = m_parameter1;
   float result = evaluateAtAbscissa(maxAbscissa);
   if (std::isnan(result) || result <= 0.0f) {
@@ -16,7 +16,7 @@ float NormalLaw::yMax() const {
   return result * (1.0f + k_displayTopMarginRatio);
 }
 
-I18n::Message NormalLaw::parameterNameAtIndex(int index) {
+I18n::Message NormalDistribution::parameterNameAtIndex(int index) {
   if (index == 0) {
     return I18n::Message::Mu;
   }
@@ -24,7 +24,7 @@ I18n::Message NormalLaw::parameterNameAtIndex(int index) {
   return I18n::Message::Sigma;
 }
 
-I18n::Message NormalLaw::parameterDefinitionAtIndex(int index) {
+I18n::Message NormalDistribution::parameterDefinitionAtIndex(int index) {
   if (index == 0) {
     return I18n::Message::MeanDefinition;
   }
@@ -32,14 +32,14 @@ I18n::Message NormalLaw::parameterDefinitionAtIndex(int index) {
   return I18n::Message::DeviationDefinition;
 }
 
-float NormalLaw::evaluateAtAbscissa(float x) const {
+float NormalDistribution::evaluateAtAbscissa(float x) const {
   if (m_parameter2 == 0.0f) {
     return NAN;
   }
   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 {
+bool NormalDistribution::authorizedValueAtIndex(float x, int index) const {
   if (index == 0) {
     return true;
   }
@@ -49,28 +49,28 @@ bool NormalLaw::authorizedValueAtIndex(float x, int index) const {
   return true;
 }
 
-void NormalLaw::setParameterAtIndex(float f, int index) {
-  TwoParameterLaw::setParameterAtIndex(f, index);
+void NormalDistribution::setParameterAtIndex(float f, int index) {
+  TwoParameterDistribution::setParameterAtIndex(f, index);
   if (index == 0 && std::fabs(m_parameter1/m_parameter2) > k_maxRatioMuSigma) {
     m_parameter2 = m_parameter1/k_maxRatioMuSigma;
   }
 }
 
-double NormalLaw::cumulativeDistributiveFunctionAtAbscissa(double x) const {
+double NormalDistribution::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   if (m_parameter2 == 0.0f) {
     return NAN;
   }
   return standardNormalCumulativeDistributiveFunctionAtAbscissa((x-m_parameter1)/std::fabs(m_parameter2));
 }
 
-double NormalLaw::cumulativeDistributiveInverseForProbability(double * probability) {
+double NormalDistribution::cumulativeDistributiveInverseForProbability(double * probability) {
   if (m_parameter2 == 0.0f) {
     return NAN;
   }
   return standardNormalCumulativeDistributiveInverseForProbability(*probability) * std::fabs(m_parameter2) + m_parameter1;
 }
 
-double NormalLaw::standardNormalCumulativeDistributiveFunctionAtAbscissa(double abscissa) const {
+double NormalDistribution::standardNormalCumulativeDistributiveFunctionAtAbscissa(double abscissa) const {
   if (abscissa == 0.0) {
     return 0.5;
   }
@@ -83,7 +83,7 @@ double NormalLaw::standardNormalCumulativeDistributiveFunctionAtAbscissa(double
   return 0.5 + 0.5 * std::erf(abscissa/std::sqrt(2.0));
 }
 
-double NormalLaw::standardNormalCumulativeDistributiveInverseForProbability(double probability) {
+double NormalDistribution::standardNormalCumulativeDistributiveInverseForProbability(double probability) {
   if (probability >= 1.0) {
     return INFINITY;
   }
@@ -96,7 +96,7 @@ double NormalLaw::standardNormalCumulativeDistributiveInverseForProbability(doub
   return std::sqrt(2.0) * erfInv(2.0 * probability - 1.0);
 }
 
-float NormalLaw::xExtremum(bool min) const {
+float NormalDistribution::xExtremum(bool min) const {
   int coefficient = (min ? -1 : 1);
   if (m_parameter2 == 0.0f) {
     return m_parameter1 + coefficient * 1.0f;
diff --git a/apps/probability/law/normal_law.h b/apps/probability/distribution/normal_distribution.h
similarity index 76%
rename from apps/probability/law/normal_law.h
rename to apps/probability/distribution/normal_distribution.h
index d5ea508a2..3751493d1 100644
--- a/apps/probability/law/normal_law.h
+++ b/apps/probability/distribution/normal_distribution.h
@@ -1,14 +1,14 @@
-#ifndef PROBABILITE_NORMAL_LAW_H
-#define PROBABILITE_NORMAL_LAW_H
+#ifndef PROBABILITE_NORMAL_DISTRIBUTION_H
+#define PROBABILITE_NORMAL_DISTRIBUTION_H
 
-#include "two_parameter_law.h"
+#include "two_parameter_distribution.h"
 
 namespace Probability {
 
-class NormalLaw final : public TwoParameterLaw {
+class NormalDistribution final : public TwoParameterDistribution {
 public:
-  NormalLaw() : TwoParameterLaw(0.0f, 1.0f) {}
-  I18n::Message title() override { return I18n::Message::NormalLaw; }
+  NormalDistribution() : TwoParameterDistribution(0.0f, 1.0f) {}
+  I18n::Message title() override { return I18n::Message::NormalDistribution; }
   Type type() const override { return Type::Normal; }
   bool isContinuous() const override { return true; }
   float xMin() const override { return xExtremum(true); }
@@ -23,7 +23,7 @@ public:
   double cumulativeDistributiveInverseForProbability(double * probability) override;
 private:
   constexpr static double k_maxRatioMuSigma = 1000000.0f;
-  /* For the standard normal law, P(X < y) > 0.9999995 with y >= 4.892 so the
+  /* For the standard normal distribution, P(X < y) > 0.9999995 with y >= 4.892 so the
    * value displayed is 1. But this is dependent on the fact that we display
    * only 7 decimal values! */
   static_assert(Constant::LargeNumberOfSignificantDigits == 7, "k_maxProbability is ill-defined compared to LargeNumberOfSignificantDigits");
diff --git a/apps/probability/law/one_parameter_law.h b/apps/probability/distribution/one_parameter_distribution.h
similarity index 58%
rename from apps/probability/law/one_parameter_law.h
rename to apps/probability/distribution/one_parameter_distribution.h
index ea45abc58..df991c719 100644
--- a/apps/probability/law/one_parameter_law.h
+++ b/apps/probability/distribution/one_parameter_distribution.h
@@ -1,14 +1,14 @@
-#ifndef PROBABILITE_ONE_PARAMETER_LAW_H
-#define PROBABILITE_ONE_PARAMETER_LAW_H
+#ifndef PROBABILITE_ONE_PARAMETER_DISTRIBUTION_H
+#define PROBABILITE_ONE_PARAMETER_DISTRIBUTION_H
 
-#include "law.h"
+#include "distribution.h"
 #include <assert.h>
 
 namespace Probability {
 
-class OneParameterLaw : public Law {
+class OneParameterDistribution : public Distribution {
 public:
-  OneParameterLaw(float parameterValue) : m_parameter1(parameterValue) {}
+  OneParameterDistribution(float parameterValue) : m_parameter1(parameterValue) {}
   int numberOfParameter() override { return 1; }
   float parameterValueAtIndex(int index) override {
     assert(index == 0);
diff --git a/apps/probability/law/poisson_law.cpp b/apps/probability/distribution/poisson_distribution.cpp
similarity index 60%
rename from apps/probability/law/poisson_law.cpp
rename to apps/probability/distribution/poisson_distribution.cpp
index 75a792752..875631229 100644
--- a/apps/probability/law/poisson_law.cpp
+++ b/apps/probability/distribution/poisson_distribution.cpp
@@ -1,20 +1,20 @@
-#include "poisson_law.h"
+#include "poisson_distribution.h"
 #include <assert.h>
 #include <cmath>
 #include <ion.h>
 
 namespace Probability {
 
-float PoissonLaw::xMin() const {
+float PoissonDistribution::xMin() const {
   return -k_displayLeftMarginRatio * xMax();
 }
 
-float PoissonLaw::xMax() const {
+float PoissonDistribution::xMax() const {
   assert(m_parameter1 != 0);
   return (m_parameter1 + 5.0f * std::sqrt(m_parameter1)) * (1.0f + k_displayRightMarginRatio);
 }
 
-float PoissonLaw::yMax() const {
+float PoissonDistribution::yMax() const {
   int maxAbscissa = (int)m_parameter1;
   assert(maxAbscissa >= 0.0f);
   float result = evaluateAtAbscissa(maxAbscissa);
@@ -24,7 +24,7 @@ float PoissonLaw::yMax() const {
   return result * (1.0f + k_displayTopMarginRatio);
 }
 
-bool PoissonLaw::authorizedValueAtIndex(float x, int index) const {
+bool PoissonDistribution::authorizedValueAtIndex(float x, int index) const {
   if (x <= 0.0f || x > 999.0f) {
     return false;
   }
@@ -32,7 +32,7 @@ bool PoissonLaw::authorizedValueAtIndex(float x, int index) const {
 }
 
 template<typename T>
-T PoissonLaw::templatedApproximateAtAbscissa(T x) const {
+T PoissonDistribution::templatedApproximateAtAbscissa(T x) const {
   if (x < 0) {
     return NAN;
   }
@@ -42,5 +42,5 @@ T PoissonLaw::templatedApproximateAtAbscissa(T x) const {
 
 }
 
-template float Probability::PoissonLaw::templatedApproximateAtAbscissa(float x) const;
-template double Probability::PoissonLaw::templatedApproximateAtAbscissa(double x) const;
+template float Probability::PoissonDistribution::templatedApproximateAtAbscissa(float x) const;
+template double Probability::PoissonDistribution::templatedApproximateAtAbscissa(double x) const;
diff --git a/apps/probability/law/poisson_law.h b/apps/probability/distribution/poisson_distribution.h
similarity index 77%
rename from apps/probability/law/poisson_law.h
rename to apps/probability/distribution/poisson_distribution.h
index 2ffa08eb4..7c6654fa8 100644
--- a/apps/probability/law/poisson_law.h
+++ b/apps/probability/distribution/poisson_distribution.h
@@ -1,14 +1,14 @@
-#ifndef PROBABILITE_POISSON_LAW_H
-#define PROBABILITE_POISSON_LAW_H
+#ifndef PROBABILITE_POISSON_DISTRIBUTION_H
+#define PROBABILITE_POISSON_DISTRIBUTION_H
 
-#include "one_parameter_law.h"
+#include "one_parameter_distribution.h"
 
 namespace Probability {
 
-class PoissonLaw final : public OneParameterLaw {
+class PoissonDistribution final : public OneParameterDistribution {
 public:
-  PoissonLaw() : OneParameterLaw(4.0f) {}
-  I18n::Message title() override { return I18n::Message::PoissonLaw; }
+  PoissonDistribution() : OneParameterDistribution(4.0f) {}
+  I18n::Message title() override { return I18n::Message::PoissonDistribution; }
   Type type() const override { return Type::Poisson; }
   bool isContinuous() const override { return false; }
   float xMin() const override;
diff --git a/apps/probability/law/regularized_gamma.cpp b/apps/probability/distribution/regularized_gamma.cpp
similarity index 99%
rename from apps/probability/law/regularized_gamma.cpp
rename to apps/probability/distribution/regularized_gamma.cpp
index 4ea23ef13..9c597cbb2 100644
--- a/apps/probability/law/regularized_gamma.cpp
+++ b/apps/probability/distribution/regularized_gamma.cpp
@@ -1,5 +1,5 @@
 #include "regularized_gamma.h"
-#include "law.h"
+#include "distribution.h"
 #include "helper.h"
 #include <cmath>
 #include <float.h>
diff --git a/apps/probability/law/regularized_gamma.h b/apps/probability/distribution/regularized_gamma.h
similarity index 100%
rename from apps/probability/law/regularized_gamma.h
rename to apps/probability/distribution/regularized_gamma.h
diff --git a/apps/probability/law/student_law.cpp b/apps/probability/distribution/student_distribution.cpp
similarity index 71%
rename from apps/probability/law/student_law.cpp
rename to apps/probability/distribution/student_distribution.cpp
index 4ea0e2b2f..73a85e5ff 100644
--- a/apps/probability/law/student_law.cpp
+++ b/apps/probability/distribution/student_distribution.cpp
@@ -1,32 +1,32 @@
-#include "student_law.h"
+#include "student_distribution.h"
 #include "incomplete_beta_function.h"
 #include "helper.h"
 #include <cmath>
 
 namespace Probability {
 
-float StudentLaw::xMin() const {
+float StudentDistribution::xMin() const {
   return -xMax();
 }
 
-float StudentLaw::xMax() const {
+float StudentDistribution::xMax() const {
   return 5.0f;
 }
 
-float StudentLaw::yMax() const {
+float StudentDistribution::yMax() const {
   return coefficient() * (1.0f + k_displayTopMarginRatio);
 }
 
-float StudentLaw::evaluateAtAbscissa(float x) const {
+float StudentDistribution::evaluateAtAbscissa(float x) const {
   const float d = m_parameter1;
   return coefficient() * std::pow(1+std::pow(x,2)/d, -(d+1)/2);
 }
 
-bool StudentLaw::authorizedValueAtIndex(float x, int index) const {
+bool StudentDistribution::authorizedValueAtIndex(float x, int index) const {
   return x >= FLT_EPSILON;
 }
 
-double StudentLaw::cumulativeDistributiveFunctionAtAbscissa(double x) const {
+double StudentDistribution::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   if (x == 0) {
     return 0.5;
   }
@@ -39,7 +39,7 @@ double StudentLaw::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   return IncompleteBetaFunction(k/2.0, k/2.0, t);
 }
 
-double StudentLaw::cumulativeDistributiveInverseForProbability(double * probability) {
+double StudentDistribution::cumulativeDistributiveInverseForProbability(double * probability) {
   if (*probability == 0.5) {
     return 0.0;
   }
@@ -51,7 +51,7 @@ double StudentLaw::cumulativeDistributiveInverseForProbability(double * probabil
   return cumulativeDistributiveInverseForProbabilityUsingIncreasingFunctionRoot(probability, xmin, xmax);
 }
 
-float StudentLaw::coefficient() const {
+float StudentDistribution::coefficient() const {
   const float k = m_parameter1;
   const float lnOfResult = std::lgamma((k+1)/2) - std::lgamma(k/2) - (M_PI+k)/2;
   return std::exp(lnOfResult);
diff --git a/apps/probability/law/student_law.h b/apps/probability/distribution/student_distribution.h
similarity index 80%
rename from apps/probability/law/student_law.h
rename to apps/probability/distribution/student_distribution.h
index c53fafe87..b00ac7873 100644
--- a/apps/probability/law/student_law.h
+++ b/apps/probability/distribution/student_distribution.h
@@ -1,18 +1,18 @@
-#ifndef PROBABILITY_STUDENT_LAW_H
-#define PROBABILITY_STUDENT_LAW_H
+#ifndef PROBABILITY_STUDENT_DISTRIBUTION_H
+#define PROBABILITY_STUDENT_DISTRIBUTION_H
 
-#include "one_parameter_law.h"
+#include "one_parameter_distribution.h"
 #include <float.h>
 
 namespace Probability {
 
-class StudentLaw : public OneParameterLaw {
+class StudentDistribution : public OneParameterDistribution {
 public:
   static constexpr int k_maxHypergeometricFunctionIterations = 1000; // TODO LEA factorize with Chi Squared
   static constexpr double k_hypergeometricFunctionPrecision = DBL_EPSILON;
 
-  StudentLaw() : OneParameterLaw(1.0f) {}
-  I18n::Message title() override { return I18n::Message::StudentLaw; }
+  StudentDistribution() : OneParameterDistribution(1.0f) {}
+  I18n::Message title() override { return I18n::Message::StudentDistribution; }
   Type type() const override { return Type::Student; }
   bool isContinuous() const override { return true; }
   float xMin() const override;
diff --git a/apps/probability/law/two_parameter_law.cpp b/apps/probability/distribution/two_parameter_distribution.cpp
similarity index 60%
rename from apps/probability/law/two_parameter_law.cpp
rename to apps/probability/distribution/two_parameter_distribution.cpp
index 8e6c7ac18..5c3197c1b 100644
--- a/apps/probability/law/two_parameter_law.cpp
+++ b/apps/probability/distribution/two_parameter_distribution.cpp
@@ -1,9 +1,9 @@
-#include "two_parameter_law.h"
+#include "two_parameter_distribution.h"
 #include <assert.h>
 
 namespace Probability {
 
-float TwoParameterLaw::parameterValueAtIndex(int index) {
+float TwoParameterDistribution::parameterValueAtIndex(int index) {
   assert(index >= 0 && index < 2);
   if (index == 0) {
     return m_parameter1;
@@ -11,7 +11,7 @@ float TwoParameterLaw::parameterValueAtIndex(int index) {
   return m_parameter2;
 }
 
-void TwoParameterLaw::setParameterAtIndex(float f, int index) {
+void TwoParameterDistribution::setParameterAtIndex(float f, int index) {
   assert(index >= 0 && index < 2);
   if (index == 0) {
     m_parameter1 = f;
diff --git a/apps/probability/law/two_parameter_law.h b/apps/probability/distribution/two_parameter_distribution.h
similarity index 56%
rename from apps/probability/law/two_parameter_law.h
rename to apps/probability/distribution/two_parameter_distribution.h
index 1e1d1fcb3..0f8d68f44 100644
--- a/apps/probability/law/two_parameter_law.h
+++ b/apps/probability/distribution/two_parameter_distribution.h
@@ -1,13 +1,13 @@
-#ifndef PROBABILITE_TWO_PARAMETER_LAW_H
-#define PROBABILITE_TWO_PARAMETER_LAW_H
+#ifndef PROBABILITE_TWO_PARAMETER_DISTRIBUTION_H
+#define PROBABILITE_TWO_PARAMETER_DISTRIBUTION_H
 
-#include "law.h"
+#include "distribution.h"
 
 namespace Probability {
 
-class TwoParameterLaw : public Law {
+class TwoParameterDistribution : public Distribution {
 public:
-  TwoParameterLaw(float parameterValue1, float parameterValue2) :
+  TwoParameterDistribution(float parameterValue1, float parameterValue2) :
     m_parameter1(parameterValue1),
     m_parameter2(parameterValue2)
   {}
diff --git a/apps/probability/law/uniform_law.cpp b/apps/probability/distribution/uniform_distribution.cpp
similarity index 70%
rename from apps/probability/law/uniform_law.cpp
rename to apps/probability/distribution/uniform_distribution.cpp
index 742af5c22..0a79ae160 100644
--- a/apps/probability/law/uniform_law.cpp
+++ b/apps/probability/distribution/uniform_distribution.cpp
@@ -1,4 +1,4 @@
-#include "uniform_law.h"
+#include "uniform_distribution.h"
 #include <cmath>
 #include <float.h>
 #include <assert.h>
@@ -6,7 +6,7 @@
 namespace Probability {
 
 
-I18n::Message UniformLaw::parameterNameAtIndex(int index) {
+I18n::Message UniformDistribution::parameterNameAtIndex(int index) {
   assert(index >= 0 && index < 2);
   if (index == 0) {
     return I18n::Message::A;
@@ -15,7 +15,7 @@ I18n::Message UniformLaw::parameterNameAtIndex(int index) {
   }
 }
 
-I18n::Message UniformLaw::parameterDefinitionAtIndex(int index) {
+I18n::Message UniformDistribution::parameterDefinitionAtIndex(int index) {
   assert(index >= 0 && index < 2);
   if (index == 0) {
     return I18n::Message::IntervalDefinition;
@@ -24,7 +24,7 @@ I18n::Message UniformLaw::parameterDefinitionAtIndex(int index) {
   }
 }
 
-float UniformLaw::xMin() const {
+float UniformDistribution::xMin() const {
   assert(m_parameter2 >= m_parameter1);
   if (m_parameter2 - m_parameter1 < FLT_EPSILON) {
     return m_parameter1 - 1.0f;
@@ -32,14 +32,14 @@ float UniformLaw::xMin() const {
   return m_parameter1 - 0.6f * (m_parameter2 - m_parameter1);
 }
 
-float UniformLaw::xMax() const {
+float UniformDistribution::xMax() const {
   if (m_parameter2 - m_parameter1 < FLT_EPSILON) {
     return m_parameter1 + 1.0f;
   }
   return m_parameter2 + 0.6f * (m_parameter2 - m_parameter1);
 }
 
-float UniformLaw::yMax() const {
+float UniformDistribution::yMax() const {
   float result = m_parameter2 - m_parameter1 < FLT_EPSILON ? k_diracMaximum : 1.0f/(m_parameter2-m_parameter1);
   if (result <= 0.0f || std::isnan(result) || std::isinf(result)) {
     result = 1.0f;
@@ -47,7 +47,7 @@ float UniformLaw::yMax() const {
   return result * (1.0f+ k_displayTopMarginRatio);
 }
 
-float UniformLaw::evaluateAtAbscissa(float t) const {
+float UniformDistribution::evaluateAtAbscissa(float t) const {
   if (m_parameter2 - m_parameter1 < FLT_EPSILON) {
     if (m_parameter1 - k_diracWidth<= t && t <= m_parameter2 + k_diracWidth) {
       return 2.0f * k_diracMaximum;
@@ -60,7 +60,7 @@ float UniformLaw::evaluateAtAbscissa(float t) const {
   return 0.0f;
 }
 
-bool UniformLaw::authorizedValueAtIndex(float x, int index) const {
+bool UniformDistribution::authorizedValueAtIndex(float x, int index) const {
   if (index == 0) {
     return true;
   }
@@ -70,14 +70,14 @@ bool UniformLaw::authorizedValueAtIndex(float x, int index) const {
   return true;
 }
 
-void UniformLaw::setParameterAtIndex(float f, int index) {
-  TwoParameterLaw::setParameterAtIndex(f, index);
+void UniformDistribution::setParameterAtIndex(float f, int index) {
+  TwoParameterDistribution::setParameterAtIndex(f, index);
   if (index == 0 && m_parameter2 < m_parameter1) {
     m_parameter2 = m_parameter1 + 1.0f;
   }
 }
 
-double UniformLaw::cumulativeDistributiveFunctionAtAbscissa(double x) const {
+double UniformDistribution::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   if (x <= m_parameter1) {
     return 0.0;
   }
@@ -87,7 +87,7 @@ double UniformLaw::cumulativeDistributiveFunctionAtAbscissa(double x) const {
   return 1.0;
 }
 
-double UniformLaw::cumulativeDistributiveInverseForProbability(double * probability) {
+double UniformDistribution::cumulativeDistributiveInverseForProbability(double * probability) {
   if (*probability >= 1.0f) {
     return m_parameter2;
   }
diff --git a/apps/probability/law/uniform_law.h b/apps/probability/distribution/uniform_distribution.h
similarity index 76%
rename from apps/probability/law/uniform_law.h
rename to apps/probability/distribution/uniform_distribution.h
index 83b696ea7..7adab7a0d 100644
--- a/apps/probability/law/uniform_law.h
+++ b/apps/probability/distribution/uniform_distribution.h
@@ -1,14 +1,14 @@
-#ifndef PROBABILITE_UNIFORM_LAW_H
-#define PROBABILITE_UNIFORM_LAW_H
+#ifndef PROBABILITE_UNIFORM_DISTRIBUTION_H
+#define PROBABILITE_UNIFORM_DISTRIBUTION_H
 
-#include "two_parameter_law.h"
+#include "two_parameter_distribution.h"
 
 namespace Probability {
 
-class UniformLaw final : public TwoParameterLaw {
+class UniformDistribution final : public TwoParameterDistribution {
 public:
-  UniformLaw() : TwoParameterLaw(-1.0f, 1.0f) {}
-  I18n::Message title() override { return I18n::Message::UniformLaw; }
+  UniformDistribution() : TwoParameterDistribution(-1.0f, 1.0f) {}
+  I18n::Message title() override { return I18n::Message::UniformDistribution; }
   Type type() const override { return Type::Uniform; }
   bool isContinuous() const override { return true; }
   float xMin() const override;
diff --git a/apps/probability/law_controller.cpp b/apps/probability/distribution_controller.cpp
similarity index 59%
rename from apps/probability/law_controller.cpp
rename to apps/probability/distribution_controller.cpp
index 88a5a7c19..ba801c976 100644
--- a/apps/probability/law_controller.cpp
+++ b/apps/probability/distribution_controller.cpp
@@ -1,15 +1,15 @@
-#include "law_controller.h"
+#include "distribution_controller.h"
 #include <assert.h>
 #include <new>
 #include "app.h"
-#include "law/binomial_law.h"
-#include "law/chi_squared_law.h"
-#include "law/exponential_law.h"
-#include "law/geometric_law.h"
-#include "law/normal_law.h"
-#include "law/poisson_law.h"
-#include "law/student_law.h"
-#include "law/uniform_law.h"
+#include "distribution/binomial_distribution.h"
+#include "distribution/chi_squared_distribution.h"
+#include "distribution/exponential_distribution.h"
+#include "distribution/geometric_distribution.h"
+#include "distribution/normal_distribution.h"
+#include "distribution/poisson_distribution.h"
+#include "distribution/student_distribution.h"
+#include "distribution/uniform_distribution.h"
 #include "images/binomial_icon.h"
 #include "images/chi_squared_icon.h"
 #include "images/exponential_icon.h"
@@ -29,17 +29,17 @@
 
 namespace Probability {
 
-LawController::ContentView::ContentView(SelectableTableView * selectableTableView) :
-  m_titleView(KDFont::SmallFont, I18n::Message::ChooseLaw, 0.5f, 0.5f, Palette::GreyDark, Palette::WallScreen),
+DistributionController::ContentView::ContentView(SelectableTableView * selectableTableView) :
+  m_titleView(KDFont::SmallFont, I18n::Message::ChooseDistribution, 0.5f, 0.5f, Palette::GreyDark, Palette::WallScreen),
   m_selectableTableView(selectableTableView)
 {
 }
 
-int LawController::ContentView::numberOfSubviews() const {
+int DistributionController::ContentView::numberOfSubviews() const {
   return 2;
 }
 
-View * LawController::ContentView::subviewAtIndex(int index) {
+View * DistributionController::ContentView::subviewAtIndex(int index) {
   assert(index >= 0 && index < 2);
   if (index == 0) {
     return &m_titleView;
@@ -47,7 +47,7 @@ View * LawController::ContentView::subviewAtIndex(int index) {
   return m_selectableTableView;
 }
 
-void LawController::ContentView::layoutSubviews() {
+void DistributionController::ContentView::layoutSubviews() {
   KDCoordinate titleHeight = KDFont::SmallFont->glyphSize().height()+k_titleMargin;
   m_titleView.setFrame(KDRect(0, 0, bounds().width(), titleHeight));
   m_selectableTableView->setFrame(KDRect(0, titleHeight, bounds().width(),  bounds().height()-titleHeight));
@@ -64,28 +64,28 @@ static I18n::Message sMessages[] = {
   I18n::Message::Poisson
 };
 
-LawController::LawController(Responder * parentResponder, Law * law, ParametersController * parametersController) :
+DistributionController::DistributionController(Responder * parentResponder, Distribution * distribution, ParametersController * parametersController) :
   ViewController(parentResponder),
   m_selectableTableView(this),
   m_contentView(&m_selectableTableView),
-  m_law(law),
+  m_distribution(distribution),
   m_parametersController(parametersController)
 {
-  assert(m_law != nullptr);
+  assert(m_distribution != nullptr);
   m_messages = sMessages;
   m_selectableTableView.setTopMargin(Metric::CommonTopMargin-ContentView::k_titleMargin);
 }
 
-View * LawController::view() {
+View * DistributionController::view() {
   return &m_contentView;
 }
 
-void Probability::LawController::viewWillAppear() {
-  selectRow((int)m_law->type());
+void Probability::DistributionController::viewWillAppear() {
+  selectRow((int)m_distribution->type());
 }
 
-void Probability::LawController::didBecomeFirstResponder() {
-  App::app()->snapshot()->setActivePage(App::Snapshot::Page::Law);
+void Probability::DistributionController::didBecomeFirstResponder() {
+  App::app()->snapshot()->setActivePage(App::Snapshot::Page::Distribution);
   if (selectedRow() == -1) {
     selectCellAtLocation(0, 0);
   } else {
@@ -94,31 +94,31 @@ void Probability::LawController::didBecomeFirstResponder() {
   Container::activeApp()->setFirstResponder(&m_selectableTableView);
 }
 
-bool Probability::LawController::handleEvent(Ion::Events::Event event) {
+bool Probability::DistributionController::handleEvent(Ion::Events::Event event) {
   if (event == Ion::Events::OK || event == Ion::Events::EXE || event == Ion::Events::Right) {
     StackViewController * stack = (StackViewController *)parentResponder();
-    setLawAccordingToIndex(selectedRow());
+    setDistributionAccordingToIndex(selectedRow());
     stack->push(m_parametersController, KDColorWhite, Palette::PurpleBright, Palette::PurpleBright);
     return true;
   }
   return false;
 }
 
-int Probability::LawController::numberOfRows() {
+int Probability::DistributionController::numberOfRows() {
   return k_totalNumberOfModels;
 };
 
-HighlightCell * Probability::LawController::reusableCell(int index) {
+HighlightCell * Probability::DistributionController::reusableCell(int index) {
   assert(index >= 0);
   assert(index < k_totalNumberOfModels);
   return &m_cells[index];
 }
 
-int Probability::LawController::reusableCellCount() {
+int Probability::DistributionController::reusableCellCount() {
   return k_totalNumberOfModels;
 }
 
-void Probability::LawController::willDisplayCellForIndex(HighlightCell * cell, int index) {
+void Probability::DistributionController::willDisplayCellForIndex(HighlightCell * cell, int index) {
   Cell * myCell = (Cell *)cell;
   myCell->setLabel(m_messages[index]);
   const Image * images[k_totalNumberOfModels] = {
@@ -145,39 +145,39 @@ void Probability::LawController::willDisplayCellForIndex(HighlightCell * cell, i
   myCell->reloadCell();
 }
 
-KDCoordinate Probability::LawController::cellHeight() {
+KDCoordinate Probability::DistributionController::cellHeight() {
   return Metric::ParameterCellHeight;
 }
 
-void Probability::LawController::setLawAccordingToIndex(int index) {
-  if ((int)m_law->type() == index) {
+void Probability::DistributionController::setDistributionAccordingToIndex(int index) {
+  if ((int)m_distribution->type() == index) {
     return;
   }
-  m_law->~Law();
+  m_distribution->~Distribution();
   switch (index) {
     case 0:
-      new(m_law) BinomialLaw();
+      new(m_distribution) BinomialDistribution();
       break;
     case 1:
-      new(m_law) UniformLaw();
+      new(m_distribution) UniformDistribution();
       break;
     case 2:
-      new(m_law) ExponentialLaw();
+      new(m_distribution) ExponentialDistribution();
       break;
     case 3:
-      new(m_law) NormalLaw();
+      new(m_distribution) NormalDistribution();
       break;
     case 4:
-      new(m_law) ChiSquaredLaw();
+      new(m_distribution) ChiSquaredDistribution();
       break;
     case 5:
-      new(m_law) StudentLaw();
+      new(m_distribution) StudentDistribution();
       break;
     case 6:
-      new(m_law) GeometricLaw();
+      new(m_distribution) GeometricDistribution();
       break;
     case 7:
-      new(m_law) PoissonLaw();
+      new(m_distribution) PoissonDistribution();
       break;
 
     default:
diff --git a/apps/probability/law_controller.h b/apps/probability/distribution_controller.h
similarity index 71%
rename from apps/probability/law_controller.h
rename to apps/probability/distribution_controller.h
index 81c58c2b4..a75e3f5bb 100644
--- a/apps/probability/law_controller.h
+++ b/apps/probability/distribution_controller.h
@@ -1,17 +1,17 @@
-#ifndef PROBABILITY_LAW_CONTROLLER_H
-#define PROBABILITY_LAW_CONTROLLER_H
+#ifndef PROBABILITY_DISTRIBUTION_CONTROLLER_H
+#define PROBABILITY_DISTRIBUTION_CONTROLLER_H
 
 #include <escher.h>
 #include "cell.h"
-#include "law/law.h"
+#include "distribution/distribution.h"
 #include "parameters_controller.h"
 #include <new>
 
 namespace Probability {
 
-class LawController : public ViewController, public SimpleListViewDataSource, public SelectableTableViewDataSource {
+class DistributionController : public ViewController, public SimpleListViewDataSource, public SelectableTableViewDataSource {
 public:
-  LawController(Responder * parentResponder, Law * m_law, ParametersController * parametersController);
+  DistributionController(Responder * parentResponder, Distribution * m_distribution, ParametersController * parametersController);
   View * view() override;
   bool handleEvent(Ion::Events::Event event) override;
   void didBecomeFirstResponder() override;
@@ -33,13 +33,13 @@ private:
     MessageTextView m_titleView;;
     SelectableTableView * m_selectableTableView;
   };
-  void setLawAccordingToIndex(int index);
+  void setDistributionAccordingToIndex(int index);
   constexpr static int k_totalNumberOfModels = 8;
   Cell m_cells[k_totalNumberOfModels];
   SelectableTableView m_selectableTableView;
   ContentView m_contentView;
   I18n::Message * m_messages;
-  Law * m_law;
+  Distribution * m_distribution;
   ParametersController * m_parametersController;
 
 };
diff --git a/apps/probability/distribution_curve_view.cpp b/apps/probability/distribution_curve_view.cpp
new file mode 100644
index 000000000..521432e6b
--- /dev/null
+++ b/apps/probability/distribution_curve_view.cpp
@@ -0,0 +1,60 @@
+#include "distribution_curve_view.h"
+#include "distribution/normal_distribution.h"
+#include <assert.h>
+
+using namespace Shared;
+
+namespace Probability {
+
+constexpr KDColor DistributionCurveView::k_backgroundColor;
+
+void DistributionCurveView::reload() {
+  CurveView::reload();
+  markRectAsDirty(bounds());
+}
+
+void DistributionCurveView::drawRect(KDContext * ctx, KDRect rect) const {
+  float lowerBound = m_calculation->lowerBound();
+  float upperBound = m_calculation->upperBound();
+  ctx->fillRect(bounds(), k_backgroundColor);
+  drawAxis(ctx, rect, Axis::Horizontal);
+  drawLabels(ctx, rect, Axis::Horizontal, false, false, false, 0, k_backgroundColor);
+  if (m_distribution->type() == Distribution::Type::Normal) {
+    // Special case for the normal distribution, which has always the same curve
+    drawStandardNormal(ctx, rect, lowerBound, upperBound);
+    return;
+  }
+  if (m_distribution->isContinuous()) {
+    drawCurve(ctx, rect, EvaluateAtAbscissa, m_distribution, nullptr, Palette::YellowDark, true, lowerBound, upperBound);
+  } else {
+    drawHistogram(ctx, rect, EvaluateAtAbscissa, m_distribution, nullptr, 0, 1, false, Palette::GreyMiddle, Palette::YellowDark, lowerBound, upperBound+0.5f);
+  }
+}
+
+char * DistributionCurveView::label(Axis axis, int index) const {
+  if (axis == Axis::Vertical) {
+    return nullptr;
+  }
+  return (char *)m_labels[index];
+}
+
+float DistributionCurveView::EvaluateAtAbscissa(float abscissa, void * model, void * context) {
+  Distribution * distribution = (Distribution *)model;
+  return distribution->evaluateAtAbscissa(abscissa);
+}
+
+void DistributionCurveView::drawStandardNormal(KDContext * ctx, KDRect rect, float colorLowerBound, float colorUpperBound) const {
+  // Save the previous curve view range
+  DistributionCurveView * constCastedThis = const_cast<DistributionCurveView *>(this);
+  CurveViewRange * previousRange = curveViewRange();
+
+  // Draw a centered reduced normal curve
+  NormalDistribution n;
+  constCastedThis->setCurveViewRange(&n);
+  drawCurve(ctx, rect, EvaluateAtAbscissa, &n, nullptr, Palette::YellowDark, true, colorLowerBound, colorUpperBound);
+
+  // Put back the previous curve view range
+  constCastedThis->setCurveViewRange(previousRange);
+}
+
+}
diff --git a/apps/probability/law_curve_view.h b/apps/probability/distribution_curve_view.h
similarity index 65%
rename from apps/probability/law_curve_view.h
rename to apps/probability/distribution_curve_view.h
index 2f142aa75..313bcf847 100644
--- a/apps/probability/law_curve_view.h
+++ b/apps/probability/distribution_curve_view.h
@@ -1,24 +1,24 @@
-#ifndef PROBABILITY_LAW_CURVE_VIEW_H
-#define PROBABILITY_LAW_CURVE_VIEW_H
+#ifndef PROBABILITY_DISTRIBUTION_CURVE_VIEW_H
+#define PROBABILITY_DISTRIBUTION_CURVE_VIEW_H
 
 #include "../shared/curve_view.h"
 #include "../constant.h"
-#include "law/law.h"
+#include "distribution/distribution.h"
 #include "calculation/calculation.h"
 #include <escher.h>
 #include <poincare/print_float.h>
 
 namespace Probability {
 
-class LawCurveView : public Shared::CurveView {
+class DistributionCurveView : public Shared::CurveView {
 public:
-  LawCurveView(Law * law, Calculation * calculation) :
-    CurveView(law, nullptr, nullptr, nullptr),
+  DistributionCurveView(Distribution * distribution, Calculation * calculation) :
+    CurveView(distribution, nullptr, nullptr, nullptr),
     m_labels{},
-    m_law(law),
+    m_distribution(distribution),
     m_calculation(calculation)
   {
-    assert(law != nullptr);
+    assert(distribution != nullptr);
     assert(calculation != nullptr);
   }
 
@@ -31,7 +31,7 @@ private:
   static constexpr KDColor k_backgroundColor = Palette::WallScreen;
   void drawStandardNormal(KDContext * ctx, KDRect rect, float colorLowerBound, float colorUpperBound) const;
   char m_labels[k_maxNumberOfXLabels][k_labelBufferMaxSize];
-  Law * m_law;
+  Distribution * m_distribution;
   Calculation * m_calculation;
 };
 
diff --git a/apps/probability/law_curve_view.cpp b/apps/probability/law_curve_view.cpp
deleted file mode 100644
index d336aa9c4..000000000
--- a/apps/probability/law_curve_view.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "law_curve_view.h"
-#include "law/normal_law.h"
-#include <assert.h>
-
-using namespace Shared;
-
-namespace Probability {
-
-constexpr KDColor LawCurveView::k_backgroundColor;
-
-void LawCurveView::reload() {
-  CurveView::reload();
-  markRectAsDirty(bounds());
-}
-
-void LawCurveView::drawRect(KDContext * ctx, KDRect rect) const {
-  float lowerBound = m_calculation->lowerBound();
-  float upperBound = m_calculation->upperBound();
-  ctx->fillRect(bounds(), k_backgroundColor);
-  drawAxis(ctx, rect, Axis::Horizontal);
-  drawLabels(ctx, rect, Axis::Horizontal, false, false, false, 0, k_backgroundColor);
-  if (m_law->type() == Law::Type::Normal) {
-    // Special case for the normal law, which has always the same curve
-    drawStandardNormal(ctx, rect, lowerBound, upperBound);
-    return;
-  }
-  if (m_law->isContinuous()) {
-    drawCurve(ctx, rect, EvaluateAtAbscissa, m_law, nullptr, Palette::YellowDark, true, lowerBound, upperBound);
-  } else {
-    drawHistogram(ctx, rect, EvaluateAtAbscissa, m_law, nullptr, 0, 1, false, Palette::GreyMiddle, Palette::YellowDark, lowerBound, upperBound+0.5f);
-  }
-}
-
-char * LawCurveView::label(Axis axis, int index) const {
-  if (axis == Axis::Vertical) {
-    return nullptr;
-  }
-  return (char *)m_labels[index];
-}
-
-float LawCurveView::EvaluateAtAbscissa(float abscissa, void * model, void * context) {
-  Law * law = (Law *)model;
-  return law->evaluateAtAbscissa(abscissa);
-}
-
-void LawCurveView::drawStandardNormal(KDContext * ctx, KDRect rect, float colorLowerBound, float colorUpperBound) const {
-  // Save the previous curve view range
-  LawCurveView * constCastedThis = const_cast<LawCurveView *>(this);
-  CurveViewRange * previousRange = curveViewRange();
-
-  // Draw a centered reduced normal curve
-  NormalLaw n;
-  constCastedThis->setCurveViewRange(&n);
-  drawCurve(ctx, rect, EvaluateAtAbscissa, &n, nullptr, Palette::YellowDark, true, colorLowerBound, colorUpperBound);
-
-  // Put back the previous curve view range
-  constCastedThis->setCurveViewRange(previousRange);
-}
-
-}
diff --git a/apps/probability/parameters_controller.cpp b/apps/probability/parameters_controller.cpp
index ef409e551..49e60a13a 100644
--- a/apps/probability/parameters_controller.cpp
+++ b/apps/probability/parameters_controller.cpp
@@ -67,14 +67,14 @@ void ParametersController::ContentView::layoutSubviews() {
 
 /* Parameters Controller */
 
-ParametersController::ParametersController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Law * law, CalculationController * calculationController) :
+ParametersController::ParametersController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Distribution * distribution, CalculationController * calculationController) :
   FloatParameterController(parentResponder),
   m_contentView(this, &m_selectableTableView),
   m_menuListCell{},
-  m_law(law),
+  m_distribution(distribution),
   m_calculationController(calculationController)
 {
-  assert(m_law != nullptr);
+  assert(m_distribution != nullptr);
   m_okButton.setMessage(I18n::Message::Next);
   for (int i = 0; i < k_maxNumberOfCells; i++) {
     m_menuListCell[i].setParentResponder(&m_selectableTableView);
@@ -83,7 +83,7 @@ ParametersController::ParametersController(Responder * parentResponder, InputEve
 }
 
 const char * ParametersController::title() {
-  return I18n::translate(m_law->title());
+  return I18n::translate(m_distribution->title());
 }
 
 bool ParametersController::handleEvent(Ion::Events::Event event) {
@@ -103,16 +103,16 @@ void ParametersController::didBecomeFirstResponder() {
 }
 
 void ParametersController::viewWillAppear() {
-  m_contentView.setNumberOfParameters(m_law->numberOfParameter());
-  for (int i = 0; i < m_law->numberOfParameter(); i++) {
-    m_contentView.parameterDefinitionAtIndex(i)->setMessage(m_law->parameterDefinitionAtIndex(i));
+  m_contentView.setNumberOfParameters(m_distribution->numberOfParameter());
+  for (int i = 0; i < m_distribution->numberOfParameter(); i++) {
+    m_contentView.parameterDefinitionAtIndex(i)->setMessage(m_distribution->parameterDefinitionAtIndex(i));
   }
   m_contentView.layoutSubviews();
   FloatParameterController::viewWillAppear();
 }
 
 int ParametersController::numberOfRows() {
-  return 1+m_law->numberOfParameter();
+  return 1+m_distribution->numberOfParameter();
 }
 
 void ParametersController::willDisplayCellForIndex(HighlightCell * cell, int index) {
@@ -123,7 +123,7 @@ void ParametersController::willDisplayCellForIndex(HighlightCell * cell, int ind
     return;
   }
   MessageTableCellWithEditableText * myCell = (MessageTableCellWithEditableText *) cell;
-  myCell->setMessage(m_law->parameterNameAtIndex(index));
+  myCell->setMessage(m_distribution->parameterNameAtIndex(index));
   FloatParameterController::willDisplayCellForIndex(cell, index);
 }
 
@@ -134,19 +134,19 @@ HighlightCell * ParametersController::reusableParameterCell(int index, int type)
 }
 
 int ParametersController::reusableParameterCellCount(int type) {
-  return m_law->numberOfParameter();
+  return m_distribution->numberOfParameter();
 }
 
 double ParametersController::parameterAtIndex(int index) {
-  return m_law->parameterValueAtIndex(index);
+  return m_distribution->parameterValueAtIndex(index);
 }
 
 bool ParametersController::setParameterAtIndex(int parameterIndex, double f) {
-  if (!m_law->authorizedValueAtIndex(f, parameterIndex)) {
+  if (!m_distribution->authorizedValueAtIndex(f, parameterIndex)) {
     Container::activeApp()->displayWarning(I18n::Message::ForbiddenValue);
     return false;
   }
-  m_law->setParameterAtIndex(f, parameterIndex);
+  m_distribution->setParameterAtIndex(f, parameterIndex);
   m_calculationController->setCalculationAccordingToIndex(0, true);
   return true;
 }
diff --git a/apps/probability/parameters_controller.h b/apps/probability/parameters_controller.h
index c938e4ae5..d20f9df34 100644
--- a/apps/probability/parameters_controller.h
+++ b/apps/probability/parameters_controller.h
@@ -3,14 +3,14 @@
 
 #include <escher.h>
 #include "../shared/float_parameter_controller.h"
-#include "law/law.h"
+#include "distribution/distribution.h"
 #include "calculation_controller.h"
 
 namespace Probability {
 
 class ParametersController : public Shared::FloatParameterController {
 public:
-  ParametersController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Law * m_law, CalculationController * calculationController);
+  ParametersController(Responder * parentResponder, InputEventHandlerDelegate * inputEventHandlerDelegate, Distribution * m_distribution, CalculationController * calculationController);
   const char * title() override;
   View * view() override { return &m_contentView; }
   bool handleEvent(Ion::Events::Event event) override;
@@ -47,7 +47,7 @@ private:
   constexpr static int k_maxNumberOfCells = 2;
   ContentView m_contentView;
   MessageTableCellWithEditableText m_menuListCell[k_maxNumberOfCells];
-  Law * m_law;
+  Distribution * m_distribution;
   CalculationController * m_calculationController;
 };
 
diff --git a/apps/probability/responder_image_cell.cpp b/apps/probability/responder_image_cell.cpp
index 947bde386..a23b65309 100644
--- a/apps/probability/responder_image_cell.cpp
+++ b/apps/probability/responder_image_cell.cpp
@@ -3,10 +3,10 @@
 
 namespace Probability {
 
-ResponderImageCell::ResponderImageCell(Responder * parentResponder, Law * law, Calculation * calculation, CalculationController * calculationController) :
+ResponderImageCell::ResponderImageCell(Responder * parentResponder, Distribution * distribution, Calculation * calculation, CalculationController * calculationController) :
   HighlightCell(),
   Responder(parentResponder),
-  m_calculationTypeController(nullptr, law, calculation, calculationController)
+  m_calculationTypeController(nullptr, distribution, calculation, calculationController)
 {
 }
 
diff --git a/apps/probability/responder_image_cell.h b/apps/probability/responder_image_cell.h
index 40ca8bdbd..acb8ad584 100644
--- a/apps/probability/responder_image_cell.h
+++ b/apps/probability/responder_image_cell.h
@@ -10,7 +10,7 @@ namespace Probability {
 
 class ResponderImageCell : public HighlightCell, public Responder {
 public:
-  ResponderImageCell(Responder * parentResponder, Law * law, Calculation * calculation, CalculationController * calculationController);
+  ResponderImageCell(Responder * parentResponder, Distribution * distribution, Calculation * calculation, CalculationController * calculationController);
   Responder * responder() override {
     return this;
   }
diff --git a/apps/probability/test/distributions.cpp b/apps/probability/test/distributions.cpp
new file mode 100644
index 000000000..deab8b832
--- /dev/null
+++ b/apps/probability/test/distributions.cpp
@@ -0,0 +1,78 @@
+#include <quiz.h>
+#include <string.h>
+#include <assert.h>
+#include <float.h>
+#include <cmath>
+#include "../distribution/chi_squared_distribution.h"
+#include "../distribution/geometric_distribution.h"
+#include "../distribution/student_distribution.h"
+
+void assert_cumulative_distributive_function_direct_and_inverse_is(Probability::Distribution * distribution, double x, double result) {
+  double r = distribution->cumulativeDistributiveFunctionAtAbscissa(x);
+  quiz_assert(!std::isnan(r));
+  quiz_assert(!std::isinf(r));
+  quiz_assert(std::abs(r-result)/result < FLT_EPSILON);
+
+  r = distribution->cumulativeDistributiveInverseForProbability(&result);
+  quiz_assert(!std::isnan(r));
+  quiz_assert(!std::isinf(r));
+  quiz_assert(std::abs(r-x) < FLT_EPSILON || std::abs(r-x)/x < FLT_EPSILON);
+
+}
+
+//TODO other distributions
+
+QUIZ_CASE(chi_squared_distribution) {
+  // Chi Squared distribution with 1 degree of freedom
+  Probability::ChiSquaredDistribution distribution;
+  distribution.setParameterAtIndex(1.0, 0);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 1.3, 0.7457867763960355222963016785797663033008575439453125);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 2.9874567, 0.91608813616541218127764523160294629633426666259765625);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 4.987, 0.97446155200631878745554104170878417789936065673828125);
+
+  // Chi Squared distribution with 1.3 degrees of freedom
+  distribution.setParameterAtIndex(1.3, 0);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 1.3, 0.66209429400375563457004091105773113667964935302734375);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 2.9874567, 0.878804860316481750714956433512270450592041015625);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 4.987, 0.96090315938362369507785842870362102985382080078125);
+
+  // Chi Squared distribution with 5.4 degrees of freedom
+  distribution.setParameterAtIndex(5.4, 0);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 1.3, 0.047059684573231390369851823152202996425330638885498046875);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 2.9874567, 0.250530060451470470983537097708904184401035308837890625);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 4.987, 0.53051693435084168459781039928202517330646514892578125);
+}
+
+QUIZ_CASE(student_distribution) {
+  // Student distribution with 1 degree of freedom
+  Probability::StudentDistribution distribution;
+  distribution.setParameterAtIndex(1.0, 0);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, -2.0, 0.1475836176504332741754010762247405259511345238869178945999223128627);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 0.0, 0.5);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 3.4567, 0.9103622230304611040452300585457123816013336181640625);
+
+  // Student distribution with 1.3 degrees of freedom
+  distribution.setParameterAtIndex(1.3, 0);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, -4.987, 0.041958035438260647687069848643659497611224651336669921875);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 1.3, 0.8111769751474751100062121622613631188869476318359375);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 2.9874567, 0.92143912473359812498330256858025677502155303955078125);
+
+  // Student distribution with 5.4 degrees of freedom
+  distribution.setParameterAtIndex(5.4, 0);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, -4.987, 0.00167496657737900025118837898929768925881944596767425537109375);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 1.3, 0.876837383157582639370275501278229057788848876953125);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 2.9874567, 0.98612148076325445433809591122553683817386627197265625);
+}
+
+QUIZ_CASE(geometric_distribution) {
+  // Geometric distribution with probability of success 0.5
+  Probability::GeometricDistribution distribution;
+  distribution.setParameterAtIndex(0.5, 0);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 2.0, 0.875);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 3.0, 0.9375);
+
+  // Geometric distribution with probability of success 0.2
+  distribution.setParameterAtIndex(0.2, 0);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 7.0, 0.8322278399999998299563230830244719982147216796875);
+  assert_cumulative_distributive_function_direct_and_inverse_is(&distribution, 3.0, 0.5904);
+}
diff --git a/apps/probability/test/erf_inv.cpp b/apps/probability/test/erf_inv.cpp
index dc0fe0b55..577f8fb61 100644
--- a/apps/probability/test/erf_inv.cpp
+++ b/apps/probability/test/erf_inv.cpp
@@ -3,7 +3,7 @@
 #include <assert.h>
 #include <float.h>
 #include <cmath>
-#include "../law/erf_inv.h"
+#include "../distribution/erf_inv.h"
 
 QUIZ_CASE(erf_inv) {
   quiz_assert(erfInv(0.0) == 0.0);
diff --git a/apps/probability/test/hypergeometric_function.cpp b/apps/probability/test/hypergeometric_function.cpp
index d01517c14..df30162b6 100644
--- a/apps/probability/test/hypergeometric_function.cpp
+++ b/apps/probability/test/hypergeometric_function.cpp
@@ -3,13 +3,13 @@
 #include <assert.h>
 #include <float.h>
 #include <cmath>
-#include "../law/student_law.h"
-#include "../law/hypergeometric_function.h"
+#include "../distribution/student_distribution.h"
+#include "../distribution/hypergeometric_function.h"
 
 void assert_hypergeometric_is(double a, double b, double c, double z, double result) {
   double r = 0.0;
-  const double precision = Probability::StudentLaw::k_hypergeometricFunctionPrecision;
-  quiz_assert(hypergeometricFunction(a, b, c, z, precision, Probability::StudentLaw::k_maxHypergeometricFunctionIterations, &r));
+  const double precision = Probability::StudentDistribution::k_hypergeometricFunctionPrecision;
+  quiz_assert(hypergeometricFunction(a, b, c, z, precision, Probability::StudentDistribution::k_maxHypergeometricFunctionIterations, &r));
   quiz_assert(std::abs(r - result)/result <= 100 * precision); // Multiply by 100 because precision is too strict
 }
 
diff --git a/apps/probability/test/laws.cpp b/apps/probability/test/laws.cpp
deleted file mode 100644
index 29f2b7ed3..000000000
--- a/apps/probability/test/laws.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include <quiz.h>
-#include <string.h>
-#include <assert.h>
-#include <float.h>
-#include <cmath>
-#include "../law/chi_squared_law.h"
-#include "../law/geometric_law.h"
-#include "../law/student_law.h"
-
-void assert_cumulative_distributive_function_direct_and_inverse_is(Probability::Law * law, double x, double result) {
-  double r = law->cumulativeDistributiveFunctionAtAbscissa(x);
-  quiz_assert(!std::isnan(r));
-  quiz_assert(!std::isinf(r));
-  quiz_assert(std::abs(r-result)/result < FLT_EPSILON);
-
-  r = law->cumulativeDistributiveInverseForProbability(&result);
-  quiz_assert(!std::isnan(r));
-  quiz_assert(!std::isinf(r));
-  quiz_assert(std::abs(r-x) < FLT_EPSILON || std::abs(r-x)/x < FLT_EPSILON);
-
-}
-
-//TODO other laws
-
-QUIZ_CASE(chi_squared_law) {
-  // Chi Squared law with 1 degree of freedom
-  Probability::ChiSquaredLaw law;
-  law.setParameterAtIndex(1.0, 0);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 1.3, 0.7457867763960355222963016785797663033008575439453125);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 2.9874567, 0.91608813616541218127764523160294629633426666259765625);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 4.987, 0.97446155200631878745554104170878417789936065673828125);
-
-  // Chi Squared law with 1.3 degrees of freedom
-  law.setParameterAtIndex(1.3, 0);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 1.3, 0.66209429400375563457004091105773113667964935302734375);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 2.9874567, 0.878804860316481750714956433512270450592041015625);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 4.987, 0.96090315938362369507785842870362102985382080078125);
-
-  // Chi Squared law with 5.4 degrees of freedom
-  law.setParameterAtIndex(5.4, 0);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 1.3, 0.047059684573231390369851823152202996425330638885498046875);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 2.9874567, 0.250530060451470470983537097708904184401035308837890625);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 4.987, 0.53051693435084168459781039928202517330646514892578125);
-}
-
-QUIZ_CASE(student_law) {
-  // Student law with 1 degree of freedom
-  Probability::StudentLaw law;
-  law.setParameterAtIndex(1.0, 0);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, -2.0, 0.1475836176504332741754010762247405259511345238869178945999223128627);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 0.0, 0.5);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 3.4567, 0.9103622230304611040452300585457123816013336181640625);
-
-  // Student law with 1.3 degrees of freedom
-  law.setParameterAtIndex(1.3, 0);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, -4.987, 0.041958035438260647687069848643659497611224651336669921875);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 1.3, 0.8111769751474751100062121622613631188869476318359375);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 2.9874567, 0.92143912473359812498330256858025677502155303955078125);
-
-  // Student law with 5.4 degrees of freedom
-  law.setParameterAtIndex(5.4, 0);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, -4.987, 0.00167496657737900025118837898929768925881944596767425537109375);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 1.3, 0.876837383157582639370275501278229057788848876953125);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 2.9874567, 0.98612148076325445433809591122553683817386627197265625);
-}
-
-QUIZ_CASE(geometric_law) {
-  // Geometric law with probability of success 0.5
-  Probability::GeometricLaw law;
-  law.setParameterAtIndex(0.5, 0);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 2.0, 0.875);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 3.0, 0.9375);
-
-  // Geometric law with probability of success 0.2
-  law.setParameterAtIndex(0.2, 0);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 7.0, 0.8322278399999998299563230830244719982147216796875);
-  assert_cumulative_distributive_function_direct_and_inverse_is(&law, 3.0, 0.5904);
-}
diff --git a/apps/probability/test/regularized_gamma.cpp b/apps/probability/test/regularized_gamma.cpp
index 6e4edf097..19794e5d9 100644
--- a/apps/probability/test/regularized_gamma.cpp
+++ b/apps/probability/test/regularized_gamma.cpp
@@ -3,13 +3,13 @@
 #include <assert.h>
 #include <float.h>
 #include <cmath>
-#include "../law/chi_squared_law.h"
-#include "../law/regularized_gamma.h"
+#include "../distribution/chi_squared_distribution.h"
+#include "../distribution/regularized_gamma.h"
 
 void assert_regularized_gamma_is(double s, double x, double result) {
   double r = 0.0;
   const double precision = FLT_EPSILON;
-  regularizedGamma(s, x, precision, Probability::ChiSquaredLaw::k_maxRegularizedGammaIterations, &r);
+  regularizedGamma(s, x, precision, Probability::ChiSquaredDistribution::k_maxRegularizedGammaIterations, &r);
   quiz_assert(std::abs(r - result) <= precision);
 }
 
@@ -25,10 +25,10 @@ QUIZ_CASE(regularized_gamma) {
   /* Choose parameters verifying both x >= s + 1.0 and x < s + 1.0 because the
    * algoritm changes.
    * To compute the result for assert_regularized_gamma_is(s, x, result),
-   * compute the value of P(t<2*x) for the chi-squared law with 2*s degrees of
+   * compute the value of P(t<2*x) for the chi-squared distribution with 2*s degrees of
    * freedom. */
 
-  // Chi-squared law with degrees of freedom = 1
+  // Chi-squared distribution with degrees of freedom = 1
   // P(x<0.5)
   assert_regularized_gamma_is(0.5, 0.25, 0.5204998778130465186819719747290946543216705322265625);
   // P(x<0.9)
@@ -59,7 +59,7 @@ QUIZ_CASE(regularized_gamma) {
   assert_regularized_gamma_is(0.5, 4.13, 0.995947187204140771399352161097340285778045654296875);
 
 
-  // Chi-squared law with degrees of freedom = 2
+  // Chi-squared distribution with degrees of freedom = 2
   // P(x<0.5)
   assert_regularized_gamma_is(1.0, 0.25, 0.22119921692859512152296019849018193781375885009765625);
   // P(x<0.9)
@@ -90,7 +90,7 @@ QUIZ_CASE(regularized_gamma) {
   assert_regularized_gamma_is(1.0, 4.13, 0.983917121177411591048667105496861040592193603515625);
 
 
-  // Chi-squared law with degrees of freedom = 3
+  // Chi-squared distribution with degrees of freedom = 3
   // P(x<0.5)
   assert_regularized_gamma_is(1.5, 0.25, 0.081108588345324139634584525992977432906627655029296875);
   // P(x<0.9)