From 7142f9545e8ab08e77d2cbc455f0ce63b2d0723b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89milie=20Feral?= Date: Tue, 3 Nov 2020 17:39:44 +0100 Subject: [PATCH] [poincare] Finish replacing approximateContext --- poincare/include/poincare/absolute_value.h | 8 ++-- poincare/include/poincare/addition.h | 8 ++-- .../include/poincare/approximation_helper.h | 6 +-- poincare/include/poincare/arc_cosine.h | 8 ++-- poincare/include/poincare/arc_sine.h | 8 ++-- poincare/include/poincare/arc_tangent.h | 8 ++-- poincare/include/poincare/arithmetic.h | 4 +- poincare/include/poincare/based_integer.h | 4 +- poincare/include/poincare/binom_cdf.h | 6 +-- poincare/include/poincare/binom_pdf.h | 6 +-- .../include/poincare/binomial_coefficient.h | 6 +-- poincare/include/poincare/ceiling.h | 8 ++-- poincare/include/poincare/complex_argument.h | 8 ++-- poincare/include/poincare/complex_cartesian.h | 6 +-- .../include/poincare/confidence_interval.h | 6 +-- poincare/include/poincare/conjugate.h | 8 ++-- poincare/include/poincare/constant.h | 4 +- poincare/include/poincare/cosine.h | 8 ++-- poincare/include/poincare/decimal.h | 4 +- poincare/include/poincare/derivative.h | 12 ++--- poincare/include/poincare/determinant.h | 6 +-- poincare/include/poincare/division.h | 8 ++-- poincare/include/poincare/division_quotient.h | 6 +-- .../include/poincare/division_remainder.h | 6 +-- poincare/include/poincare/empty_expression.h | 6 +-- poincare/include/poincare/equal.h | 6 +-- poincare/include/poincare/expression_node.h | 44 +++++++++++-------- poincare/include/poincare/factor.h | 8 ++-- poincare/include/poincare/factorial.h | 8 ++-- poincare/include/poincare/float.h | 6 +-- poincare/include/poincare/floor.h | 8 ++-- poincare/include/poincare/frac_part.h | 8 ++-- poincare/include/poincare/function.h | 6 +-- .../include/poincare/great_common_divisor.h | 6 +-- .../include/poincare/hyperbolic_arc_cosine.h | 8 ++-- .../include/poincare/hyperbolic_arc_sine.h | 8 ++-- .../include/poincare/hyperbolic_arc_tangent.h | 8 ++-- poincare/include/poincare/hyperbolic_cosine.h | 8 ++-- poincare/include/poincare/hyperbolic_sine.h | 8 ++-- .../include/poincare/hyperbolic_tangent.h | 8 ++-- poincare/include/poincare/imaginary_part.h | 8 ++-- poincare/include/poincare/infinity.h | 4 +- poincare/include/poincare/integral.h | 12 ++--- poincare/include/poincare/inv_binom.h | 6 +-- poincare/include/poincare/inv_norm.h | 6 +-- .../include/poincare/least_common_multiple.h | 6 +-- poincare/include/poincare/logarithm.h | 8 ++-- poincare/include/poincare/matrix.h | 10 ++--- poincare/include/poincare/matrix_dimension.h | 6 +-- .../include/poincare/matrix_echelon_form.h | 6 +-- poincare/include/poincare/matrix_identity.h | 6 +-- poincare/include/poincare/matrix_inverse.h | 6 +-- poincare/include/poincare/matrix_trace.h | 6 +-- poincare/include/poincare/matrix_transpose.h | 6 +-- poincare/include/poincare/multiplication.h | 8 ++-- .../include/poincare/naperian_logarithm.h | 8 ++-- poincare/include/poincare/norm_cdf.h | 6 +-- poincare/include/poincare/norm_cdf2.h | 6 +-- poincare/include/poincare/norm_pdf.h | 6 +-- poincare/include/poincare/nth_root.h | 6 +-- poincare/include/poincare/opposite.h | 8 ++-- poincare/include/poincare/parenthesis.h | 6 +-- .../include/poincare/permute_coefficient.h | 6 +-- poincare/include/poincare/power.h | 10 ++--- .../include/poincare/prediction_interval.h | 6 +-- poincare/include/poincare/randint.h | 10 ++--- poincare/include/poincare/random.h | 4 +- poincare/include/poincare/rational.h | 4 +- poincare/include/poincare/real_part.h | 8 ++-- poincare/include/poincare/round.h | 6 +-- poincare/include/poincare/sequence.h | 6 +-- poincare/include/poincare/sign_function.h | 8 ++-- poincare/include/poincare/sine.h | 8 ++-- poincare/include/poincare/square_root.h | 8 ++-- poincare/include/poincare/store.h | 8 ++-- poincare/include/poincare/subtraction.h | 8 ++-- poincare/include/poincare/sum_and_product.h | 6 +-- poincare/include/poincare/symbol.h | 6 +-- poincare/include/poincare/tangent.h | 8 ++-- poincare/include/poincare/undefined.h | 4 +- poincare/include/poincare/unit.h | 6 +-- poincare/include/poincare/unit_convert.h | 6 +-- poincare/include/poincare/unreal.h | 4 +- poincare/include/poincare/vector_cross.h | 6 +-- poincare/include/poincare/vector_dot.h | 6 +-- poincare/include/poincare/vector_norm.h | 6 +-- poincare/src/absolute_value.cpp | 2 +- poincare/src/approximation_helper.cpp | 38 ++++++++-------- poincare/src/arithmetic.cpp | 22 +++++----- poincare/src/binom_cdf.cpp | 8 ++-- poincare/src/binom_pdf.cpp | 8 ++-- poincare/src/binomial_coefficient.cpp | 6 +-- poincare/src/complex_argument.cpp | 2 +- poincare/src/complex_cartesian.cpp | 6 +-- poincare/src/confidence_interval.cpp | 6 +-- poincare/src/derivative.cpp | 27 ++++++------ poincare/src/determinant.cpp | 4 +- poincare/src/division_quotient.cpp | 6 +-- poincare/src/division_remainder.cpp | 6 +-- poincare/src/empty_expression.cpp | 2 +- poincare/src/equal.cpp | 2 +- poincare/src/expression.cpp | 8 ++-- poincare/src/factor.cpp | 10 ++--- poincare/src/function.cpp | 16 +++---- poincare/src/great_common_divisor.cpp | 8 ++-- .../src/hyperbolic_trigonometric_function.cpp | 4 +- poincare/src/integral.cpp | 37 ++++++++-------- poincare/src/inv_binom.cpp | 8 ++-- poincare/src/inv_norm.cpp | 8 ++-- poincare/src/least_common_multiple.cpp | 8 ++-- poincare/src/logarithm.cpp | 32 +++++++------- poincare/src/matrix.cpp | 4 +- poincare/src/matrix_dimension.cpp | 4 +- poincare/src/matrix_echelon_form.cpp | 4 +- poincare/src/matrix_identity.cpp | 4 +- poincare/src/matrix_inverse.cpp | 4 +- poincare/src/matrix_trace.cpp | 4 +- poincare/src/matrix_transpose.cpp | 4 +- poincare/src/norm_cdf.cpp | 8 ++-- poincare/src/norm_cdf2.cpp | 10 ++--- poincare/src/norm_pdf.cpp | 8 ++-- poincare/src/nth_root.cpp | 10 ++--- poincare/src/parenthesis.cpp | 4 +- poincare/src/permute_coefficient.cpp | 6 +-- poincare/src/power.cpp | 14 +++--- poincare/src/prediction_interval.cpp | 6 +-- poincare/src/randint.cpp | 8 ++-- poincare/src/round.cpp | 6 +-- poincare/src/sequence.cpp | 16 +++---- poincare/src/sign_function.cpp | 2 +- poincare/src/store.cpp | 10 ++--- poincare/src/sum_and_product.cpp | 17 +++---- poincare/src/symbol.cpp | 6 +-- poincare/src/symbol_abstract.cpp | 2 +- poincare/src/trigonometry.cpp | 4 +- poincare/src/trigonometry_cheat_table.cpp | 2 +- poincare/src/unit.cpp | 6 +-- poincare/src/unit_convert.cpp | 6 +-- poincare/src/vector_cross.cpp | 6 +-- poincare/src/vector_dot.cpp | 6 +-- poincare/src/vector_norm.cpp | 4 +- 141 files changed, 556 insertions(+), 547 deletions(-) diff --git a/poincare/include/poincare/absolute_value.h b/poincare/include/poincare/absolute_value.h index a9324ee3f..f16a3508b 100644 --- a/poincare/include/poincare/absolute_value.h +++ b/poincare/include/poincare/absolute_value.h @@ -28,11 +28,11 @@ public: template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { return Complex::Builder(std::abs(c)); } - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } // Layout diff --git a/poincare/include/poincare/addition.h b/poincare/include/poincare/addition.h index 58e3c1bae..7a17468eb 100644 --- a/poincare/include/poincare/addition.h +++ b/poincare/include/poincare/addition.h @@ -64,11 +64,11 @@ private: template static MatrixComplex computeOnMatrixAndComplex(const MatrixComplex m, const std::complex c, Preferences::ComplexFormat complexFormat) { return MatrixComplex::Undefined(); } - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::MapReduce(this, context, complexFormat, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::MapReduce(this, approximationContext, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::MapReduce(this, context, complexFormat, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::MapReduce(this, approximationContext, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } }; diff --git a/poincare/include/poincare/approximation_helper.h b/poincare/include/poincare/approximation_helper.h index b16869948..2ddc6289d 100644 --- a/poincare/include/poincare/approximation_helper.h +++ b/poincare/include/poincare/approximation_helper.h @@ -10,17 +10,17 @@ namespace Poincare { namespace ApproximationHelper { template T Epsilon(); - template int PositiveIntegerApproximationIfPossible(const ExpressionNode * expression, bool * isUndefined, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); + template int PositiveIntegerApproximationIfPossible(const ExpressionNode * expression, bool * isUndefined, ExpressionNode::ApproximationContext approximationContext); template std::complex NeglectRealOrImaginaryPartIfNeglectable(std::complex result, std::complex input1, std::complex input2 = 1.0, bool enableNullResult = true); template using ComplexCompute = Complex(*)(const std::complex, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - template Evaluation Map(const ExpressionNode * expression, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, ComplexCompute compute); + template Evaluation Map(const ExpressionNode * expression, ExpressionNode::ApproximationContext approximationContext, ComplexCompute compute); template using ComplexAndComplexReduction = Complex(*)(const std::complex, const std::complex, Preferences::ComplexFormat complexFormat); template using ComplexAndMatrixReduction = MatrixComplex(*)(const std::complex c, const MatrixComplex m, Preferences::ComplexFormat complexFormat); template using MatrixAndComplexReduction = MatrixComplex(*)(const MatrixComplex m, const std::complex c, Preferences::ComplexFormat complexFormat); template using MatrixAndMatrixReduction = MatrixComplex(*)(const MatrixComplex m, const MatrixComplex n, Preferences::ComplexFormat complexFormat); - template Evaluation MapReduce(const ExpressionNode * expression, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, ComplexAndComplexReduction computeOnComplexes, ComplexAndMatrixReduction computeOnComplexAndMatrix, MatrixAndComplexReduction computeOnMatrixAndComplex, MatrixAndMatrixReduction computeOnMatrices); + template Evaluation MapReduce(const ExpressionNode * expression, ExpressionNode::ApproximationContext approximationContext, ComplexAndComplexReduction computeOnComplexes, ComplexAndMatrixReduction computeOnComplexAndMatrix, MatrixAndComplexReduction computeOnMatrixAndComplex, MatrixAndMatrixReduction computeOnMatrices); template MatrixComplex ElementWiseOnMatrixComplexAndComplex(const MatrixComplex n, std::complex c, Preferences::ComplexFormat complexFormat, ComplexAndComplexReduction computeOnComplexes); template MatrixComplex ElementWiseOnComplexMatrices(const MatrixComplex m, const MatrixComplex n, Preferences::ComplexFormat complexFormat, ComplexAndComplexReduction computeOnComplexes); diff --git a/poincare/include/poincare/arc_cosine.h b/poincare/include/poincare/arc_cosine.h index f95f34827..c3267ad26 100644 --- a/poincare/include/poincare/arc_cosine.h +++ b/poincare/include/poincare/arc_cosine.h @@ -35,11 +35,11 @@ private: //Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/arc_sine.h b/poincare/include/poincare/arc_sine.h index f5c5c07e1..b2a8945d6 100644 --- a/poincare/include/poincare/arc_sine.h +++ b/poincare/include/poincare/arc_sine.h @@ -34,11 +34,11 @@ private: //Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/arc_tangent.h b/poincare/include/poincare/arc_tangent.h index 31147cc4a..5522d1444 100644 --- a/poincare/include/poincare/arc_tangent.h +++ b/poincare/include/poincare/arc_tangent.h @@ -35,11 +35,11 @@ private: //Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/arithmetic.h b/poincare/include/poincare/arithmetic.h index edfb361db..348e5806f 100644 --- a/poincare/include/poincare/arithmetic.h +++ b/poincare/include/poincare/arithmetic.h @@ -14,8 +14,8 @@ public: static Expression LCM(const Expression & expression); static int GCD(int i, int j); static int LCM(int i, int j); - template static Evaluation GCD(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - template static Evaluation LCM(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); + template static Evaluation GCD(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext); + template static Evaluation LCM(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext); /* When outputCoefficients[0] is set to -1, that indicates a special case: * i could not be factorized. * Before calling PrimeFactorization, we initiate two tables of Integers diff --git a/poincare/include/poincare/based_integer.h b/poincare/include/poincare/based_integer.h index 5de001d3d..4dd2627d9 100644 --- a/poincare/include/poincare/based_integer.h +++ b/poincare/include/poincare/based_integer.h @@ -34,8 +34,8 @@ public: Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Approximation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return Complex::Builder(templatedApproximate()); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return Complex::Builder(templatedApproximate()); } + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return Complex::Builder(templatedApproximate()); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return Complex::Builder(templatedApproximate()); } template T templatedApproximate() const; private: diff --git a/poincare/include/poincare/binom_cdf.h b/poincare/include/poincare/binom_cdf.h index 0d017fe07..6d6ce8cc3 100644 --- a/poincare/include/poincare/binom_cdf.h +++ b/poincare/include/poincare/binom_cdf.h @@ -29,9 +29,9 @@ private: int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class BinomCDF final : public BinomialDistributionFunction { diff --git a/poincare/include/poincare/binom_pdf.h b/poincare/include/poincare/binom_pdf.h index 515abbb41..6f99d1180 100644 --- a/poincare/include/poincare/binom_pdf.h +++ b/poincare/include/poincare/binom_pdf.h @@ -29,9 +29,9 @@ private: int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class BinomPDF final : public BinomialDistributionFunction { diff --git a/poincare/include/poincare/binomial_coefficient.h b/poincare/include/poincare/binomial_coefficient.h index c00bc8179..9d5ae2b75 100644 --- a/poincare/include/poincare/binomial_coefficient.h +++ b/poincare/include/poincare/binomial_coefficient.h @@ -30,9 +30,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Complex templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Complex templatedApproximate(ApproximationContext approximationContext) const; }; class BinomialCoefficient final : public Expression { diff --git a/poincare/include/poincare/ceiling.h b/poincare/include/poincare/ceiling.h index c6acc967c..d027f23ec 100644 --- a/poincare/include/poincare/ceiling.h +++ b/poincare/include/poincare/ceiling.h @@ -31,11 +31,11 @@ private: // Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/complex_argument.h b/poincare/include/poincare/complex_argument.h index 04c991789..2169a6013 100644 --- a/poincare/include/poincare/complex_argument.h +++ b/poincare/include/poincare/complex_argument.h @@ -31,11 +31,11 @@ private: // Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/complex_cartesian.h b/poincare/include/poincare/complex_cartesian.h index 37defc849..5f6734dce 100644 --- a/poincare/include/poincare/complex_cartesian.h +++ b/poincare/include/poincare/complex_cartesian.h @@ -26,8 +26,8 @@ private: // Layout Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { assert(false); return Layout(); } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } // Simplification Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowBeautify(ReductionContext reductionContext) override; @@ -38,7 +38,7 @@ private: return LayoutShape::BoundaryPunctuation; }; - template Complex templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + template Complex templatedApproximate(ApproximationContext approximationContext) const; }; class ComplexCartesian final : public Expression { diff --git a/poincare/include/poincare/confidence_interval.h b/poincare/include/poincare/confidence_interval.h index 970b15512..889a292be 100644 --- a/poincare/include/poincare/confidence_interval.h +++ b/poincare/include/poincare/confidence_interval.h @@ -32,9 +32,9 @@ private: LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class SimplePredictionIntervalNode final : public ConfidenceIntervalNode { diff --git a/poincare/include/poincare/conjugate.h b/poincare/include/poincare/conjugate.h index e019b77fe..c7edcbee7 100644 --- a/poincare/include/poincare/conjugate.h +++ b/poincare/include/poincare/conjugate.h @@ -33,11 +33,11 @@ private: // Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/constant.h b/poincare/include/poincare/constant.h index 33741479e..879ae4b8d 100644 --- a/poincare/include/poincare/constant.h +++ b/poincare/include/poincare/constant.h @@ -34,8 +34,8 @@ public: Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Approximation */ - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(); } + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(); } /* Symbol properties */ bool isPi() const { return isConstantCodePoint(UCodePointGreekSmallLetterPi); } diff --git a/poincare/include/poincare/cosine.h b/poincare/include/poincare/cosine.h index 9f262ebc1..ae14e37ab 100644 --- a/poincare/include/poincare/cosine.h +++ b/poincare/include/poincare/cosine.h @@ -38,11 +38,11 @@ private: Expression unaryFunctionDifferential() override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/decimal.h b/poincare/include/poincare/decimal.h index b00af47b8..60a217438 100644 --- a/poincare/include/poincare/decimal.h +++ b/poincare/include/poincare/decimal.h @@ -46,10 +46,10 @@ public: Expression setSign(Sign s, ReductionContext reductionContext) override; // Approximation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return Complex::Builder(templatedApproximate()); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return Complex::Builder(templatedApproximate()); } diff --git a/poincare/include/poincare/derivative.h b/poincare/include/poincare/derivative.h index 439833127..f75e72683 100644 --- a/poincare/include/poincare/derivative.h +++ b/poincare/include/poincare/derivative.h @@ -34,12 +34,12 @@ private: LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; - template T approximateWithArgument(T x, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; - template T growthRateAroundAbscissa(T x, T h, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; - template T riddersApproximation(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, T x, T h, T * error) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; + template T approximateWithArgument(T x, ApproximationContext approximationContext) const; + template T growthRateAroundAbscissa(T x, T h, ApproximationContext approximationContext) const; + template T riddersApproximation(ApproximationContext approximationContext, T x, T h, T * error) const; // TODO: Change coefficients? constexpr static double k_maxErrorRateOnApproximation = 0.001; constexpr static double k_minInitialRate = 0.01; diff --git a/poincare/include/poincare/determinant.h b/poincare/include/poincare/determinant.h index b672bcaf3..6d0d2100f 100644 --- a/poincare/include/poincare/determinant.h +++ b/poincare/include/poincare/determinant.h @@ -28,9 +28,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } /* Approximation */ - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; diff --git a/poincare/include/poincare/division.h b/poincare/include/poincare/division.h index 75fdf84ab..e03369017 100644 --- a/poincare/include/poincare/division.h +++ b/poincare/include/poincare/division.h @@ -33,15 +33,15 @@ public: Expression removeUnit(Expression * unit) override { assert(false); return ExpressionNode::removeUnit(unit); } // Approximation - virtual Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { + virtual Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return ApproximationHelper::MapReduce( - this, context, complexFormat, angleUnit, compute, + this, approximationContext, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } - virtual Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { + virtual Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return ApproximationHelper::MapReduce( - this, context, complexFormat, angleUnit, compute, + this, approximationContext, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } diff --git a/poincare/include/poincare/division_quotient.h b/poincare/include/poincare/division_quotient.h index 6d4444698..7f99045c2 100644 --- a/poincare/include/poincare/division_quotient.h +++ b/poincare/include/poincare/division_quotient.h @@ -33,9 +33,9 @@ private: // Simplification Expression shallowReduce(ReductionContext reductionContext) override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class DivisionQuotient final : public Expression { diff --git a/poincare/include/poincare/division_remainder.h b/poincare/include/poincare/division_remainder.h index 183e4e320..f5f47538e 100644 --- a/poincare/include/poincare/division_remainder.h +++ b/poincare/include/poincare/division_remainder.h @@ -35,9 +35,9 @@ private: // Simplification Expression shallowReduce(ReductionContext reductionContext) override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class DivisionRemainder final : public Expression { diff --git a/poincare/include/poincare/empty_expression.h b/poincare/include/poincare/empty_expression.h index ac3d849ac..a069965a2 100644 --- a/poincare/include/poincare/empty_expression.h +++ b/poincare/include/poincare/empty_expression.h @@ -33,9 +33,9 @@ private: // Layout Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class EmptyExpression final : public Expression { diff --git a/poincare/include/poincare/equal.h b/poincare/include/poincare/equal.h index 60af23182..fa067652f 100644 --- a/poincare/include/poincare/equal.h +++ b/poincare/include/poincare/equal.h @@ -28,9 +28,9 @@ private: Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Evalutation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Equal final : public Expression { diff --git a/poincare/include/poincare/expression_node.h b/poincare/include/poincare/expression_node.h index 03a4f009f..37fb0ae27 100644 --- a/poincare/include/poincare/expression_node.h +++ b/poincare/include/poincare/expression_node.h @@ -162,54 +162,60 @@ public: Null = 1, }; - class ReductionContext { + class ComputationContext { public: - ReductionContext(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, Preferences::UnitFormat unitFormat, ReductionTarget target, SymbolicComputation symbolicComputation = SymbolicComputation::ReplaceAllDefinedSymbolsWithDefinition, UnitConversion unitConversion = UnitConversion::Default) : + ComputationContext( + Context * context, + Preferences::ComplexFormat complexFormat, + Preferences::AngleUnit angleUnit) : m_context(context), m_complexFormat(complexFormat), - m_angleUnit(angleUnit), + m_angleUnit(angleUnit) + {} + Context * context() { return m_context; } + void setContext(Context * context) { m_context = context; } + Preferences::ComplexFormat complexFormat() const { return m_complexFormat; } + Preferences::AngleUnit angleUnit() const { return m_angleUnit; } + private: + Context * m_context; + Preferences::ComplexFormat m_complexFormat; + Preferences::AngleUnit m_angleUnit; + }; + + class ReductionContext : public ComputationContext { + public: + ReductionContext(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, Preferences::UnitFormat unitFormat, ReductionTarget target, SymbolicComputation symbolicComputation = SymbolicComputation::ReplaceAllDefinedSymbolsWithDefinition, UnitConversion unitConversion = UnitConversion::Default) : + ComputationContext(context, complexFormat, angleUnit), m_unitFormat(unitFormat), m_target(target), m_symbolicComputation(symbolicComputation), m_unitConversion(unitConversion) {} - Context * context() { return m_context; } - Preferences::ComplexFormat complexFormat() const { return m_complexFormat; } - Preferences::AngleUnit angleUnit() const { return m_angleUnit; } Preferences::UnitFormat unitFormat() const { return m_unitFormat; } ReductionTarget target() const { return m_target; } SymbolicComputation symbolicComputation() const { return m_symbolicComputation; } UnitConversion unitConversion() const { return m_unitConversion; } private: - Context * m_context; - Preferences::ComplexFormat m_complexFormat; - Preferences::AngleUnit m_angleUnit; Preferences::UnitFormat m_unitFormat; ReductionTarget m_target; SymbolicComputation m_symbolicComputation; UnitConversion m_unitConversion; }; - class ApproximationContext { + class ApproximationContext : public ComputationContext { public: ApproximationContext( Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, bool withinReduce = false) : - m_context(context), - m_complexFormat(complexFormat), - m_angleUnit(angleUnit), + ComputationContext(context, complexFormat, angleUnit), m_withinReduce(withinReduce) {} - Context * context() { return m_context; } - Preferences::ComplexFormat complexFormat() const { return m_complexFormat; } - Preferences::AngleUnit angleUnit() const { return m_angleUnit; } + ApproximationContext(ReductionContext reductionContext, bool withinReduce) : + ApproximationContext(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), withinReduce) {} bool withinReduce() const { return m_withinReduce; } private: - Context * m_context; - Preferences::ComplexFormat m_complexFormat; - Preferences::AngleUnit m_angleUnit; bool m_withinReduce; }; diff --git a/poincare/include/poincare/factor.h b/poincare/include/poincare/factor.h index d899399ba..3e16af3ab 100644 --- a/poincare/include/poincare/factor.h +++ b/poincare/include/poincare/factor.h @@ -33,9 +33,9 @@ private: LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } /* Evaluation */ - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Factor final : public Expression { @@ -45,7 +45,7 @@ public: static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("factor", 1, &UntypedBuilderOneChild); - Multiplication createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Multiplication createMultiplicationOfIntegerPrimeDecomposition(Integer i) const; // Expression Expression shallowReduce(Context * context); diff --git a/poincare/include/poincare/factorial.h b/poincare/include/poincare/factorial.h index 10ed3373f..2720bb8ff 100644 --- a/poincare/include/poincare/factorial.h +++ b/poincare/include/poincare/factorial.h @@ -37,11 +37,11 @@ private: // Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } #if 0 diff --git a/poincare/include/poincare/float.h b/poincare/include/poincare/float.h index fce3cc20e..1c08efe3b 100644 --- a/poincare/include/poincare/float.h +++ b/poincare/include/poincare/float.h @@ -47,13 +47,13 @@ public: /* Layout */ Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Evaluation */ - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } private: // Simplification LayoutShape leftLayoutShape() const override { return LayoutShape::Decimal; } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { + template Evaluation templatedApproximate(ApproximationContext approximationContext) const { return Complex::Builder((U)m_value); } T m_value; diff --git a/poincare/include/poincare/floor.h b/poincare/include/poincare/floor.h index fee31eb69..d2a097a81 100644 --- a/poincare/include/poincare/floor.h +++ b/poincare/include/poincare/floor.h @@ -32,11 +32,11 @@ private: // Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/frac_part.h b/poincare/include/poincare/frac_part.h index 63745f56f..f9ae55cb6 100644 --- a/poincare/include/poincare/frac_part.h +++ b/poincare/include/poincare/frac_part.h @@ -33,11 +33,11 @@ private: // Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/function.h b/poincare/include/poincare/function.h index e1e4a8399..24ffa6d4b 100644 --- a/poincare/include/poincare/function.h +++ b/poincare/include/poincare/function.h @@ -42,9 +42,9 @@ private: LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override; - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override; - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override; + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override; + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Function : public SymbolAbstract { diff --git a/poincare/include/poincare/great_common_divisor.h b/poincare/include/poincare/great_common_divisor.h index 62346b6f8..28a4665a7 100644 --- a/poincare/include/poincare/great_common_divisor.h +++ b/poincare/include/poincare/great_common_divisor.h @@ -30,9 +30,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class GreatCommonDivisor final : public NAryExpression { diff --git a/poincare/include/poincare/hyperbolic_arc_cosine.h b/poincare/include/poincare/hyperbolic_arc_cosine.h index 16db5644c..0647ec030 100644 --- a/poincare/include/poincare/hyperbolic_arc_cosine.h +++ b/poincare/include/poincare/hyperbolic_arc_cosine.h @@ -27,11 +27,11 @@ private: int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; //Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_arc_sine.h b/poincare/include/poincare/hyperbolic_arc_sine.h index 91fba959e..b3a98bcc8 100644 --- a/poincare/include/poincare/hyperbolic_arc_sine.h +++ b/poincare/include/poincare/hyperbolic_arc_sine.h @@ -25,11 +25,11 @@ private: int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; //Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_arc_tangent.h b/poincare/include/poincare/hyperbolic_arc_tangent.h index fada17c7b..496e29228 100644 --- a/poincare/include/poincare/hyperbolic_arc_tangent.h +++ b/poincare/include/poincare/hyperbolic_arc_tangent.h @@ -25,11 +25,11 @@ private: int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; //Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_cosine.h b/poincare/include/poincare/hyperbolic_cosine.h index 0e50b8327..c33368fd0 100644 --- a/poincare/include/poincare/hyperbolic_cosine.h +++ b/poincare/include/poincare/hyperbolic_cosine.h @@ -30,11 +30,11 @@ private: Expression unaryFunctionDifferential() override; //Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_sine.h b/poincare/include/poincare/hyperbolic_sine.h index 47f0b00c9..408eae86d 100644 --- a/poincare/include/poincare/hyperbolic_sine.h +++ b/poincare/include/poincare/hyperbolic_sine.h @@ -28,11 +28,11 @@ private: Expression unaryFunctionDifferential() override; //Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_tangent.h b/poincare/include/poincare/hyperbolic_tangent.h index 36db08f5d..4b1fa04bc 100644 --- a/poincare/include/poincare/hyperbolic_tangent.h +++ b/poincare/include/poincare/hyperbolic_tangent.h @@ -28,11 +28,11 @@ private: Expression unaryFunctionDifferential() override; //Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/imaginary_part.h b/poincare/include/poincare/imaginary_part.h index f43de3ee0..373f93a34 100644 --- a/poincare/include/poincare/imaginary_part.h +++ b/poincare/include/poincare/imaginary_part.h @@ -34,11 +34,11 @@ private: template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { return Complex::Builder(std::imag(c)); } - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/infinity.h b/poincare/include/poincare/infinity.h index 3936a3267..b4d6aa02c 100644 --- a/poincare/include/poincare/infinity.h +++ b/poincare/include/poincare/infinity.h @@ -27,10 +27,10 @@ public: Expression setSign(Sign s, ReductionContext reductionContext) override; // Approximation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(); } diff --git a/poincare/include/poincare/integral.h b/poincare/include/poincare/integral.h index 164724341..c72001801 100644 --- a/poincare/include/poincare/integral.h +++ b/poincare/include/poincare/integral.h @@ -31,9 +31,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }; LayoutShape rightLayoutShape() const override { return LayoutShape::MoreLetters; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; template struct DetailedResult { @@ -44,10 +44,10 @@ private: #ifdef LAGRANGE_METHOD template T lagrangeGaussQuadrature(T a, T b, Context Context * context, Preferences::AngleUnit angleUnit context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; #else - template DetailedResult kronrodGaussQuadrature(T a, T b, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; - template T adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + template DetailedResult kronrodGaussQuadrature(T a, T b, ApproximationContext approximationContext) const; + template T adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, ApproximationContext approximationContext) const; #endif - template T functionValueAtAbscissa(T x, Context * xcontext, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + template T functionValueAtAbscissa(T x, ApproximationContext approximationContext) const; }; class Integral final : public ParameteredExpression { diff --git a/poincare/include/poincare/inv_binom.h b/poincare/include/poincare/inv_binom.h index e4f30699b..229aa982c 100644 --- a/poincare/include/poincare/inv_binom.h +++ b/poincare/include/poincare/inv_binom.h @@ -30,9 +30,9 @@ private: Expression shallowReduce(ReductionContext reductionContext) override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class InvBinom final : public BinomialDistributionFunction { diff --git a/poincare/include/poincare/inv_norm.h b/poincare/include/poincare/inv_norm.h index dc27eadf7..981a01882 100644 --- a/poincare/include/poincare/inv_norm.h +++ b/poincare/include/poincare/inv_norm.h @@ -30,9 +30,9 @@ private: Expression shallowReduce(ReductionContext reductionContext) override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class InvNorm final : public NormalDistributionFunction { diff --git a/poincare/include/poincare/least_common_multiple.h b/poincare/include/poincare/least_common_multiple.h index f73dc7e13..10545e171 100644 --- a/poincare/include/poincare/least_common_multiple.h +++ b/poincare/include/poincare/least_common_multiple.h @@ -30,9 +30,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class LeastCommonMultiple final : public NAryExpression { diff --git a/poincare/include/poincare/logarithm.h b/poincare/include/poincare/logarithm.h index 1c0ab9ede..f56f740d0 100644 --- a/poincare/include/poincare/logarithm.h +++ b/poincare/include/poincare/logarithm.h @@ -42,9 +42,9 @@ public: * (warning: log takes the other side of the cut values on ]-inf-0i, 0-0i]). */ return Complex::Builder(std::log10(c)); } - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Logarithm final : public Expression { @@ -61,7 +61,7 @@ public: private: void deepReduceChildren(ExpressionNode::ReductionContext reductionContext); - Expression simpleShallowReduce(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); + Expression simpleShallowReduce(ExpressionNode::ReductionContext reductionContext); Integer simplifyLogarithmIntegerBaseInteger(Integer i, Integer & base, Addition & a, bool isDenominator); Expression splitLogarithmInteger(Integer i, bool isDenominator, ExpressionNode::ReductionContext reductionContext); bool parentIsAPowerOfSameBase() const; diff --git a/poincare/include/poincare/matrix.h b/poincare/include/poincare/matrix.h index 25456b7fd..35ef39629 100644 --- a/poincare/include/poincare/matrix.h +++ b/poincare/include/poincare/matrix.h @@ -40,18 +40,18 @@ public: Expression shallowReduce(ReductionContext reductionContext) override; // Approximation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return templatedApproximate(context, complexFormat, angleUnit); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return templatedApproximate(approximationContext); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return templatedApproximate(context, complexFormat, angleUnit); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return templatedApproximate(approximationContext); } // Layout Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode = Preferences::PrintFloatMode::Decimal, int numberOfSignificantDigits = 0) const override; private: - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; /* We could store 2 uint8_t but multiplying m_numberOfRows and * m_numberOfColumns could then lead to overflow. As we are unlikely to use * greater matrix than 100*100, uint16_t is fine. */ diff --git a/poincare/include/poincare/matrix_dimension.h b/poincare/include/poincare/matrix_dimension.h index 579ddd890..7fbb30af3 100644 --- a/poincare/include/poincare/matrix_dimension.h +++ b/poincare/include/poincare/matrix_dimension.h @@ -29,9 +29,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class MatrixDimension final : public Expression { diff --git a/poincare/include/poincare/matrix_echelon_form.h b/poincare/include/poincare/matrix_echelon_form.h index cda533715..1dac327d9 100644 --- a/poincare/include/poincare/matrix_echelon_form.h +++ b/poincare/include/poincare/matrix_echelon_form.h @@ -21,9 +21,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; // Properties virtual const char * functionHelperName() const = 0; diff --git a/poincare/include/poincare/matrix_identity.h b/poincare/include/poincare/matrix_identity.h index 775542289..d9a0a1ea1 100644 --- a/poincare/include/poincare/matrix_identity.h +++ b/poincare/include/poincare/matrix_identity.h @@ -27,9 +27,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class MatrixIdentity final : public Expression { diff --git a/poincare/include/poincare/matrix_inverse.h b/poincare/include/poincare/matrix_inverse.h index dff666e1a..4eae80e32 100644 --- a/poincare/include/poincare/matrix_inverse.h +++ b/poincare/include/poincare/matrix_inverse.h @@ -28,9 +28,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class MatrixInverse final : public Expression { diff --git a/poincare/include/poincare/matrix_trace.h b/poincare/include/poincare/matrix_trace.h index 6ff79e471..781ec702e 100644 --- a/poincare/include/poincare/matrix_trace.h +++ b/poincare/include/poincare/matrix_trace.h @@ -28,9 +28,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class MatrixTrace final : public Expression { diff --git a/poincare/include/poincare/matrix_transpose.h b/poincare/include/poincare/matrix_transpose.h index fc710e933..62a1e015f 100644 --- a/poincare/include/poincare/matrix_transpose.h +++ b/poincare/include/poincare/matrix_transpose.h @@ -28,9 +28,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class MatrixTranspose final : public Expression { diff --git a/poincare/include/poincare/multiplication.h b/poincare/include/poincare/multiplication.h index 2007f258b..452cfcb61 100644 --- a/poincare/include/poincare/multiplication.h +++ b/poincare/include/poincare/multiplication.h @@ -56,11 +56,11 @@ private: template static MatrixComplex computeOnMatrixAndComplex(const MatrixComplex m, const std::complex c, Preferences::ComplexFormat complexFormat) { return ApproximationHelper::ElementWiseOnMatrixComplexAndComplex(m, c, complexFormat, compute); } - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::MapReduce(this, context, complexFormat, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::MapReduce(this, approximationContext, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::MapReduce(this, context, complexFormat, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::MapReduce(this, approximationContext, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } }; diff --git a/poincare/include/poincare/naperian_logarithm.h b/poincare/include/poincare/naperian_logarithm.h index 6c10d3e3a..799c58596 100644 --- a/poincare/include/poincare/naperian_logarithm.h +++ b/poincare/include/poincare/naperian_logarithm.h @@ -35,11 +35,11 @@ private: * (warning: ln takes the other side of the cut values on ]-inf-0i, 0-0i]). */ return Complex::Builder(std::log(c)); } - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/norm_cdf.h b/poincare/include/poincare/norm_cdf.h index c0c113ce8..511786f2e 100644 --- a/poincare/include/poincare/norm_cdf.h +++ b/poincare/include/poincare/norm_cdf.h @@ -29,9 +29,9 @@ private: int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class NormCDF final : public NormalDistributionFunction { diff --git a/poincare/include/poincare/norm_cdf2.h b/poincare/include/poincare/norm_cdf2.h index 067663eb9..404d0fe68 100644 --- a/poincare/include/poincare/norm_cdf2.h +++ b/poincare/include/poincare/norm_cdf2.h @@ -31,9 +31,9 @@ private: int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class NormCDF2 final : public NormalDistributionFunction { diff --git a/poincare/include/poincare/norm_pdf.h b/poincare/include/poincare/norm_pdf.h index f9bd81648..ae9a2280f 100644 --- a/poincare/include/poincare/norm_pdf.h +++ b/poincare/include/poincare/norm_pdf.h @@ -29,9 +29,9 @@ private: int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class NormPDF final : public NormalDistributionFunction { diff --git a/poincare/include/poincare/nth_root.h b/poincare/include/poincare/nth_root.h index fbb729e9a..dc29c7525 100644 --- a/poincare/include/poincare/nth_root.h +++ b/poincare/include/poincare/nth_root.h @@ -29,9 +29,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::NthRoot; }; LayoutShape rightLayoutShape() const override { return LayoutShape::Root; }; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; diff --git a/poincare/include/poincare/opposite.h b/poincare/include/poincare/opposite.h index 441521a66..87352d211 100644 --- a/poincare/include/poincare/opposite.h +++ b/poincare/include/poincare/opposite.h @@ -30,11 +30,11 @@ public: bool childAtIndexNeedsUserParentheses(const Expression & child, int childIndex) const override; // Approximation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, compute); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, compute); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, compute); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, compute); } // Layout diff --git a/poincare/include/poincare/parenthesis.h b/poincare/include/poincare/parenthesis.h index f11810b5a..e2fcd0a51 100644 --- a/poincare/include/poincare/parenthesis.h +++ b/poincare/include/poincare/parenthesis.h @@ -33,10 +33,10 @@ public: LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }; // Approximation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } private: - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Parenthesis final : public Expression { diff --git a/poincare/include/poincare/permute_coefficient.h b/poincare/include/poincare/permute_coefficient.h index a2886babb..7af4d70de 100644 --- a/poincare/include/poincare/permute_coefficient.h +++ b/poincare/include/poincare/permute_coefficient.h @@ -33,9 +33,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class PermuteCoefficient final : public Expression { diff --git a/poincare/include/poincare/power.h b/poincare/include/poincare/power.h index 72c8d0404..c9a25279d 100644 --- a/poincare/include/poincare/power.h +++ b/poincare/include/poincare/power.h @@ -64,13 +64,13 @@ private: template static MatrixComplex computeOnComplexAndMatrix(const std::complex c, const MatrixComplex n, Preferences::ComplexFormat complexFormat); template static MatrixComplex computeOnMatrixAndComplex(const MatrixComplex m, const std::complex d, Preferences::ComplexFormat complexFormat); template static MatrixComplex computeOnMatrices(const MatrixComplex m, const MatrixComplex n, Preferences::ComplexFormat complexFormat); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return templatedApproximate(context, complexFormat, angleUnit); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return templatedApproximate(approximationContext); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return templatedApproximate(context, complexFormat, angleUnit); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return templatedApproximate(approximationContext); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Power final : public Expression { diff --git a/poincare/include/poincare/prediction_interval.h b/poincare/include/poincare/prediction_interval.h index 4691311b5..4ec7cdf58 100644 --- a/poincare/include/poincare/prediction_interval.h +++ b/poincare/include/poincare/prediction_interval.h @@ -31,9 +31,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class PredictionInterval final : public Expression { diff --git a/poincare/include/poincare/randint.h b/poincare/include/poincare/randint.h index e7091027c..af068d593 100644 --- a/poincare/include/poincare/randint.h +++ b/poincare/include/poincare/randint.h @@ -28,13 +28,13 @@ private: Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return templateApproximate(context, complexFormat, angleUnit); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return templateApproximate(approximationContext); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return templateApproximate(context, complexFormat, angleUnit); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return templateApproximate(approximationContext); } - template Evaluation templateApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, bool * inputIsUndefined = nullptr) const; + template Evaluation templateApproximate(ApproximationContext approximationContext, bool * inputIsUndefined = nullptr) const; // Simplification Expression shallowReduce(ReductionContext reductionContext) override; LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; diff --git a/poincare/include/poincare/random.h b/poincare/include/poincare/random.h index 712b421ab..c6a7dae9e 100644 --- a/poincare/include/poincare/random.h +++ b/poincare/include/poincare/random.h @@ -32,10 +32,10 @@ private: Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templateApproximate(); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templateApproximate(); } template Evaluation templateApproximate() const; diff --git a/poincare/include/poincare/rational.h b/poincare/include/poincare/rational.h index 43dce2300..9215e2e2a 100644 --- a/poincare/include/poincare/rational.h +++ b/poincare/include/poincare/rational.h @@ -39,8 +39,8 @@ public: Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // Approximation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return Complex::Builder(templatedApproximate()); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return Complex::Builder(templatedApproximate()); } + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return Complex::Builder(templatedApproximate()); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return Complex::Builder(templatedApproximate()); } template T templatedApproximate() const; // Basic test diff --git a/poincare/include/poincare/real_part.h b/poincare/include/poincare/real_part.h index b4a5c728e..1200cb9c6 100644 --- a/poincare/include/poincare/real_part.h +++ b/poincare/include/poincare/real_part.h @@ -36,11 +36,11 @@ private: template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { return Complex::Builder(std::real(c)); } - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/round.h b/poincare/include/poincare/round.h index 9de713c55..3e3dc5962 100644 --- a/poincare/include/poincare/round.h +++ b/poincare/include/poincare/round.h @@ -31,9 +31,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Round final : public Expression { diff --git a/poincare/include/poincare/sequence.h b/poincare/include/poincare/sequence.h index f2bd6ee55..a5e7656de 100644 --- a/poincare/include/poincare/sequence.h +++ b/poincare/include/poincare/sequence.h @@ -34,9 +34,9 @@ private: LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override; - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override; - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override; + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override; + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Sequence : public SymbolAbstract { diff --git a/poincare/include/poincare/sign_function.h b/poincare/include/poincare/sign_function.h index 968abf164..b8445938d 100644 --- a/poincare/include/poincare/sign_function.h +++ b/poincare/include/poincare/sign_function.h @@ -35,11 +35,11 @@ private: LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/sine.h b/poincare/include/poincare/sine.h index 4579180cc..1858479e8 100644 --- a/poincare/include/poincare/sine.h +++ b/poincare/include/poincare/sine.h @@ -39,11 +39,11 @@ private: Expression unaryFunctionDifferential() override; // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/square_root.h b/poincare/include/poincare/square_root.h index 45dfe0436..6f40f3f7b 100644 --- a/poincare/include/poincare/square_root.h +++ b/poincare/include/poincare/square_root.h @@ -32,11 +32,11 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::Root; }; // Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/store.h b/poincare/include/poincare/store.h index 5613c1e15..cc89d40ec 100644 --- a/poincare/include/poincare/store.h +++ b/poincare/include/poincare/store.h @@ -23,9 +23,9 @@ private: // Simplification Expression shallowReduce(ReductionContext reductionContext) override; // Evalutation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Store final : public Expression { @@ -48,7 +48,7 @@ public: Expression shallowReduce(ExpressionNode::ReductionContext reductionContext); private: - Expression storeValueForSymbol(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Expression storeValueForSymbol(Context * context) const; StoreNode * node() const { return static_cast(Expression::node()); } }; diff --git a/poincare/include/poincare/subtraction.h b/poincare/include/poincare/subtraction.h index 5ceeab30a..ed74653d2 100644 --- a/poincare/include/poincare/subtraction.h +++ b/poincare/include/poincare/subtraction.h @@ -28,11 +28,11 @@ public: // Approximation template static Complex compute(const std::complex c, const std::complex d, Preferences::ComplexFormat complexFormat) { return Complex::Builder(c - d); } - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::MapReduce(this, context, complexFormat, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::MapReduce(this, approximationContext, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::MapReduce(this, context, complexFormat, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::MapReduce(this, approximationContext, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } /* Layout */ diff --git a/poincare/include/poincare/sum_and_product.h b/poincare/include/poincare/sum_and_product.h index 63ea7a7b6..54f038bfe 100644 --- a/poincare/include/poincare/sum_and_product.h +++ b/poincare/include/poincare/sum_and_product.h @@ -17,9 +17,9 @@ private: Expression shallowReduce(ReductionContext reductionContext) override; LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }; /* Approximation */ - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; virtual float emptySumAndProductValue() const = 0; virtual Evaluation evaluateWithNextTerm(SinglePrecision p, Evaluation a, Evaluation b, Preferences::ComplexFormat complexFormat) const = 0; virtual Evaluation evaluateWithNextTerm(DoublePrecision p, Evaluation a, Evaluation b, Preferences::ComplexFormat complexFormat) const = 0; diff --git a/poincare/include/poincare/symbol.h b/poincare/include/poincare/symbol.h index ca0584799..4f18e6176 100644 --- a/poincare/include/poincare/symbol.h +++ b/poincare/include/poincare/symbol.h @@ -40,15 +40,15 @@ public: bool derivate(ReductionContext reductionContext, Expression symbol, Expression symbolValue) override; /* Approximation */ - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } bool isUnknown() const; private: char m_name[0]; // MUST be the last member variable size_t nodeSize() const override { return sizeof(SymbolNode); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class Symbol final : public SymbolAbstract { diff --git a/poincare/include/poincare/tangent.h b/poincare/include/poincare/tangent.h index 7bda46d97..b83d5171f 100644 --- a/poincare/include/poincare/tangent.h +++ b/poincare/include/poincare/tangent.h @@ -37,11 +37,11 @@ private: // Evaluation template static Complex computeOnComplex(const std::complex c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Radian); - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit,computeOnComplex); + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } }; diff --git a/poincare/include/poincare/undefined.h b/poincare/include/poincare/undefined.h index 0a4f34a7e..9a09fe95f 100644 --- a/poincare/include/poincare/undefined.h +++ b/poincare/include/poincare/undefined.h @@ -22,10 +22,10 @@ public: Expression setSign(Sign s, ReductionContext reductionContext) override; // Approximation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(); } diff --git a/poincare/include/poincare/unit.h b/poincare/include/poincare/unit.h index 77f63fd91..ded37f0b8 100644 --- a/poincare/include/poincare/unit.h +++ b/poincare/include/poincare/unit.h @@ -465,8 +465,8 @@ public: int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Approximation */ - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } // Comparison int simplificationOrderSameType(const ExpressionNode * e, bool ascending, bool canBeInterrupted, bool ignoreParentheses) const override; @@ -482,7 +482,7 @@ public: void setPrefix(const Prefix * prefix) { m_prefix = prefix; } private: - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; const Representative * m_representative; const Prefix * m_prefix; diff --git a/poincare/include/poincare/unit_convert.h b/poincare/include/poincare/unit_convert.h index 1a046500b..c4cccf592 100644 --- a/poincare/include/poincare/unit_convert.h +++ b/poincare/include/poincare/unit_convert.h @@ -25,9 +25,9 @@ private: void deepReduceChildren(ExpressionNode::ReductionContext reductionContext) override; Expression shallowBeautify(ReductionContext reductionContext) override; // Evalutation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class UnitConvert final : public Expression { diff --git a/poincare/include/poincare/unreal.h b/poincare/include/poincare/unreal.h index 8ab669aae..7e4290e3e 100644 --- a/poincare/include/poincare/unreal.h +++ b/poincare/include/poincare/unreal.h @@ -20,10 +20,10 @@ public: Type type() const override { return Type::Unreal; } // Approximation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(); } diff --git a/poincare/include/poincare/vector_cross.h b/poincare/include/poincare/vector_cross.h index c878ddb93..8969bd8b8 100644 --- a/poincare/include/poincare/vector_cross.h +++ b/poincare/include/poincare/vector_cross.h @@ -28,9 +28,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class VectorCross final : public Expression { diff --git a/poincare/include/poincare/vector_dot.h b/poincare/include/poincare/vector_dot.h index fe4a45fd5..25c1aa670 100644 --- a/poincare/include/poincare/vector_dot.h +++ b/poincare/include/poincare/vector_dot.h @@ -28,9 +28,9 @@ private: LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class VectorDot final : public Expression { diff --git a/poincare/include/poincare/vector_norm.h b/poincare/include/poincare/vector_norm.h index 0e0cf600f..10eae04f3 100644 --- a/poincare/include/poincare/vector_norm.h +++ b/poincare/include/poincare/vector_norm.h @@ -28,9 +28,9 @@ private: Expression shallowReduce(ReductionContext reductionContext) override; LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } // Evaluation - Evaluation approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - Evaluation approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate(context, complexFormat, angleUnit); } - template Evaluation templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + Evaluation approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + Evaluation approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate(approximationContext); } + template Evaluation templatedApproximate(ApproximationContext approximationContext) const; }; class VectorNorm final : public Expression { diff --git a/poincare/src/absolute_value.cpp b/poincare/src/absolute_value.cpp index dd37f3e1f..a6e112232 100644 --- a/poincare/src/absolute_value.cpp +++ b/poincare/src/absolute_value.cpp @@ -52,7 +52,7 @@ Expression AbsoluteValue::shallowReduce(ExpressionNode::ReductionContext reducti } // |x| = ±x if x is real if (c.isReal(reductionContext.context())) { - double app = c.node()->approximate(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), true).toScalar(); + double app = c.node()->approximate(double(), ExpressionNode::ApproximationContext(reductionContext, true)).toScalar(); if (!std::isnan(app)) { if ((c.isNumber() && app >= 0) || app >= Expression::Epsilon()) { /* abs(a) = a with a >= 0 diff --git a/poincare/src/approximation_helper.cpp b/poincare/src/approximation_helper.cpp index 8224024fa..77b924eb4 100644 --- a/poincare/src/approximation_helper.cpp +++ b/poincare/src/approximation_helper.cpp @@ -44,8 +44,8 @@ T ApproximationHelper::Epsilon() { return precision; } -template int ApproximationHelper::PositiveIntegerApproximationIfPossible(const ExpressionNode * expression, bool * isUndefined, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { - Evaluation evaluation = expression->approximate(T(), context, complexFormat, angleUnit); +template int ApproximationHelper::PositiveIntegerApproximationIfPossible(const ExpressionNode * expression, bool * isUndefined, ExpressionNode::ApproximationContext approximationContext) { + Evaluation evaluation = expression->approximate(T(), approximationContext); T scalar = evaluation.toScalar(); if (std::isnan(scalar) || scalar != (int)scalar) { *isUndefined = true; @@ -79,41 +79,41 @@ template std::complex ApproximationHelper::NeglectRealOrImaginar return result; } -template Evaluation ApproximationHelper::Map(const ExpressionNode * expression, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, ComplexCompute compute) { +template Evaluation ApproximationHelper::Map(const ExpressionNode * expression, ExpressionNode::ApproximationContext approximationContext, ComplexCompute compute) { assert(expression->numberOfChildren() == 1); - Evaluation input = expression->childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); + Evaluation input = expression->childAtIndex(0)->approximate(T(), approximationContext); if (input.type() == EvaluationNode::Type::Complex) { - return compute(static_cast &>(input).stdComplex(), complexFormat, angleUnit); + return compute(static_cast &>(input).stdComplex(), approximationContext.complexFormat(), approximationContext.angleUnit()); } else { assert(input.type() == EvaluationNode::Type::MatrixComplex); MatrixComplex m = static_cast &>(input); MatrixComplex result = MatrixComplex::Builder(); for (int i = 0; i < m.numberOfChildren(); i++) { - result.addChildAtIndexInPlace(compute(m.complexAtIndex(i), complexFormat, angleUnit), i, i); + result.addChildAtIndexInPlace(compute(m.complexAtIndex(i), approximationContext.complexFormat(), approximationContext.angleUnit()), i, i); } result.setDimensions(m.numberOfRows(), m.numberOfColumns()); return std::move(result); } } -template Evaluation ApproximationHelper::MapReduce(const ExpressionNode * expression, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, ComplexAndComplexReduction computeOnComplexes, ComplexAndMatrixReduction computeOnComplexAndMatrix, MatrixAndComplexReduction computeOnMatrixAndComplex, MatrixAndMatrixReduction computeOnMatrices) { +template Evaluation ApproximationHelper::MapReduce(const ExpressionNode * expression, ExpressionNode::ApproximationContext approximationContext, ComplexAndComplexReduction computeOnComplexes, ComplexAndMatrixReduction computeOnComplexAndMatrix, MatrixAndComplexReduction computeOnMatrixAndComplex, MatrixAndMatrixReduction computeOnMatrices) { assert(expression->numberOfChildren() > 0); - Evaluation result = expression->childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); + Evaluation result = expression->childAtIndex(0)->approximate(T(), approximationContext); for (int i = 1; i < expression->numberOfChildren(); i++) { Evaluation intermediateResult; - Evaluation nextOperandEvaluation = expression->childAtIndex(i)->approximate(T(), context, complexFormat, angleUnit); + Evaluation nextOperandEvaluation = expression->childAtIndex(i)->approximate(T(), approximationContext); if (result.type() == EvaluationNode::Type::Complex && nextOperandEvaluation.type() == EvaluationNode::Type::Complex) { - intermediateResult = computeOnComplexes(static_cast &>(result).stdComplex(), static_cast &>(nextOperandEvaluation).stdComplex(), complexFormat); + intermediateResult = computeOnComplexes(static_cast &>(result).stdComplex(), static_cast &>(nextOperandEvaluation).stdComplex(), approximationContext.complexFormat()); } else if (result.type() == EvaluationNode::Type::Complex) { assert(nextOperandEvaluation.type() == EvaluationNode::Type::MatrixComplex); - intermediateResult = computeOnComplexAndMatrix(static_cast &>(result).stdComplex(), static_cast &>(nextOperandEvaluation), complexFormat); + intermediateResult = computeOnComplexAndMatrix(static_cast &>(result).stdComplex(), static_cast &>(nextOperandEvaluation), approximationContext.complexFormat()); } else if (nextOperandEvaluation.type() == EvaluationNode::Type::Complex) { assert(result.type() == EvaluationNode::Type::MatrixComplex); - intermediateResult = computeOnMatrixAndComplex(static_cast &>(result), static_cast &>(nextOperandEvaluation).stdComplex(), complexFormat); + intermediateResult = computeOnMatrixAndComplex(static_cast &>(result), static_cast &>(nextOperandEvaluation).stdComplex(), approximationContext.complexFormat()); } else { assert(result.node()->type() == EvaluationNode::Type::MatrixComplex); assert(nextOperandEvaluation.node()->type() == EvaluationNode::Type::MatrixComplex); - intermediateResult = computeOnMatrices(static_cast &>(result), static_cast &>(nextOperandEvaluation), complexFormat); + intermediateResult = computeOnMatrices(static_cast &>(result), static_cast &>(nextOperandEvaluation), approximationContext.complexFormat()); } result = intermediateResult; if (result.isUndefined()) { @@ -145,14 +145,14 @@ template MatrixComplex ApproximationHelper::ElementWiseOnComplexM } template float Poincare::ApproximationHelper::Epsilon(); template double Poincare::ApproximationHelper::Epsilon(); -template int Poincare::ApproximationHelper::PositiveIntegerApproximationIfPossible(Poincare::ExpressionNode const*, bool*, Poincare::Context*, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit); -template int Poincare::ApproximationHelper::PositiveIntegerApproximationIfPossible(Poincare::ExpressionNode const*, bool*, Poincare::Context*, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit); +template int Poincare::ApproximationHelper::PositiveIntegerApproximationIfPossible(Poincare::ExpressionNode const*, bool*, ExpressionNode::ApproximationContext); +template int Poincare::ApproximationHelper::PositiveIntegerApproximationIfPossible(Poincare::ExpressionNode const*, bool*, ExpressionNode::ApproximationContext); template std::complex Poincare::ApproximationHelper::NeglectRealOrImaginaryPartIfNeglectable(std::complex,std::complex,std::complex,bool); template std::complex Poincare::ApproximationHelper::NeglectRealOrImaginaryPartIfNeglectable(std::complex,std::complex,std::complex,bool); -template Poincare::Evaluation Poincare::ApproximationHelper::Map(const Poincare::ExpressionNode * expression, Poincare::Context * context, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationHelper::ComplexCompute compute); -template Poincare::Evaluation Poincare::ApproximationHelper::Map(const Poincare::ExpressionNode * expression, Poincare::Context * context, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationHelper::ComplexCompute compute); -template Poincare::Evaluation Poincare::ApproximationHelper::MapReduce(const Poincare::ExpressionNode * expression, Poincare::Context * context, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationHelper::ComplexAndComplexReduction computeOnComplexes, Poincare::ApproximationHelper::ComplexAndMatrixReduction computeOnComplexAndMatrix, Poincare::ApproximationHelper::MatrixAndComplexReduction computeOnMatrixAndComplex, Poincare::ApproximationHelper::MatrixAndMatrixReduction computeOnMatrices); -template Poincare::Evaluation Poincare::ApproximationHelper::MapReduce(const Poincare::ExpressionNode * expression, Poincare::Context * context, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationHelper::ComplexAndComplexReduction computeOnComplexes, Poincare::ApproximationHelper::ComplexAndMatrixReduction computeOnComplexAndMatrix, Poincare::ApproximationHelper::MatrixAndComplexReduction computeOnMatrixAndComplex, Poincare::ApproximationHelper::MatrixAndMatrixReduction computeOnMatrices); +template Poincare::Evaluation Poincare::ApproximationHelper::Map(const Poincare::ExpressionNode * expression, ExpressionNode::ApproximationContext, Poincare::ApproximationHelper::ComplexCompute compute); +template Poincare::Evaluation Poincare::ApproximationHelper::Map(const Poincare::ExpressionNode * expression, ExpressionNode::ApproximationContext, Poincare::ApproximationHelper::ComplexCompute compute); +template Poincare::Evaluation Poincare::ApproximationHelper::MapReduce(const Poincare::ExpressionNode * expression, ExpressionNode::ApproximationContext, Poincare::ApproximationHelper::ComplexAndComplexReduction computeOnComplexes, Poincare::ApproximationHelper::ComplexAndMatrixReduction computeOnComplexAndMatrix, Poincare::ApproximationHelper::MatrixAndComplexReduction computeOnMatrixAndComplex, Poincare::ApproximationHelper::MatrixAndMatrixReduction computeOnMatrices); +template Poincare::Evaluation Poincare::ApproximationHelper::MapReduce(const Poincare::ExpressionNode * expression, ExpressionNode::ApproximationContext, Poincare::ApproximationHelper::ComplexAndComplexReduction computeOnComplexes, Poincare::ApproximationHelper::ComplexAndMatrixReduction computeOnComplexAndMatrix, Poincare::ApproximationHelper::MatrixAndComplexReduction computeOnMatrixAndComplex, Poincare::ApproximationHelper::MatrixAndMatrixReduction computeOnMatrices); template Poincare::MatrixComplex Poincare::ApproximationHelper::ElementWiseOnMatrixComplexAndComplex(const Poincare::MatrixComplex, const std::complex, Poincare::Preferences::ComplexFormat, Poincare::Complex (*)(std::complex, std::complex, Poincare::Preferences::ComplexFormat)); template Poincare::MatrixComplex Poincare::ApproximationHelper::ElementWiseOnMatrixComplexAndComplex(const Poincare::MatrixComplex, std::complex const, Poincare::Preferences::ComplexFormat, Poincare::Complex (*)(std::complex, std::complex, Poincare::Preferences::ComplexFormat)); template Poincare::MatrixComplex Poincare::ApproximationHelper::ElementWiseOnComplexMatrices(const Poincare::MatrixComplex, const Poincare::MatrixComplex, Poincare::Preferences::ComplexFormat, Poincare::Complex (*)(std::complex, std::complex, Poincare::Preferences::ComplexFormat)); diff --git a/poincare/src/arithmetic.cpp b/poincare/src/arithmetic.cpp index e65879385..79bbd7adf 100644 --- a/poincare/src/arithmetic.cpp +++ b/poincare/src/arithmetic.cpp @@ -109,15 +109,15 @@ Expression Arithmetic::LCM(const Expression & expression) { } template -Evaluation applyAssociativeFunctionOnChildren(const ExpressionNode & expressionNode, int (*f)(int, int), Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { +Evaluation applyAssociativeFunctionOnChildren(const ExpressionNode & expressionNode, int (*f)(int, int), ExpressionNode::ApproximationContext approximationContext) { /* Use function associativity to compute a function of expression's children. * The function can be GCD or LCM. */ bool isUndefined = false; // We define f(a) = f(a,a) = a - int a = ApproximationHelper::PositiveIntegerApproximationIfPossible(expressionNode.childAtIndex(0), &isUndefined, context, complexFormat, angleUnit); + int a = ApproximationHelper::PositiveIntegerApproximationIfPossible(expressionNode.childAtIndex(0), &isUndefined, approximationContext); // f is associative, f(a,b,c,d) = f(f(f(a,b),c),d) for (int i = 1; i < expressionNode.numberOfChildren(); ++i) { - int b = ApproximationHelper::PositiveIntegerApproximationIfPossible(expressionNode.childAtIndex(i), &isUndefined, context, complexFormat, angleUnit); + int b = ApproximationHelper::PositiveIntegerApproximationIfPossible(expressionNode.childAtIndex(i), &isUndefined, approximationContext); if (isUndefined) { return Complex::RealUndefined(); } @@ -127,15 +127,15 @@ Evaluation applyAssociativeFunctionOnChildren(const ExpressionNode & expressi } template -Evaluation Arithmetic::GCD(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { +Evaluation Arithmetic::GCD(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext) { // Evaluate GCD of expression's children - return applyAssociativeFunctionOnChildren(expressionNode, Arithmetic::GCD, context, complexFormat, angleUnit); + return applyAssociativeFunctionOnChildren(expressionNode, Arithmetic::GCD, approximationContext); } template -Evaluation Arithmetic::LCM(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { +Evaluation Arithmetic::LCM(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext) { // Evaluate LCM of expression's children - return applyAssociativeFunctionOnChildren(expressionNode, Arithmetic::LCM, context, complexFormat, angleUnit); + return applyAssociativeFunctionOnChildren(expressionNode, Arithmetic::LCM, approximationContext); } const short primeFactors[Arithmetic::k_numberOfPrimeFactors] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, @@ -200,9 +200,9 @@ int Arithmetic::PrimeFactorization(const Integer & n, Integer outputFactors[], I return t+1; } -template Evaluation Arithmetic::GCD(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); -template Evaluation Arithmetic::GCD(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); -template Evaluation Arithmetic::LCM(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); -template Evaluation Arithmetic::LCM(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); +template Evaluation Arithmetic::GCD(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext); +template Evaluation Arithmetic::GCD(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext); +template Evaluation Arithmetic::LCM(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext); +template Evaluation Arithmetic::LCM(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext); } diff --git a/poincare/src/binom_cdf.cpp b/poincare/src/binom_cdf.cpp index 43e8d87f9..7a83ebf5b 100644 --- a/poincare/src/binom_cdf.cpp +++ b/poincare/src/binom_cdf.cpp @@ -24,10 +24,10 @@ int BinomCDFNode::serialize(char * buffer, int bufferSize, Preferences::PrintFlo } template -Evaluation BinomCDFNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation xEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation nEvaluation = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); - Evaluation pEvaluation = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); +Evaluation BinomCDFNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation xEvaluation = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation nEvaluation = childAtIndex(1)->approximate(T(), approximationContext); + Evaluation pEvaluation = childAtIndex(2)->approximate(T(), approximationContext); const T x = xEvaluation.toScalar(); const T n = nEvaluation.toScalar(); diff --git a/poincare/src/binom_pdf.cpp b/poincare/src/binom_pdf.cpp index 12305f0bb..f285721d0 100644 --- a/poincare/src/binom_pdf.cpp +++ b/poincare/src/binom_pdf.cpp @@ -24,10 +24,10 @@ int BinomPDFNode::serialize(char * buffer, int bufferSize, Preferences::PrintFlo } template -Evaluation BinomPDFNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation xEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation nEvaluation = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); - Evaluation pEvaluation = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); +Evaluation BinomPDFNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation xEvaluation = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation nEvaluation = childAtIndex(1)->approximate(T(), approximationContext); + Evaluation pEvaluation = childAtIndex(2)->approximate(T(), approximationContext); T x = xEvaluation.toScalar(); T n = nEvaluation.toScalar(); diff --git a/poincare/src/binomial_coefficient.cpp b/poincare/src/binomial_coefficient.cpp index a14ef2029..0cdf5208a 100644 --- a/poincare/src/binomial_coefficient.cpp +++ b/poincare/src/binomial_coefficient.cpp @@ -30,9 +30,9 @@ int BinomialCoefficientNode::serialize(char * buffer, int bufferSize, Preference } template -Complex BinomialCoefficientNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation nInput = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation kInput = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Complex BinomialCoefficientNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation nInput = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation kInput = childAtIndex(1)->approximate(T(), approximationContext); T n = nInput.toScalar(); T k = kInput.toScalar(); return Complex::Builder(compute(k, n)); diff --git a/poincare/src/complex_argument.cpp b/poincare/src/complex_argument.cpp index 02f258abc..2c761454b 100644 --- a/poincare/src/complex_argument.cpp +++ b/poincare/src/complex_argument.cpp @@ -51,7 +51,7 @@ Expression ComplexArgument::shallowReduce(ExpressionNode::ReductionContext reduc } bool real = c.isReal(reductionContext.context()); if (real) { - float app = c.node()->approximate(float(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), true).toScalar(); + float app = c.node()->approximate(float(), ExpressionNode::ApproximationContext(reductionContext, true)).toScalar(); if (!std::isnan(app) && app >= Expression::Epsilon()) { // arg(x) = 0 if x > 0 Expression result = Rational::Builder(0); diff --git a/poincare/src/complex_cartesian.cpp b/poincare/src/complex_cartesian.cpp index b02cd4199..c0dbf3e57 100644 --- a/poincare/src/complex_cartesian.cpp +++ b/poincare/src/complex_cartesian.cpp @@ -37,9 +37,9 @@ Expression ComplexCartesianNode::shallowBeautify(ReductionContext reductionConte } template -Complex ComplexCartesianNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation realEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation imagEvalution = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Complex ComplexCartesianNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation realEvaluation = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation imagEvalution = childAtIndex(1)->approximate(T(), approximationContext); assert(realEvaluation.type() == EvaluationNode::Type::Complex); assert(imagEvalution.type() == EvaluationNode::Type::Complex); std::complex a = static_cast &>(realEvaluation).stdComplex(); diff --git a/poincare/src/confidence_interval.cpp b/poincare/src/confidence_interval.cpp index 688cee557..c4d546f43 100644 --- a/poincare/src/confidence_interval.cpp +++ b/poincare/src/confidence_interval.cpp @@ -31,9 +31,9 @@ Expression ConfidenceIntervalNode::shallowReduce(ReductionContext reductionConte } template -Evaluation ConfidenceIntervalNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation fInput = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation nInput = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Evaluation ConfidenceIntervalNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation fInput = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation nInput = childAtIndex(1)->approximate(T(), approximationContext); T f = static_cast &>(fInput).toScalar(); T n = static_cast &>(nInput).toScalar(); if (std::isnan(f) || std::isnan(n) || n != (int)n || n < 0 || f < 0 || f > 1) { diff --git a/poincare/src/derivative.cpp b/poincare/src/derivative.cpp index aba4808b4..660d7b13b 100644 --- a/poincare/src/derivative.cpp +++ b/poincare/src/derivative.cpp @@ -40,10 +40,10 @@ Expression DerivativeNode::shallowReduce(ReductionContext reductionContext) { } template -Evaluation DerivativeNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation evaluationArgumentInput = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); +Evaluation DerivativeNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation evaluationArgumentInput = childAtIndex(2)->approximate(T(), approximationContext); T evaluationArgument = evaluationArgumentInput.toScalar(); - T functionValue = approximateWithArgument(evaluationArgument, context, complexFormat, angleUnit); + T functionValue = approximateWithArgument(evaluationArgument, approximationContext); // No complex/matrix version of Derivative if (std::isnan(evaluationArgument) || std::isnan(functionValue)) { return Complex::RealUndefined(); @@ -55,7 +55,7 @@ Evaluation DerivativeNode::templatedApproximate(Context * context, Preference static T tenEpsilon = sizeof(T) == sizeof(double) ? 10.0*DBL_EPSILON : 10.0f*FLT_EPSILON; do { T currentError; - T currentResult = riddersApproximation(context, complexFormat, angleUnit, evaluationArgument, h, ¤tError); + T currentResult = riddersApproximation(approximationContext, evaluationArgument, h, ¤tError); h /= (T)10.0; if (std::isnan(currentError) || currentError > error) { continue; @@ -83,23 +83,24 @@ Evaluation DerivativeNode::templatedApproximate(Context * context, Preference } template -T DerivativeNode::approximateWithArgument(T x, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +T DerivativeNode::approximateWithArgument(T x, ApproximationContext approximationContext) const { assert(childAtIndex(1)->type() == Type::Symbol); - VariableContext variableContext = VariableContext(static_cast(childAtIndex(1))->name(), context); + VariableContext variableContext = VariableContext(static_cast(childAtIndex(1))->name(), approximationContext.context()); variableContext.setApproximationForVariable(x); // Here we cannot use Expression::approximateWithValueForSymbol which would reset the sApproximationEncounteredComplex flag - return childAtIndex(0)->approximate(T(), &variableContext, complexFormat, angleUnit).toScalar(); + approximationContext.setContext(&variableContext); + return childAtIndex(0)->approximate(T(), approximationContext).toScalar(); } template -T DerivativeNode::growthRateAroundAbscissa(T x, T h, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - T expressionPlus = approximateWithArgument(x+h, context, complexFormat, angleUnit); - T expressionMinus = approximateWithArgument(x-h, context, complexFormat, angleUnit); +T DerivativeNode::growthRateAroundAbscissa(T x, T h, ApproximationContext approximationContext) const { + T expressionPlus = approximateWithArgument(x+h, approximationContext); + T expressionMinus = approximateWithArgument(x-h, approximationContext); return (expressionPlus - expressionMinus)/(h+h); } template -T DerivativeNode::riddersApproximation(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, T x, T h, T * error) const { +T DerivativeNode::riddersApproximation(ApproximationContext approximationContext, T x, T h, T * error) const { /* Ridders' Algorithm * Blibliography: * - Ridders, C.J.F. 1982, Advances in Helperering Software, vol. 4, no. 2, @@ -118,7 +119,7 @@ T DerivativeNode::riddersApproximation(Context * context, Preferences::ComplexFo a[i][j] = 1; } } - a[0][0] = growthRateAroundAbscissa(x, hh, context, complexFormat, angleUnit); + a[0][0] = growthRateAroundAbscissa(x, hh, approximationContext); T ans = 0; T errt = 0; // Loop on i: change the step size @@ -127,7 +128,7 @@ T DerivativeNode::riddersApproximation(Context * context, Preferences::ComplexFo // Make hh an exactly representable number volatile T temp = x+hh; hh = temp - x; - a[0][i] = growthRateAroundAbscissa(x, hh, context, complexFormat, angleUnit); + a[0][i] = growthRateAroundAbscissa(x, hh, approximationContext); T fac = k_rateStepSize*k_rateStepSize; // Loop on j: compute extrapolation for several orders for (int j = 1; j < 10; j++) { diff --git a/poincare/src/determinant.cpp b/poincare/src/determinant.cpp index f8b2e5c2d..cb8d588c2 100644 --- a/poincare/src/determinant.cpp +++ b/poincare/src/determinant.cpp @@ -26,8 +26,8 @@ int DeterminantNode::serialize(char * buffer, int bufferSize, Preferences::Print } template -Evaluation DeterminantNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation DeterminantNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input = childAtIndex(0)->approximate(T(), approximationContext); return Complex::Builder(input.determinant()); } diff --git a/poincare/src/division_quotient.cpp b/poincare/src/division_quotient.cpp index f081031de..8a57e3099 100644 --- a/poincare/src/division_quotient.cpp +++ b/poincare/src/division_quotient.cpp @@ -33,9 +33,9 @@ int DivisionQuotientNode::serialize(char * buffer, int bufferSize, Preferences:: } template -Evaluation DivisionQuotientNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation f1Input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation f2Input = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Evaluation DivisionQuotientNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation f1Input = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation f2Input = childAtIndex(1)->approximate(T(), approximationContext); T f1 = f1Input.toScalar(); T f2 = f2Input.toScalar(); if (std::isnan(f1) || std::isnan(f2) || f1 != (int)f1 || f2 != (int)f2) { diff --git a/poincare/src/division_remainder.cpp b/poincare/src/division_remainder.cpp index 842315fe1..99eb8c1dc 100644 --- a/poincare/src/division_remainder.cpp +++ b/poincare/src/division_remainder.cpp @@ -25,9 +25,9 @@ Expression DivisionRemainderNode::shallowReduce(ReductionContext reductionContex } template -Evaluation DivisionRemainderNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation f1Input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation f2Input = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Evaluation DivisionRemainderNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation f1Input = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation f2Input = childAtIndex(1)->approximate(T(), approximationContext); T f1 = f1Input.toScalar(); T f2 = f2Input.toScalar(); if (std::isnan(f1) || std::isnan(f2) || f1 != (int)f1 || f2 != (int)f2) { diff --git a/poincare/src/empty_expression.cpp b/poincare/src/empty_expression.cpp index a72775bff..d1fe21669 100644 --- a/poincare/src/empty_expression.cpp +++ b/poincare/src/empty_expression.cpp @@ -13,7 +13,7 @@ Layout EmptyExpressionNode::createLayout(Preferences::PrintFloatMode floatDispla return EmptyLayout::Builder(); } -template Evaluation EmptyExpressionNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +template Evaluation EmptyExpressionNode::templatedApproximate(ApproximationContext approximationContext) const { return Complex::Undefined(); } diff --git a/poincare/src/equal.cpp b/poincare/src/equal.cpp index 1d5091d88..4468a2e32 100644 --- a/poincare/src/equal.cpp +++ b/poincare/src/equal.cpp @@ -39,7 +39,7 @@ int EqualNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatM } template -Evaluation EqualNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +Evaluation EqualNode::templatedApproximate(ApproximationContext approximationContext) const { return Complex::Undefined(); } diff --git a/poincare/src/expression.cpp b/poincare/src/expression.cpp index fb57e0dd3..6154d7635 100644 --- a/poincare/src/expression.cpp +++ b/poincare/src/expression.cpp @@ -375,7 +375,7 @@ Expression Expression::defaultHandleUnitsInChildren() { } Expression Expression::shallowReduceUsingApproximation(ExpressionNode::ReductionContext reductionContext) { - double approx = node()->approximate(double(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), true).toScalar(); + double approx = node()->approximate(double(), ExpressionNode::ApproximationContext(reductionContext, true)).toScalar(); /* If approx is capped by the largest integer such as all smaller integers can * be exactly represented in IEEE754, approx is the exact result (no * precision were loss). */ @@ -449,7 +449,7 @@ Evaluation Expression::approximateToEvaluation(Context * context, Preferences sApproximationEncounteredComplex = false; // Reset interrupting flag because some evaluation methods use it sSimplificationHasBeenInterrupted = false; - Evaluation e = node()->approximate(U(), context, complexFormat, angleUnit, withinReduce); + Evaluation e = node()->approximate(U(), ExpressionNode::ApproximationContext(context, complexFormat, angleUnit, withinReduce)); if (complexFormat == Preferences::ComplexFormat::Real && sApproximationEncounteredComplex) { e = Complex::Undefined(); } @@ -1160,8 +1160,8 @@ template Expression Expression::approximate(Context * context, Preferenc template float Expression::approximateToScalar(Context * context, Preferences::ComplexFormat, Preferences::AngleUnit angleUnit, bool withinReduce) const; template double Expression::approximateToScalar(Context * context, Preferences::ComplexFormat, Preferences::AngleUnit angleUnit, bool withinReduce) const; -template float Expression::ApproximateToScalar(const char * text, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, Preferences::UnitFormat unitFormat, ExpressionNode::SymbolicComputation symbolicComputation, bool withinReduce); -template double Expression::ApproximateToScalar(const char * text, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, Preferences::UnitFormat unitFormat, ExpressionNode::SymbolicComputation symbolicComputation, bool withinReduce); +template float Expression::ApproximateToScalar(const char * text, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, Preferences::UnitFormat unitFormat, ExpressionNode::SymbolicComputation symbolicComputation); +template double Expression::ApproximateToScalar(const char * text, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, Preferences::UnitFormat unitFormat, ExpressionNode::SymbolicComputation symbolicComputation); template Evaluation Expression::approximateToEvaluation(Context * context, Preferences::ComplexFormat, Preferences::AngleUnit angleUnit, bool withinReduce) const; template Evaluation Expression::approximateToEvaluation(Context * context, Preferences::ComplexFormat, Preferences::AngleUnit angleUnit, bool withinReduce) const; diff --git a/poincare/src/factor.cpp b/poincare/src/factor.cpp index 85ee0adb5..bff8a70f6 100644 --- a/poincare/src/factor.cpp +++ b/poincare/src/factor.cpp @@ -37,8 +37,8 @@ Expression FactorNode::shallowBeautify(ReductionContext reductionContext) { // Add tests :) template -Evaluation FactorNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation e = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation FactorNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation e = childAtIndex(0)->approximate(T(), approximationContext); if (std::isnan(e.toScalar())) { return Complex::Undefined(); } @@ -46,7 +46,7 @@ Evaluation FactorNode::templatedApproximate(Context * context, Preferences::C } -Multiplication Factor::createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +Multiplication Factor::createMultiplicationOfIntegerPrimeDecomposition(Integer i) const { assert(!i.isZero()); assert(!i.isNegative()); Multiplication m = Multiplication::Builder(); @@ -95,13 +95,13 @@ Expression Factor::shallowBeautify(ExpressionNode::ReductionContext reductionCon replaceWithInPlace(r); return std::move(r); } - Multiplication numeratorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.unsignedIntegerNumerator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); + Multiplication numeratorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.unsignedIntegerNumerator()); if (numeratorDecomp.numberOfChildren() == 0) { return replaceWithUndefinedInPlace(); } Expression result = numeratorDecomp.squashUnaryHierarchyInPlace(); if (!r.isInteger()) { - Multiplication denominatorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.integerDenominator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); + Multiplication denominatorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.integerDenominator()); if (denominatorDecomp.numberOfChildren() == 0) { return replaceWithUndefinedInPlace(); } diff --git a/poincare/src/function.cpp b/poincare/src/function.cpp index 1d966416d..023a5ed0f 100644 --- a/poincare/src/function.cpp +++ b/poincare/src/function.cpp @@ -60,26 +60,26 @@ Expression FunctionNode::deepReplaceReplaceableSymbols(Context * context, bool * return Function(this).deepReplaceReplaceableSymbols(context, didReplace, replaceFunctionsOnly, parameteredAncestorsCount); } -Evaluation FunctionNode::approximate(SinglePrecision p, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - return templatedApproximate(context, complexFormat, angleUnit); +Evaluation FunctionNode::approximate(SinglePrecision p, ApproximationContext approximationContext) const { + return templatedApproximate(approximationContext); } -Evaluation FunctionNode::approximate(DoublePrecision p, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - return templatedApproximate(context, complexFormat, angleUnit); +Evaluation FunctionNode::approximate(DoublePrecision p, ApproximationContext approximationContext) const { + return templatedApproximate(approximationContext); } template -Evaluation FunctionNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - if (childAtIndex(0)->approximate((T)1, context, complexFormat, angleUnit).isUndefined()) { +Evaluation FunctionNode::templatedApproximate(ApproximationContext approximationContext) const { + if (childAtIndex(0)->approximate((T)1, approximationContext).isUndefined()) { return Complex::Undefined(); } Function f(this); - Expression e = SymbolAbstract::Expand(f, context, true); + Expression e = SymbolAbstract::Expand(f, approximationContext.context(), true); if (e.isUninitialized()) { return Complex::Undefined(); } - return e.node()->approximate(T(), context, complexFormat, angleUnit); + return e.node()->approximate(T(), approximationContext); } Function Function::Builder(const char * name, size_t length, Expression child) { diff --git a/poincare/src/great_common_divisor.cpp b/poincare/src/great_common_divisor.cpp index 51d6a6fcc..5641df6c1 100644 --- a/poincare/src/great_common_divisor.cpp +++ b/poincare/src/great_common_divisor.cpp @@ -24,8 +24,8 @@ Expression GreatCommonDivisorNode::shallowBeautify(ReductionContext reductionCon } template -Evaluation GreatCommonDivisorNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - return Arithmetic::GCD(*this, context, complexFormat, angleUnit); +Evaluation GreatCommonDivisorNode::templatedApproximate(ApproximationContext approximationContext) const { + return Arithmetic::GCD(*this, approximationContext); } Expression GreatCommonDivisor::shallowBeautify(Context * context) { @@ -64,7 +64,7 @@ Expression GreatCommonDivisor::shallowReduce(ExpressionNode::ReductionContext re return result; } -template Evaluation GreatCommonDivisorNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; -template Evaluation GreatCommonDivisorNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; +template Evaluation GreatCommonDivisorNode::templatedApproximate(ApproximationContext approximationContext) const; +template Evaluation GreatCommonDivisorNode::templatedApproximate(ApproximationContext approximationContext) const; } diff --git a/poincare/src/hyperbolic_trigonometric_function.cpp b/poincare/src/hyperbolic_trigonometric_function.cpp index 76dfa541f..34b635489 100644 --- a/poincare/src/hyperbolic_trigonometric_function.cpp +++ b/poincare/src/hyperbolic_trigonometric_function.cpp @@ -81,8 +81,8 @@ Expression HyperbolicTrigonometricFunction::shallowReduce(ExpressionNode::Reduct && std::fabs(e.approximateToScalar( reductionContext.context(), reductionContext.complexFormat(), - reductionContext.angleUnit()), - true) < 1.0)) + reductionContext.angleUnit(), + true)) < 1.0)) { result = e; } diff --git a/poincare/src/integral.cpp b/poincare/src/integral.cpp index 55641980a..7c4643855 100644 --- a/poincare/src/integral.cpp +++ b/poincare/src/integral.cpp @@ -44,35 +44,36 @@ Expression IntegralNode::shallowReduce(ReductionContext reductionContext) { } template -Evaluation IntegralNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation aInput = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); - Evaluation bInput = childAtIndex(3)->approximate(T(), context, complexFormat, angleUnit); +Evaluation IntegralNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation aInput = childAtIndex(2)->approximate(T(), approximationContext); + Evaluation bInput = childAtIndex(3)->approximate(T(), approximationContext); T a = aInput.toScalar(); T b = bInput.toScalar(); if (std::isnan(a) || std::isnan(b)) { return Complex::RealUndefined(); } #ifdef LAGRANGE_METHOD - T result = lagrangeGaussQuadrature(a, b, context, complexFormat, angleUnit); + T result = lagrangeGaussQuadrature(a, b, approximationContext); #else - T result = adaptiveQuadrature(a, b, 0.1, k_maxNumberOfIterations, context, complexFormat, angleUnit); + T result = adaptiveQuadrature(a, b, 0.1, k_maxNumberOfIterations, approximationContext); #endif return Complex::Builder(result); } template -T IntegralNode::functionValueAtAbscissa(T x, Context * xcontext, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +T IntegralNode::functionValueAtAbscissa(T x, ApproximationContext approximationContext) const { // Here we cannot use Expression::approximateWithValueForSymbol which would reset the sApproximationEncounteredComplex flag assert(childAtIndex(1)->type() == Type::Symbol); - VariableContext variableContext = VariableContext(static_cast(childAtIndex(1))->name(), xcontext); + VariableContext variableContext = VariableContext(static_cast(childAtIndex(1))->name(), approximationContext.context()); variableContext.setApproximationForVariable(x); - return childAtIndex(0)->approximate(T(), &variableContext, complexFormat, angleUnit).toScalar(); + approximationContext.setContext(&variableContext); + return childAtIndex(0)->approximate(T(), approximationContext).toScalar(); } #ifdef LAGRANGE_METHOD template -T IntegralNode::lagrangeGaussQuadrature(T a, T b, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +T IntegralNode::lagrangeGaussQuadrature(T a, T b, ApproximationContext approximationContext) const { /* We here use Gauss-Legendre quadrature with n = 5 * Gauss-Legendre abscissae and weights can be found in * C/C++ library source code. */ @@ -86,11 +87,11 @@ T IntegralNode::lagrangeGaussQuadrature(T a, T b, Context * context, Preferences T result = 0; for (int j = 0; j < 10; j++) { T dx = xr * x[j]; - T evaluationAfterX = functionValueAtAbscissa(xm+dx, context, complexFormat, angleUnit); + T evaluationAfterX = functionValueAtAbscissa(xm+dx, approximationContext); if (std::isnan(evaluationAfterX)) { return NAN; } - T evaluationBeforeX = functionValueAtAbscissa(xm-dx, context, complexFormat, angleUnit); + T evaluationBeforeX = functionValueAtAbscissa(xm-dx, approximationContext); if (std::isnan(evaluationBeforeX)) { return NAN; } @@ -103,7 +104,7 @@ T IntegralNode::lagrangeGaussQuadrature(T a, T b, Context * context, Preferences #else template -IntegralNode::DetailedResult IntegralNode::kronrodGaussQuadrature(T a, T b, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +IntegralNode::DetailedResult IntegralNode::kronrodGaussQuadrature(T a, T b, ApproximationContext approximationContext) const { static T epsilon = sizeof(T) == sizeof(double) ? DBL_EPSILON : FLT_EPSILON; static T max = sizeof(T) == sizeof(double) ? DBL_MAX : FLT_MAX; /* We here use Kronrod-Legendre quadrature with n = 21 @@ -137,7 +138,7 @@ IntegralNode::DetailedResult IntegralNode::kronrodGaussQuadrature(T a, T b, C errorResult.absoluteError = 0; T gaussIntegral = 0; - T fCenter = functionValueAtAbscissa(center, context, complexFormat, angleUnit); + T fCenter = functionValueAtAbscissa(center, approximationContext); if (std::isnan(fCenter)) { return errorResult; } @@ -145,11 +146,11 @@ IntegralNode::DetailedResult IntegralNode::kronrodGaussQuadrature(T a, T b, C T absKronrodIntegral = std::fabs(kronrodIntegral); for (int j = 0; j < 10; j++) { T xDelta = halfLength * x[j]; - T fval1 = functionValueAtAbscissa(center - xDelta, context, complexFormat, angleUnit); + T fval1 = functionValueAtAbscissa(center - xDelta, approximationContext); if (std::isnan(fval1)) { return errorResult; } - T fval2 = functionValueAtAbscissa(center + xDelta, context, complexFormat, angleUnit); + T fval2 = functionValueAtAbscissa(center + xDelta, approximationContext); if (std::isnan(fval2)) { return errorResult; } @@ -187,17 +188,17 @@ IntegralNode::DetailedResult IntegralNode::kronrodGaussQuadrature(T a, T b, C } template -T IntegralNode::adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +T IntegralNode::adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, ApproximationContext approximationContext) const { if (Expression::ShouldStopProcessing()) { return NAN; } - DetailedResult quadKG = kronrodGaussQuadrature(a, b, context, complexFormat, angleUnit); + DetailedResult quadKG = kronrodGaussQuadrature(a, b, approximationContext); T result = quadKG.integral; if (quadKG.absoluteError <= eps) { return result; } else if (--numberOfIterations > 0) { T m = (a+b)/2; - return adaptiveQuadrature(a, m, eps/2, numberOfIterations, context, complexFormat, angleUnit) + adaptiveQuadrature(m, b, eps/2, numberOfIterations, context, complexFormat, angleUnit); + return adaptiveQuadrature(a, m, eps/2, numberOfIterations, approximationContext) + adaptiveQuadrature(m, b, eps/2, numberOfIterations, approximationContext); } else { return NAN; } diff --git a/poincare/src/inv_binom.cpp b/poincare/src/inv_binom.cpp index 0b5cc6e7c..3e75b3e1c 100644 --- a/poincare/src/inv_binom.cpp +++ b/poincare/src/inv_binom.cpp @@ -26,10 +26,10 @@ Expression InvBinomNode::shallowReduce(ReductionContext reductionContext) { } template -Evaluation InvBinomNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation aEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation nEvaluation = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); - Evaluation pEvaluation = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); +Evaluation InvBinomNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation aEvaluation = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation nEvaluation = childAtIndex(1)->approximate(T(), approximationContext); + Evaluation pEvaluation = childAtIndex(2)->approximate(T(), approximationContext); T a = aEvaluation.toScalar(); T n = nEvaluation.toScalar(); diff --git a/poincare/src/inv_norm.cpp b/poincare/src/inv_norm.cpp index 1e1de3382..1fbbec3d7 100644 --- a/poincare/src/inv_norm.cpp +++ b/poincare/src/inv_norm.cpp @@ -26,10 +26,10 @@ Expression InvNormNode::shallowReduce(ReductionContext reductionContext) { } template -Evaluation InvNormNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation aEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation muEvaluation = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); - Evaluation sigmaEvaluation = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); +Evaluation InvNormNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation aEvaluation = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation muEvaluation = childAtIndex(1)->approximate(T(), approximationContext); + Evaluation sigmaEvaluation = childAtIndex(2)->approximate(T(), approximationContext); T a = aEvaluation.toScalar(); T mu = muEvaluation.toScalar(); diff --git a/poincare/src/least_common_multiple.cpp b/poincare/src/least_common_multiple.cpp index 6d49b02a4..6702aaac8 100644 --- a/poincare/src/least_common_multiple.cpp +++ b/poincare/src/least_common_multiple.cpp @@ -24,8 +24,8 @@ Expression LeastCommonMultipleNode::shallowBeautify(ReductionContext reductionCo } template -Evaluation LeastCommonMultipleNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - return Arithmetic::LCM(*this, context, complexFormat, angleUnit); +Evaluation LeastCommonMultipleNode::templatedApproximate(ApproximationContext approximationContext) const { + return Arithmetic::LCM(*this, approximationContext); } Expression LeastCommonMultiple::shallowBeautify(Context * context) { @@ -64,7 +64,7 @@ Expression LeastCommonMultiple::shallowReduce(ExpressionNode::ReductionContext r return result; } -template Evaluation LeastCommonMultipleNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; -template Evaluation LeastCommonMultipleNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; +template Evaluation LeastCommonMultipleNode::templatedApproximate(ApproximationContext approximationContext) const; +template Evaluation LeastCommonMultipleNode::templatedApproximate(ApproximationContext approximationContext) const; } diff --git a/poincare/src/logarithm.cpp b/poincare/src/logarithm.cpp index 1a093958a..bc9d96ad1 100644 --- a/poincare/src/logarithm.cpp +++ b/poincare/src/logarithm.cpp @@ -105,19 +105,19 @@ Expression LogarithmNode<2>::shallowBeautify(ReductionContext reductionContext) } template<> -template Evaluation LogarithmNode<1>::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - return ApproximationHelper::Map(this, context, complexFormat, angleUnit, computeOnComplex); +template Evaluation LogarithmNode<1>::templatedApproximate(ApproximationContext approximationContext) const { + return ApproximationHelper::Map(this, approximationContext, computeOnComplex); } template<> -template Evaluation LogarithmNode<2>::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation x = childAtIndex(0)->approximate(U(), context, complexFormat, angleUnit); - Evaluation n = childAtIndex(1)->approximate(U(), context, complexFormat, angleUnit); +template Evaluation LogarithmNode<2>::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation x = childAtIndex(0)->approximate(U(), approximationContext); + Evaluation n = childAtIndex(1)->approximate(U(), approximationContext); std::complex result = std::complex(NAN, NAN); if (x.type() == EvaluationNode::Type::Complex && n.type() == EvaluationNode::Type::Complex) { std::complex xc = (static_cast&>(x)).stdComplex(); std::complex nc = (static_cast&>(n)).stdComplex(); - result = DivisionNode::compute(computeOnComplex(xc, complexFormat, angleUnit).stdComplex(), computeOnComplex(nc, complexFormat, angleUnit).stdComplex(), complexFormat).stdComplex(); + result = DivisionNode::compute(computeOnComplex(xc, approximationContext.complexFormat(), approximationContext.angleUnit()).stdComplex(), computeOnComplex(nc, approximationContext.complexFormat(), approximationContext.angleUnit()).stdComplex(), approximationContext.complexFormat()).stdComplex(); } return Complex::Builder(result); } @@ -171,7 +171,7 @@ Expression Logarithm::shallowReduce(ExpressionNode::ReductionContext reductionCo } return *this; } - Expression f = simpleShallowReduce(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); + Expression f = simpleShallowReduce(reductionContext); if (f.type() != ExpressionNode::Type::Logarithm) { return f; } @@ -264,7 +264,7 @@ Expression Logarithm::shallowReduce(ExpressionNode::ReductionContext reductionCo return *this; } -Expression Logarithm::simpleShallowReduce(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { +Expression Logarithm::simpleShallowReduce(ExpressionNode::ReductionContext reductionContext) { Expression c = childAtIndex(0); Expression b = childAtIndex(1); // log(0,0)->Undefined @@ -275,7 +275,7 @@ Expression Logarithm::simpleShallowReduce(Context * context, Preferences::Comple if (b.type() == ExpressionNode::Type::Rational && static_cast(b).isOne()) { return replaceWithUndefinedInPlace(); } - bool infiniteArg = c.recursivelyMatches(Expression::IsInfinity, context); + bool infiniteArg = c.recursivelyMatches(Expression::IsInfinity, reductionContext.context()); // log(x,x)->1 with x != inf and log(inf,inf) = undef if (c.isIdenticalTo(b)) { Expression result = infiniteArg ? Undefined::Builder().convert() : Rational::Builder(1).convert(); @@ -293,14 +293,14 @@ Expression Logarithm::simpleShallowReduce(Context * context, Preferences::Comple const Rational r = static_cast(c); // log(0, x) = -inf if x > 1 && x != inf || inf x < 1 || undef if x < 0 if (r.isZero()) { - bool infiniteBase = b.recursivelyMatches(Expression::IsInfinity, context); + bool infiniteBase = b.recursivelyMatches(Expression::IsInfinity, reductionContext.context()); // Special case: log(0,inf) -> undef if (infiniteBase) { return replaceWithUndefinedInPlace(); } bool isNegative = true; Expression result; - Evaluation baseApproximation = b.node()->approximate(1.0f, context, complexFormat, angleUnit, true); + Evaluation baseApproximation = b.node()->approximate(1.0f, ExpressionNode::ApproximationContext(reductionContext, true)); std::complex logDenominator = std::log10(static_cast&>(baseApproximation).stdComplex()); if (logDenominator.imag() != 0.0f || logDenominator.real() == 0.0f) { result = Undefined::Builder(); @@ -401,7 +401,7 @@ Expression Logarithm::splitLogarithmInteger(Integer i, bool isDenominator, Expre Logarithm e = clone().convert(); e.replaceChildAtIndexInPlace(0, Rational::Builder(factors[index])); Multiplication m = Multiplication::Builder(Rational::Builder(coefficients[index]), e); - e.simpleShallowReduce(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); + e.simpleShallowReduce(reductionContext); a.addChildAtIndexInPlace(m, a.numberOfChildren(), a.numberOfChildren()); m.shallowReduce(reductionContext); } @@ -425,10 +425,10 @@ Expression Logarithm::shallowBeautify() { return *this; } -template Evaluation LogarithmNode<1>::templatedApproximate(Poincare::Context *, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit) const; -template Evaluation LogarithmNode<1>::templatedApproximate(Poincare::Context *, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit) const; -template Evaluation LogarithmNode<2>::templatedApproximate(Poincare::Context *, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit) const; -template Evaluation LogarithmNode<2>::templatedApproximate(Poincare::Context *, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit) const; +template Evaluation LogarithmNode<1>::templatedApproximate(ApproximationContext) const; +template Evaluation LogarithmNode<1>::templatedApproximate(ApproximationContext) const; +template Evaluation LogarithmNode<2>::templatedApproximate(ApproximationContext) const; +template Evaluation LogarithmNode<2>::templatedApproximate(ApproximationContext) const; template int LogarithmNode<1>::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const; template int LogarithmNode<2>::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const; diff --git a/poincare/src/matrix.cpp b/poincare/src/matrix.cpp index 8aa47751c..5dd9f56a0 100644 --- a/poincare/src/matrix.cpp +++ b/poincare/src/matrix.cpp @@ -99,10 +99,10 @@ int MatrixNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloat } template -Evaluation MatrixNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +Evaluation MatrixNode::templatedApproximate(ApproximationContext approximationContext) const { MatrixComplex matrix = MatrixComplex::Builder(); for (ExpressionNode * c : children()) { - matrix.addChildAtIndexInPlace(c->approximate(T(), context, complexFormat, angleUnit), matrix.numberOfChildren(), matrix.numberOfChildren()); + matrix.addChildAtIndexInPlace(c->approximate(T(), approximationContext), matrix.numberOfChildren(), matrix.numberOfChildren()); } matrix.setDimensions(numberOfRows(), numberOfColumns()); return std::move(matrix); diff --git a/poincare/src/matrix_dimension.cpp b/poincare/src/matrix_dimension.cpp index b6514bab8..aa294244a 100644 --- a/poincare/src/matrix_dimension.cpp +++ b/poincare/src/matrix_dimension.cpp @@ -26,8 +26,8 @@ int MatrixDimensionNode::serialize(char * buffer, int bufferSize, Preferences::P } template -Evaluation MatrixDimensionNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation MatrixDimensionNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input = childAtIndex(0)->approximate(T(), approximationContext); std::complex operands[2]; if (input.type() == EvaluationNode::Type::MatrixComplex) { operands[0] = std::complex(static_cast&>(input).numberOfRows()); diff --git a/poincare/src/matrix_echelon_form.cpp b/poincare/src/matrix_echelon_form.cpp index cffcad695..6f8eed893 100644 --- a/poincare/src/matrix_echelon_form.cpp +++ b/poincare/src/matrix_echelon_form.cpp @@ -21,8 +21,8 @@ int MatrixEchelonFormNode::serialize(char * buffer, int bufferSize, Preferences: } template -Evaluation MatrixEchelonFormNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation MatrixEchelonFormNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input = childAtIndex(0)->approximate(T(), approximationContext); Evaluation ref; if (input.type() == EvaluationNode::Type::MatrixComplex) { ref = static_cast&>(input).ref(isFormReduced()); diff --git a/poincare/src/matrix_identity.cpp b/poincare/src/matrix_identity.cpp index f9dd65b67..526e55576 100644 --- a/poincare/src/matrix_identity.cpp +++ b/poincare/src/matrix_identity.cpp @@ -28,8 +28,8 @@ int MatrixIdentityNode::serialize(char * buffer, int bufferSize, Preferences::Pr } template -Evaluation MatrixIdentityNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation MatrixIdentityNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input = childAtIndex(0)->approximate(T(), approximationContext); T r = input.toScalar(); // Undefined if the child is not real if (!std::isnan(r) && !std::isinf(r) && r > (T)0.0 // The child is defined and positive && std::ceil(r) == std::floor(r) // The child is an integer diff --git a/poincare/src/matrix_inverse.cpp b/poincare/src/matrix_inverse.cpp index ec994bb7c..bd7f79503 100644 --- a/poincare/src/matrix_inverse.cpp +++ b/poincare/src/matrix_inverse.cpp @@ -27,8 +27,8 @@ int MatrixInverseNode::serialize(char * buffer, int bufferSize, Preferences::Pri } template -Evaluation MatrixInverseNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation MatrixInverseNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input = childAtIndex(0)->approximate(T(), approximationContext); Evaluation inverse; if (input.type() == EvaluationNode::Type::MatrixComplex) { inverse = static_cast&>(input).inverse(); diff --git a/poincare/src/matrix_trace.cpp b/poincare/src/matrix_trace.cpp index f678e3bbe..427e6c528 100644 --- a/poincare/src/matrix_trace.cpp +++ b/poincare/src/matrix_trace.cpp @@ -27,8 +27,8 @@ int MatrixTraceNode::serialize(char * buffer, int bufferSize, Preferences::Print } template -Evaluation MatrixTraceNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation MatrixTraceNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input = childAtIndex(0)->approximate(T(), approximationContext); Complex result = Complex::Builder(input.trace()); return std::move(result); } diff --git a/poincare/src/matrix_transpose.cpp b/poincare/src/matrix_transpose.cpp index 8c7452b8b..ea6483868 100644 --- a/poincare/src/matrix_transpose.cpp +++ b/poincare/src/matrix_transpose.cpp @@ -25,8 +25,8 @@ int MatrixTransposeNode::serialize(char * buffer, int bufferSize, Preferences::P } template -Evaluation MatrixTransposeNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation MatrixTransposeNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input = childAtIndex(0)->approximate(T(), approximationContext); Evaluation transpose; if (input.type() == EvaluationNode::Type::MatrixComplex) { transpose = static_cast&>(input).transpose(); diff --git a/poincare/src/norm_cdf.cpp b/poincare/src/norm_cdf.cpp index 2775cc418..90b313524 100644 --- a/poincare/src/norm_cdf.cpp +++ b/poincare/src/norm_cdf.cpp @@ -24,10 +24,10 @@ int NormCDFNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloa } template -Evaluation NormCDFNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation aEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation muEvaluation = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); - Evaluation sigmaEvaluation = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); +Evaluation NormCDFNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation aEvaluation = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation muEvaluation = childAtIndex(1)->approximate(T(), approximationContext); + Evaluation sigmaEvaluation = childAtIndex(2)->approximate(T(), approximationContext); const T a = aEvaluation.toScalar(); const T mu = muEvaluation.toScalar(); diff --git a/poincare/src/norm_cdf2.cpp b/poincare/src/norm_cdf2.cpp index 625451406..a1cbb63e4 100644 --- a/poincare/src/norm_cdf2.cpp +++ b/poincare/src/norm_cdf2.cpp @@ -24,11 +24,11 @@ int NormCDF2Node::serialize(char * buffer, int bufferSize, Preferences::PrintFlo } template -Evaluation NormCDF2Node::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation aEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation bEvaluation = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); - Evaluation muEvaluation = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); - Evaluation sigmaEvaluation = childAtIndex(3)->approximate(T(), context, complexFormat, angleUnit); +Evaluation NormCDF2Node::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation aEvaluation = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation bEvaluation = childAtIndex(1)->approximate(T(), approximationContext); + Evaluation muEvaluation = childAtIndex(2)->approximate(T(), approximationContext); + Evaluation sigmaEvaluation = childAtIndex(3)->approximate(T(), approximationContext); T a = aEvaluation.toScalar(); T b = bEvaluation.toScalar(); diff --git a/poincare/src/norm_pdf.cpp b/poincare/src/norm_pdf.cpp index bb3ccee3f..5ab9011a8 100644 --- a/poincare/src/norm_pdf.cpp +++ b/poincare/src/norm_pdf.cpp @@ -24,10 +24,10 @@ int NormPDFNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloa } template -Evaluation NormPDFNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation xEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation muEvaluation = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); - Evaluation sigmaEvaluation = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); +Evaluation NormPDFNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation xEvaluation = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation muEvaluation = childAtIndex(1)->approximate(T(), approximationContext); + Evaluation sigmaEvaluation = childAtIndex(2)->approximate(T(), approximationContext); T x = xEvaluation.toScalar(); T mu = muEvaluation.toScalar(); diff --git a/poincare/src/nth_root.cpp b/poincare/src/nth_root.cpp index b5e63ca01..c1a8be9f6 100644 --- a/poincare/src/nth_root.cpp +++ b/poincare/src/nth_root.cpp @@ -34,9 +34,9 @@ Expression NthRootNode::shallowReduce(ReductionContext reductionContext) { } template -Evaluation NthRootNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation base = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation index = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Evaluation NthRootNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation base = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation index = childAtIndex(1)->approximate(T(), approximationContext); Complex result = Complex::Undefined(); if (base.type() == EvaluationNode::Type::Complex && index.type() == EvaluationNode::Type::Complex) @@ -46,14 +46,14 @@ Evaluation NthRootNode::templatedApproximate(Context * context, Preferences:: /* If the complexFormat is Real, we look for nthroot of form root(x,q) with * x real and q integer because they might have a real form which does not * correspond to the principale angle. */ - if (complexFormat == Preferences::ComplexFormat::Real && indexc.imag() == 0.0 && std::round(indexc.real()) == indexc.real()) { + if (approximationContext.complexFormat() == Preferences::ComplexFormat::Real && indexc.imag() == 0.0 && std::round(indexc.real()) == indexc.real()) { // root(x, q) with q integer and x real Complex result = PowerNode::computeNotPrincipalRealRootOfRationalPow(basec, (T)1.0, indexc.real()); if (!result.isUndefined()) { return std::move(result); } } - result = PowerNode::compute(basec, std::complex(1.0)/(indexc), complexFormat); + result = PowerNode::compute(basec, std::complex(1.0)/(indexc), approximationContext.complexFormat()); } return std::move(result); } diff --git a/poincare/src/parenthesis.cpp b/poincare/src/parenthesis.cpp index ca514b079..cd06aeb3b 100644 --- a/poincare/src/parenthesis.cpp +++ b/poincare/src/parenthesis.cpp @@ -21,8 +21,8 @@ Expression ParenthesisNode::shallowReduce(ReductionContext reductionContext) { } template -Evaluation ParenthesisNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - return childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation ParenthesisNode::templatedApproximate(ApproximationContext approximationContext) const { + return childAtIndex(0)->approximate(T(), approximationContext); } Expression Parenthesis::shallowReduce() { diff --git a/poincare/src/permute_coefficient.cpp b/poincare/src/permute_coefficient.cpp index 9207a1b1f..50121a188 100644 --- a/poincare/src/permute_coefficient.cpp +++ b/poincare/src/permute_coefficient.cpp @@ -28,9 +28,9 @@ Expression PermuteCoefficientNode::shallowReduce(ReductionContext reductionConte } template -Evaluation PermuteCoefficientNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation nInput = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation kInput = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Evaluation PermuteCoefficientNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation nInput = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation kInput = childAtIndex(1)->approximate(T(), approximationContext); T n = nInput.toScalar(); T k = kInput.toScalar(); if (std::isnan(n) || std::isnan(k) || n != std::round(n) || k != std::round(k) || n < 0.0f || k < 0.0f) { diff --git a/poincare/src/power.cpp b/poincare/src/power.cpp index 5a76875eb..6738c1d24 100644 --- a/poincare/src/power.cpp +++ b/poincare/src/power.cpp @@ -293,12 +293,12 @@ template MatrixComplex PowerNode::computeOnMatrices(const MatrixC return MatrixComplex::Undefined(); } -template Evaluation PowerNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +template Evaluation PowerNode::templatedApproximate(ApproximationContext approximationContext) const { /* Special case: c^(p/q) with p, q integers * In real mode, c^(p/q) might have a real root which is not the principal * root. We return this value in that case to avoid returning "unreal". */ - if (complexFormat == Preferences::ComplexFormat::Real) { - Evaluation base = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); + if (approximationContext.complexFormat() == Preferences::ComplexFormat::Real) { + Evaluation base = childAtIndex(0)->approximate(T(), approximationContext); if (base.type() != EvaluationNode::Type::Complex) { goto defaultApproximation; } @@ -334,7 +334,7 @@ template Evaluation PowerNode::templatedApproximate(Context * con } } defaultApproximation: - return ApproximationHelper::MapReduce(this, context, complexFormat, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); + return ApproximationHelper::MapReduce(this, approximationContext, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } // Power @@ -1393,9 +1393,9 @@ Expression Power::CreateComplexExponent(const Expression & r, ExpressionNode::Re #if 0 const Constant iComplex = Constant::Builder(UCodePointMathematicalBoldSmallI); const Constant pi = Constant::Builder(UCodePointGreekSmallLetterPi); - Expression op = Multiplication::Builder(pi, r).shallowReduce(context, complexFormat, angleUnit, false); - Cosine cos = Cosine(op).shallowReduce(context, complexFormat, angleUnit, false);; - Sine sin = Sine(op).shallowReduce(context, complexFormat, angleUnit, false); + Expression op = Multiplication::Builder(pi, r).shallowReduce(reductionContext, false); + Cosine cos = Cosine(op).shallowReduce(reductionContext, false);; + Sine sin = Sine(op).shallowReduce(reductionContext, false); Expression m = Multiplication::Builder(iComplex, sin); Expression a = Addition::Builder(cos, m); const Expression * multExpOperands[3] = {pi, r->clone()}; diff --git a/poincare/src/prediction_interval.cpp b/poincare/src/prediction_interval.cpp index 0893818e6..6aad86c95 100644 --- a/poincare/src/prediction_interval.cpp +++ b/poincare/src/prediction_interval.cpp @@ -31,9 +31,9 @@ Expression PredictionIntervalNode::shallowReduce(ReductionContext reductionConte } template -Evaluation PredictionIntervalNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation pInput = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation nInput = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Evaluation PredictionIntervalNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation pInput = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation nInput = childAtIndex(1)->approximate(T(), approximationContext); T p = static_cast &>(pInput).toScalar(); T n = static_cast &>(nInput).toScalar(); if (std::isnan(p) || std::isnan(n) || n != (int)n || n < 0 || p < 0 || p > 1) { diff --git a/poincare/src/randint.cpp b/poincare/src/randint.cpp index 52d15e7f9..16864410f 100644 --- a/poincare/src/randint.cpp +++ b/poincare/src/randint.cpp @@ -28,9 +28,9 @@ int RandintNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloa return SerializationHelper::Prefix(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, Randint::s_functionHelper.name()); } -template Evaluation RandintNode::templateApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, bool * inputIsUndefined) const { - Evaluation aInput = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation bInput = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +template Evaluation RandintNode::templateApproximate(ApproximationContext approximationContext, bool * inputIsUndefined) const { + Evaluation aInput = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation bInput = childAtIndex(1)->approximate(T(), approximationContext); if (inputIsUndefined) { *inputIsUndefined = aInput.isUndefined() || bInput.isUndefined(); } @@ -67,7 +67,7 @@ Expression Randint::shallowReduce(ExpressionNode::ReductionContext reductionCont return e; } bool inputIsUndefined = false; - double eval = static_cast(node())->templateApproximate(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), &inputIsUndefined).toScalar(); + double eval = static_cast(node())->templateApproximate(ExpressionNode::ApproximationContext(reductionContext, true), &inputIsUndefined).toScalar(); if (inputIsUndefined) { /* The input might be NAN because we are reducing a function's expression * which depends on x. We thus do not want to replace too early with diff --git a/poincare/src/round.cpp b/poincare/src/round.cpp index 8b370ca92..a5acc4aaf 100644 --- a/poincare/src/round.cpp +++ b/poincare/src/round.cpp @@ -27,9 +27,9 @@ Expression RoundNode::shallowReduce(ReductionContext reductionContext) { } template -Evaluation RoundNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation f1Input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation f2Input = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Evaluation RoundNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation f1Input = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation f2Input = childAtIndex(1)->approximate(T(), approximationContext); T f1 = f1Input.toScalar(); T f2 = f2Input.toScalar(); if (std::isnan(f2) || f2 != std::round(f2)) { diff --git a/poincare/src/sequence.cpp b/poincare/src/sequence.cpp index e6177bc19..82f2023aa 100644 --- a/poincare/src/sequence.cpp +++ b/poincare/src/sequence.cpp @@ -53,24 +53,24 @@ Expression SequenceNode::shallowReduce(ReductionContext reductionContext) { return Sequence(this).shallowReduce(reductionContext); } -Evaluation SequenceNode::approximate(SinglePrecision p, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - return templatedApproximate(context, complexFormat, angleUnit); +Evaluation SequenceNode::approximate(SinglePrecision p, ApproximationContext approximationContext) const { + return templatedApproximate(approximationContext); } -Evaluation SequenceNode::approximate(DoublePrecision p, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - return templatedApproximate(context, complexFormat, angleUnit); +Evaluation SequenceNode::approximate(DoublePrecision p, ApproximationContext approximationContext) const { + return templatedApproximate(approximationContext); } template -Evaluation SequenceNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - if (childAtIndex(0)->approximate((T)1, context, complexFormat, angleUnit).isUndefined()) { +Evaluation SequenceNode::templatedApproximate(ApproximationContext approximationContext) const { + if (childAtIndex(0)->approximate((T)1, approximationContext).isUndefined()) { return Complex::Undefined(); } - Expression e = context->expressionForSymbolAbstract(this, false); + Expression e = approximationContext.context()->expressionForSymbolAbstract(this, false); if (e.isUninitialized()) { return Complex::Undefined(); } - return e.node()->approximate(T(), context, complexFormat, angleUnit); + return e.node()->approximate(T(), approximationContext); } Sequence Sequence::Builder(const char * name, size_t length, Expression child) { diff --git a/poincare/src/sign_function.cpp b/poincare/src/sign_function.cpp index 69447828d..49bea3f6b 100644 --- a/poincare/src/sign_function.cpp +++ b/poincare/src/sign_function.cpp @@ -67,7 +67,7 @@ Expression SignFunction::shallowReduce(ExpressionNode::ReductionContext reductio if (s == ExpressionNode::Sign::Negative) { resultSign = Rational::Builder(-1); } else { - Evaluation childApproximated = child.node()->approximate(1.0f, reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), true); + Evaluation childApproximated = child.node()->approximate(1.0f, ExpressionNode::ApproximationContext(reductionContext, true)); assert(childApproximated.type() == EvaluationNode::Type::Complex); Complex c = static_cast&>(childApproximated); if (std::isnan(c.imag()) || std::isnan(c.real()) || c.imag() != 0) { diff --git a/poincare/src/store.cpp b/poincare/src/store.cpp index ddd1daa64..1c0d82aa8 100644 --- a/poincare/src/store.cpp +++ b/poincare/src/store.cpp @@ -14,18 +14,18 @@ Expression StoreNode::shallowReduce(ReductionContext reductionContext) { } template -Evaluation StoreNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +Evaluation StoreNode::templatedApproximate(ApproximationContext approximationContext) const { /* If we are here, it means that the store node was not shallowReduced. * Otherwise, it would have been replaced by its symbol. We thus have to * setExpressionForSymbolAbstract. */ - Expression storedExpression = Store(this).storeValueForSymbol(context, complexFormat, angleUnit); + Expression storedExpression = Store(this).storeValueForSymbol(approximationContext.context()); assert(!storedExpression.isUninitialized()); - return storedExpression.node()->approximate(T(), context, complexFormat, angleUnit); + return storedExpression.node()->approximate(T(), approximationContext); } Expression Store::shallowReduce(ExpressionNode::ReductionContext reductionContext) { // Store the expression. - Expression storedExpression = storeValueForSymbol(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); + Expression storedExpression = storeValueForSymbol(reductionContext.context()); if (symbol().type() == ExpressionNode::Type::Symbol) { /* If the symbol is not a function, we want to replace the store with its @@ -46,7 +46,7 @@ Expression Store::shallowReduce(ExpressionNode::ReductionContext reductionContex return storedExpression; } -Expression Store::storeValueForSymbol(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +Expression Store::storeValueForSymbol(Context * context) const { assert(!value().isUninitialized()); context->setExpressionForSymbolAbstract(value(), symbol()); Expression storedExpression = context->expressionForSymbolAbstract(symbol(), false); diff --git a/poincare/src/sum_and_product.cpp b/poincare/src/sum_and_product.cpp index c5f6cd5b3..2cf0f1f4f 100644 --- a/poincare/src/sum_and_product.cpp +++ b/poincare/src/sum_and_product.cpp @@ -24,16 +24,16 @@ Expression SumAndProductNode::shallowReduce(ReductionContext reductionContext) { } template -Evaluation SumAndProductNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation aInput = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); - Evaluation bInput = childAtIndex(3)->approximate(T(), context, complexFormat, angleUnit); +Evaluation SumAndProductNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation aInput = childAtIndex(2)->approximate(T(), approximationContext); + Evaluation bInput = childAtIndex(3)->approximate(T(), approximationContext); T start = aInput.toScalar(); T end = bInput.toScalar(); if (std::isnan(start) || std::isnan(end) || start != (int)start || end != (int)end || end - start > k_maxNumberOfSteps) { return Complex::Undefined(); } SymbolNode * symbol = static_cast(childAtIndex(1)); - VariableContext nContext = VariableContext(symbol->name(), context); + VariableContext nContext = VariableContext(symbol->name(), approximationContext.context()); Evaluation result = Complex::Builder((T)emptySumAndProductValue()); for (int i = (int)start; i <= (int)end; i++) { if (Expression::ShouldStopProcessing()) { @@ -47,7 +47,8 @@ Evaluation SumAndProductNode::templatedApproximate(Context * context, Prefere * have. We can then evaluate its value */ child.childAtIndex(0).replaceSymbolWithExpression(symbol, Float::Builder(i)); } - result = evaluateWithNextTerm(T(), result, child.node()->approximate(T(), &nContext, complexFormat, angleUnit), complexFormat); + approximationContext.setContext(&nContext); + result = evaluateWithNextTerm(T(), result, child.node()->approximate(T(), approximationContext), approximationContext.complexFormat()); if (result.isUndefined()) { return Complex::Undefined(); } @@ -70,7 +71,7 @@ Expression SumAndProduct::shallowReduce(Context * context) { return *this; } -template Evaluation SumAndProductNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; -template Evaluation SumAndProductNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; +template Evaluation SumAndProductNode::templatedApproximate(ApproximationContext approximationContext) const; +template Evaluation SumAndProductNode::templatedApproximate(ApproximationContext approximationContext) const; -} \ No newline at end of file +} diff --git a/poincare/src/symbol.cpp b/poincare/src/symbol.cpp index 29e0c28af..efa74e016 100644 --- a/poincare/src/symbol.cpp +++ b/poincare/src/symbol.cpp @@ -91,13 +91,13 @@ bool SymbolNode::derivate(ReductionContext reductionContext, Expression symbol, } template -Evaluation SymbolNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +Evaluation SymbolNode::templatedApproximate(ApproximationContext approximationContext) const { Symbol s(this); - Expression e = SymbolAbstract::Expand(s, context, false); + Expression e = SymbolAbstract::Expand(s, approximationContext.context(), false); if (e.isUninitialized()) { return Complex::Undefined(); } - return e.node()->approximate(T(), context, complexFormat, angleUnit); + return e.node()->approximate(T(), approximationContext); } bool SymbolNode::isUnknown() const { diff --git a/poincare/src/symbol_abstract.cpp b/poincare/src/symbol_abstract.cpp index 09b87aff0..c9127000f 100644 --- a/poincare/src/symbol_abstract.cpp +++ b/poincare/src/symbol_abstract.cpp @@ -20,7 +20,7 @@ size_t SymbolAbstractNode::size() const { ExpressionNode::Sign SymbolAbstractNode::sign(Context * context) const { SymbolAbstract s(this); - Expression e = SymbolAbstract::Expand(s, context, false); + Expression e = SymbolAbstract::Expand(s, context, true); if (e.isUninitialized()) { return Sign::Unknown; } diff --git a/poincare/src/trigonometry.cpp b/poincare/src/trigonometry.cpp index e0ff2bc93..51ccdce30 100644 --- a/poincare/src/trigonometry.cpp +++ b/poincare/src/trigonometry.cpp @@ -286,7 +286,7 @@ Expression Trigonometry::shallowReduceInverseFunction(Expression & e, Expression // Step 1. Look for an expression of type "acos(cos(x))", return x if (AreInverseFunctions(e.childAtIndex(0), e)) { - float x = e.childAtIndex(0).childAtIndex(0).nodex()->approximate(float(), reductionContext.context(), reductionContext.complexFormat(), angleUnit, true).toScalar(); + float x = e.childAtIndex(0).childAtIndex(0).node()->approximate(float(), ExpressionNode::ApproximationContext(reductionContext, true)).toScalar(); if (!(std::isinf(x) || std::isnan(x))) { Expression result = e.childAtIndex(0).childAtIndex(0); // We translate the result within [-π,π] for acos(cos), [-π/2,π/2] for asin(sin) and atan(tan) @@ -314,7 +314,7 @@ Expression Trigonometry::shallowReduceInverseFunction(Expression & e, Expression // Step 2. Special case for atan(sin(x)/cos(x)) if (e.type() == ExpressionNode::Type::ArcTangent && ExpressionIsEquivalentToTangent(e.childAtIndex(0))) { - float trigoOp = e.childAtIndex(0).childAtIndex(1).childAtIndex(0).node()->approximate(float(), reductionContext.context(), reductionContext.complexFormat(), angleUnit, true).toScalar(); + float trigoOp = e.childAtIndex(0).childAtIndex(1).childAtIndex(0).node()->approximate(float(), ExpressionNode::ApproximationContext(reductionContext, true)).toScalar(); if (trigoOp >= -pi/2.0f && trigoOp <= pi/2.0f) { Expression result = e.childAtIndex(0).childAtIndex(1).childAtIndex(0); e.replaceWithInPlace(result); diff --git a/poincare/src/trigonometry_cheat_table.cpp b/poincare/src/trigonometry_cheat_table.cpp index bcd1e2905..60515d6c5 100644 --- a/poincare/src/trigonometry_cheat_table.cpp +++ b/poincare/src/trigonometry_cheat_table.cpp @@ -59,7 +59,7 @@ Expression TrigonometryCheatTable::simplify(const Expression e, ExpressionNode:: } // Approximate e to quickly compare it to cheat table entries - float eValue = e.node()->approximation(float(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), true).toScalar(); + float eValue = e.node()->approximate(float(), ExpressionNode::ApproximationContext(reductionContext, true)).toScalar(); if (std::isnan(eValue) || std::isinf(eValue)) { return Expression(); } diff --git a/poincare/src/unit.cpp b/poincare/src/unit.cpp index d6d355da7..8ba9a1d9c 100644 --- a/poincare/src/unit.cpp +++ b/poincare/src/unit.cpp @@ -706,7 +706,7 @@ Expression UnitNode::shallowBeautify(ReductionContext reductionContext) { } template -Evaluation UnitNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +Evaluation UnitNode::templatedApproximate(ApproximationContext approximationContext) const { return Complex::Undefined(); } @@ -951,7 +951,7 @@ void Unit::chooseBestRepresentativeAndPrefix(double * value, double exponent, Ex } } -template Evaluation UnitNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; -template Evaluation UnitNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; +template Evaluation UnitNode::templatedApproximate(ApproximationContext approximationContext) const; +template Evaluation UnitNode::templatedApproximate(ApproximationContext approximationContext) const; } diff --git a/poincare/src/unit_convert.cpp b/poincare/src/unit_convert.cpp index c2984c386..9d5ea9309 100644 --- a/poincare/src/unit_convert.cpp +++ b/poincare/src/unit_convert.cpp @@ -29,7 +29,7 @@ void UnitConvertNode::deepReduceChildren(ExpressionNode::ReductionContext reduct } template -Evaluation UnitConvertNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +Evaluation UnitConvertNode::templatedApproximate(ApproximationContext approximationContext) const { /* If we are here, it means that the unit convert node was not shallowReduced. * Otherwise, it would have been replaced by the division of the value by the * unit. We thus return Undefined. */ @@ -109,7 +109,7 @@ Expression UnitConvert::shallowBeautify(ExpressionNode::ReductionContext reducti return result.shallowBeautify(reductionContextWithoutUnits); } -template Evaluation UnitConvertNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; -template Evaluation UnitConvertNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; +template Evaluation UnitConvertNode::templatedApproximate(ApproximationContext approximationContext) const; +template Evaluation UnitConvertNode::templatedApproximate(ApproximationContext approximationContext) const; } diff --git a/poincare/src/vector_cross.cpp b/poincare/src/vector_cross.cpp index dc5f6dc19..6ee288083 100644 --- a/poincare/src/vector_cross.cpp +++ b/poincare/src/vector_cross.cpp @@ -24,9 +24,9 @@ int VectorCrossNode::serialize(char * buffer, int bufferSize, Preferences::Print } template -Evaluation VectorCrossNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input0 = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation input1 = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Evaluation VectorCrossNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input0 = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation input1 = childAtIndex(1)->approximate(T(), approximationContext); return input0.cross(&input1); } diff --git a/poincare/src/vector_dot.cpp b/poincare/src/vector_dot.cpp index 5dc5d23f1..aaabfe3c1 100644 --- a/poincare/src/vector_dot.cpp +++ b/poincare/src/vector_dot.cpp @@ -24,9 +24,9 @@ int VectorDotNode::serialize(char * buffer, int bufferSize, Preferences::PrintFl } template -Evaluation VectorDotNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input0 = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); - Evaluation input1 = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); +Evaluation VectorDotNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input0 = childAtIndex(0)->approximate(T(), approximationContext); + Evaluation input1 = childAtIndex(1)->approximate(T(), approximationContext); return Complex::Builder(input0.dot(&input1)); } diff --git a/poincare/src/vector_norm.cpp b/poincare/src/vector_norm.cpp index 85a3ff59b..c428d8b5e 100644 --- a/poincare/src/vector_norm.cpp +++ b/poincare/src/vector_norm.cpp @@ -25,8 +25,8 @@ int VectorNormNode::serialize(char * buffer, int bufferSize, Preferences::PrintF } template -Evaluation VectorNormNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - Evaluation input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); +Evaluation VectorNormNode::templatedApproximate(ApproximationContext approximationContext) const { + Evaluation input = childAtIndex(0)->approximate(T(), approximationContext); return Complex::Builder(input.norm()); }