UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-01-19 00:37:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

[apps/proba] Factorize code

Browse Source
This commit is contained in:
Léa Saviot
2019-08-26 16:04:08 +02:00
parent ddba1f6050
commit a8a5ecfd4e
4 changed files with 19 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
apps/probability/distribution/distribution.cpp
View File

@@ -58,27 +58,12 @@ double Distribution::cumulativeDistributiveInverseForProbability(double * probab
if (*probability <= 0.0) {
return 0.0;
}
double p = 0.0;
int k = 0;
double delta = 0.0;
do {
delta = std::fabs(*probability-p);
p += evaluateAtDiscreteAbscissa(k++);
if (p >= k_maxProbability && std::fabs(*probability-1.0) <= delta) {
*probability = 1.0;
return k-1.0;
}
} while (std::fabs(*probability-p) <= delta && k < k_maxNumberOfOperations && p < 1.0);
p -= evaluateAtDiscreteAbscissa(--k);
if (k == k_maxNumberOfOperations) {
*probability = 1.0;
return INFINITY;
}
*probability = p;
if (std::isnan(*probability)) {
return NAN;
}
return k-1.0;
return Poincare::Solver::CumulativeDistributiveInverseForNDefinedFunction<double>(probability,
[](double k, Poincare::Context * context, Poincare::Preferences::ComplexFormat complexFormat, Poincare::Preferences::AngleUnit angleUnit, const void * context1, const void * context2, const void * context3) {
const Distribution * distribution = reinterpret_cast<const Distribution *>(context1);
return distribution->evaluateAtDiscreteAbscissa(k);
}, nullptr, Poincare::Preferences::ComplexFormat::Real, Poincare::Preferences::AngleUnit::Degree, this);
// Context, complex format and angle unit are dummy values
}
double Distribution::rightIntegralInverseForProbability(double * probability) {

2
poincare/include/poincare/solver.h
View File

@@ -20,7 +20,7 @@ public:
// Proba
// Cumulative distributive inverse for function defined on N (positive integers)
template<typename T> static T CumulativeDistributiveInverseForNDefinedFunction(T probability, ValueAtAbscissa evaluation, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, const void * context1 = nullptr, const void * context2 = nullptr, const void * context3 = nullptr);
template<typename T> static T CumulativeDistributiveInverseForNDefinedFunction(T * probability, ValueAtAbscissa evaluation, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, const void * context1 = nullptr, const void * context2 = nullptr, const void * context3 = nullptr);
// Cumulative distributive function for function defined on N (positive integers)
template<typename T> static T CumulativeDistributiveFunctionForNDefinedFunction(T x, ValueAtAbscissa evaluation, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, const void * context1 = nullptr, const void * context2 = nullptr, const void * context3 = nullptr);

4
poincare/src/binomial_distribution.cpp
View File

@@ -81,9 +81,9 @@ T BinomialDistribution::CumulativeDistributiveInverseForProbability(T probabilit
if (std::abs(probability - (T)1.0) < precision) {
return n;
}
T proba = probability;
return Solver::CumulativeDistributiveInverseForNDefinedFunction<T>(
probability,
&proba,
[](double x, Context * context, Poincare::Preferences::ComplexFormat complexFormat, Poincare::Preferences::AngleUnit angleUnit, const void * n, const void * p, const void * isDouble) {
if (*(bool *)isDouble) {
return (double)BinomialDistribution::EvaluateAtAbscissa<T>(x, *(reinterpret_cast<const double *>(n)), *(reinterpret_cast<const double *>(p)));

17
poincare/src/solver.cpp
View File

@@ -206,23 +206,26 @@ Coordinate2D Solver::IncreasingFunctionRoot(double ax, double bx, double precisi
}
template<typename T>
T Solver::CumulativeDistributiveInverseForNDefinedFunction(T probability, ValueAtAbscissa evaluation, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, const void * context1, const void * context2, const void * context3) {
T Solver::CumulativeDistributiveInverseForNDefinedFunction(T * probability, ValueAtAbscissa evaluation, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, const void * context1, const void * context2, const void * context3) {
T precision = sizeof(T) == sizeof(double) ? DBL_EPSILON : FLT_EPSILON;
assert(probability <= (((T)1.0) - precision) && probability > precision);
assert(*probability <= (((T)1.0) - precision) && *probability > precision);
T p = 0.0;
int k = 0;
T delta = 0.0;
do {
delta = std::fabs(probability-p);
delta = std::fabs(*probability-p);
p += evaluation(k++, context, complexFormat, angleUnit, context1, context2, context3);
if (p >= k_maxProbability && std::fabs(probability-1.0) <= delta) {
if (p >= k_maxProbability && std::fabs(*probability-1.0) <= delta) {
*probability = (T)1.0;
return (T)(k-1);
}
} while (std::fabs(probability-p) <= delta && k < k_maxNumberOfOperations && p < 1.0);
} while (std::fabs(*probability-p) <= delta && k < k_maxNumberOfOperations && p < 1.0);
p -= evaluation(--k, context, complexFormat, angleUnit, context1, context2, context3);
if (k == k_maxNumberOfOperations) {
*probability = (T)1.0;
return INFINITY;
}
*probability = p;
if (std::isnan(p)) {
return NAN;
}
@@ -247,8 +250,8 @@ T Solver::CumulativeDistributiveFunctionForNDefinedFunction(T x, ValueAtAbscissa
return result;
}
template float Solver::CumulativeDistributiveInverseForNDefinedFunction(float, ValueAtAbscissa, Context *, Preferences::ComplexFormat, Preferences::AngleUnit, const void *, const void *, const void *);
template double Solver::CumulativeDistributiveInverseForNDefinedFunction(double, ValueAtAbscissa, Context *, Preferences::ComplexFormat, Preferences::AngleUnit, const void *, const void *, const void *);
template float Solver::CumulativeDistributiveInverseForNDefinedFunction(float *, ValueAtAbscissa, Context *, Preferences::ComplexFormat, Preferences::AngleUnit, const void *, const void *, const void *);
template double Solver::CumulativeDistributiveInverseForNDefinedFunction(double *, ValueAtAbscissa, Context *, Preferences::ComplexFormat, Preferences::AngleUnit, const void *, const void *, const void *);
template float Solver::CumulativeDistributiveFunctionForNDefinedFunction(float, ValueAtAbscissa, Context *, Preferences::ComplexFormat, Preferences::AngleUnit, const void *, const void *, const void *);
template double Solver::CumulativeDistributiveFunctionForNDefinedFunction(double, ValueAtAbscissa, Context *, Preferences::ComplexFormat, Preferences::AngleUnit, const void *, const void *, const void *);