UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-03-18 21:30:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

[poincare] Finish replacing approximateContext

Browse Source
This commit is contained in:
Émilie Feral
2020-11-03 17:39:44 +01:00
parent f8b3156f19
commit 7142f9545e
141 changed files with 556 additions and 547 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
poincare/include/poincare/absolute_value.h
View File

@@ -28,11 +28,11 @@ public:
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
return Complex<T>::Builder(std::abs(c));
}
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit, computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
// Layout

8
poincare/include/poincare/addition.h
View File

@@ -64,11 +64,11 @@ private:
template<typename T> static MatrixComplex<T> computeOnMatrixAndComplex(const MatrixComplex<T> m, const std::complex<T> c, Preferences::ComplexFormat complexFormat) {
return MatrixComplex<T>::Undefined();
}
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::MapReduce<float>(this, context, complexFormat, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<float>(this, approximationContext, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::MapReduce<double>(this, context, complexFormat, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<double>(this, approximationContext, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
}
};

6
poincare/include/poincare/approximation_helper.h
View File

@@ -10,17 +10,17 @@ namespace Poincare {
namespace ApproximationHelper {
template <typename T> T Epsilon();
template <typename T> int PositiveIntegerApproximationIfPossible(const ExpressionNode * expression, bool * isUndefined, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
template <typename T> int PositiveIntegerApproximationIfPossible(const ExpressionNode * expression, bool * isUndefined, ExpressionNode::ApproximationContext approximationContext);
template <typename T> std::complex<T> NeglectRealOrImaginaryPartIfNeglectable(std::complex<T> result, std::complex<T> input1, std::complex<T> input2 = 1.0, bool enableNullResult = true);
template <typename T> using ComplexCompute = Complex<T>(*)(const std::complex<T>, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
template<typename T> Evaluation<T> Map(const ExpressionNode * expression, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, ComplexCompute<T> compute);
template<typename T> Evaluation<T> Map(const ExpressionNode * expression, ExpressionNode::ApproximationContext approximationContext, ComplexCompute<T> compute);
template <typename T> using ComplexAndComplexReduction = Complex<T>(*)(const std::complex<T>, const std::complex<T>, Preferences::ComplexFormat complexFormat);
template <typename T> using ComplexAndMatrixReduction = MatrixComplex<T>(*)(const std::complex<T> c, const MatrixComplex<T> m, Preferences::ComplexFormat complexFormat);
template <typename T> using MatrixAndComplexReduction = MatrixComplex<T>(*)(const MatrixComplex<T> m, const std::complex<T> c, Preferences::ComplexFormat complexFormat);
template <typename T> using MatrixAndMatrixReduction = MatrixComplex<T>(*)(const MatrixComplex<T> m, const MatrixComplex<T> n, Preferences::ComplexFormat complexFormat);
template<typename T> Evaluation<T> MapReduce(const ExpressionNode * expression, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, ComplexAndComplexReduction<T> computeOnComplexes, ComplexAndMatrixReduction<T> computeOnComplexAndMatrix, MatrixAndComplexReduction<T> computeOnMatrixAndComplex, MatrixAndMatrixReduction<T> computeOnMatrices);
template<typename T> Evaluation<T> MapReduce(const ExpressionNode * expression, ExpressionNode::ApproximationContext approximationContext, ComplexAndComplexReduction<T> computeOnComplexes, ComplexAndMatrixReduction<T> computeOnComplexAndMatrix, MatrixAndComplexReduction<T> computeOnMatrixAndComplex, MatrixAndMatrixReduction<T> computeOnMatrices);
template<typename T> MatrixComplex<T> ElementWiseOnMatrixComplexAndComplex(const MatrixComplex<T> n, std::complex<T> c, Preferences::ComplexFormat complexFormat, ComplexAndComplexReduction<T> computeOnComplexes);
template<typename T> MatrixComplex<T> ElementWiseOnComplexMatrices(const MatrixComplex<T> m, const MatrixComplex<T> n, Preferences::ComplexFormat complexFormat, ComplexAndComplexReduction<T> computeOnComplexes);

8
poincare/include/poincare/arc_cosine.h
View File

@@ -35,11 +35,11 @@ private:
//Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/arc_sine.h
View File

@@ -34,11 +34,11 @@ private:
//Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/arc_tangent.h
View File

@@ -35,11 +35,11 @@ private:
//Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

4
poincare/include/poincare/arithmetic.h
View File

@@ -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<typename T> static Evaluation<T> GCD(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
template<typename T> static Evaluation<T> LCM(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
template<typename T> static Evaluation<T> GCD(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext);
template<typename T> static Evaluation<T> 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

4
poincare/include/poincare/based_integer.h
View File

@@ -34,8 +34,8 @@ public:
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return Complex<float>::Builder(templatedApproximate<float>()); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return Complex<double>::Builder(templatedApproximate<double>()); }
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return Complex<float>::Builder(templatedApproximate<float>()); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return Complex<double>::Builder(templatedApproximate<double>()); }
template<typename T> T templatedApproximate() const;
private:

6
poincare/include/poincare/binom_cdf.h
View File

@@ -29,9 +29,9 @@ private:
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class BinomCDF final : public BinomialDistributionFunction {

6
poincare/include/poincare/binom_pdf.h
View File

@@ -29,9 +29,9 @@ private:
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class BinomPDF final : public BinomialDistributionFunction {

6
poincare/include/poincare/binomial_coefficient.h
View File

@@ -30,9 +30,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; };
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Complex<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Complex<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class BinomialCoefficient final : public Expression {

8
poincare/include/poincare/ceiling.h
View File

@@ -31,11 +31,11 @@ private:
// Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit, computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/complex_argument.h
View File

@@ -31,11 +31,11 @@ private:
// Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

6
poincare/include/poincare/complex_cartesian.h
View File

@@ -26,8 +26,8 @@ private:
// Layout
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { assert(false); return Layout(); }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
// Simplification
Expression shallowReduce(ReductionContext reductionContext) override;
Expression shallowBeautify(ReductionContext reductionContext) override;
@@ -38,7 +38,7 @@ private:
return LayoutShape::BoundaryPunctuation;
};
template<typename T> Complex<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> Complex<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class ComplexCartesian final : public Expression {

6
poincare/include/poincare/confidence_interval.h
View File

@@ -32,9 +32,9 @@ private:
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class SimplePredictionIntervalNode final : public ConfidenceIntervalNode {

8
poincare/include/poincare/conjugate.h
View File

@@ -33,11 +33,11 @@ private:
// Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

4
poincare/include/poincare/constant.h
View File

@@ -34,8 +34,8 @@ public:
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
/* Approximation */
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(); }
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(); }
/* Symbol properties */
bool isPi() const { return isConstantCodePoint(UCodePointGreekSmallLetterPi); }

8
poincare/include/poincare/cosine.h
View File

@@ -38,11 +38,11 @@ private:
Expression unaryFunctionDifferential() override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

4
poincare/include/poincare/decimal.h
View File

@@ -46,10 +46,10 @@ public:
Expression setSign(Sign s, ReductionContext reductionContext) override;
// Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return Complex<float>::Builder(templatedApproximate<float>());
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return Complex<double>::Builder(templatedApproximate<double>());
}

12
poincare/include/poincare/derivative.h
View File

@@ -34,12 +34,12 @@ private:
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> T approximateWithArgument(T x, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> T growthRateAroundAbscissa(T x, T h, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> T riddersApproximation(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, T x, T h, T * error) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
template<typename T> T approximateWithArgument(T x, ApproximationContext approximationContext) const;
template<typename T> T growthRateAroundAbscissa(T x, T h, ApproximationContext approximationContext) const;
template<typename T> 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;

6
poincare/include/poincare/determinant.h
View File

@@ -28,9 +28,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
/* Approximation */
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};

8
poincare/include/poincare/division.h
View File

@@ -33,15 +33,15 @@ public:
Expression removeUnit(Expression * unit) override { assert(false); return ExpressionNode::removeUnit(unit); }
// Approximation
virtual Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
virtual Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<float>(
this, context, complexFormat, angleUnit, compute<float>,
this, approximationContext, compute<float>,
computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>,
computeOnMatrices<float>);
}
virtual Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
virtual Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<double>(
this, context, complexFormat, angleUnit, compute<double>,
this, approximationContext, compute<double>,
computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>,
computeOnMatrices<double>);
}

6
poincare/include/poincare/division_quotient.h
View File

@@ -33,9 +33,9 @@ private:
// Simplification
Expression shallowReduce(ReductionContext reductionContext) override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class DivisionQuotient final : public Expression {

6
poincare/include/poincare/division_remainder.h
View File

@@ -35,9 +35,9 @@ private:
// Simplification
Expression shallowReduce(ReductionContext reductionContext) override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class DivisionRemainder final : public Expression {

6
poincare/include/poincare/empty_expression.h
View File

@@ -33,9 +33,9 @@ private:
// Layout
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class EmptyExpression final : public Expression {

6
poincare/include/poincare/equal.h
View File

@@ -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<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class Equal final : public Expression {

44
poincare/include/poincare/expression_node.h
View File

@@ -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;
};

8
poincare/include/poincare/factor.h
View File

@@ -33,9 +33,9 @@ private:
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
/* Evaluation */
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> 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<Factor>);
Multiplication createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Multiplication createMultiplicationOfIntegerPrimeDecomposition(Integer i) const;
// Expression
Expression shallowReduce(Context * context);

8
poincare/include/poincare/factorial.h
View File

@@ -37,11 +37,11 @@ private:
// Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
#if 0

6
poincare/include/poincare/float.h
View File

@@ -47,13 +47,13 @@ public:
/* Layout */
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
/* Evaluation */
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
private:
// Simplification
LayoutShape leftLayoutShape() const override { return LayoutShape::Decimal; }
template<typename U> Evaluation<U> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const {
template<typename U> Evaluation<U> templatedApproximate(ApproximationContext approximationContext) const {
return Complex<U>::Builder((U)m_value);
}
T m_value;

8
poincare/include/poincare/floor.h
View File

@@ -32,11 +32,11 @@ private:
// Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit, computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/frac_part.h
View File

@@ -33,11 +33,11 @@ private:
// Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit, computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

6
poincare/include/poincare/function.h
View File

@@ -42,9 +42,9 @@ private:
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override;
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override;
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override;
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override;
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class Function : public SymbolAbstract {

6
poincare/include/poincare/great_common_divisor.h
View File

@@ -30,9 +30,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class GreatCommonDivisor final : public NAryExpression {

8
poincare/include/poincare/hyperbolic_arc_cosine.h
View File

@@ -27,11 +27,11 @@ private:
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
//Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/hyperbolic_arc_sine.h
View File

@@ -25,11 +25,11 @@ private:
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
//Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/hyperbolic_arc_tangent.h
View File

@@ -25,11 +25,11 @@ private:
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
//Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/hyperbolic_cosine.h
View File

@@ -30,11 +30,11 @@ private:
Expression unaryFunctionDifferential() override;
//Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/hyperbolic_sine.h
View File

@@ -28,11 +28,11 @@ private:
Expression unaryFunctionDifferential() override;
//Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/hyperbolic_tangent.h
View File

@@ -28,11 +28,11 @@ private:
Expression unaryFunctionDifferential() override;
//Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/imaginary_part.h
View File

@@ -34,11 +34,11 @@ private:
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
return Complex<T>::Builder(std::imag(c));
}
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

4
poincare/include/poincare/infinity.h
View File

@@ -27,10 +27,10 @@ public:
Expression setSign(Sign s, ReductionContext reductionContext) override;
// Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>();
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>();
}

12
poincare/include/poincare/integral.h
View File

@@ -31,9 +31,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; };
LayoutShape rightLayoutShape() const override { return LayoutShape::MoreLetters; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
template<typename T>
struct DetailedResult
{
@@ -44,10 +44,10 @@ private:
#ifdef LAGRANGE_METHOD
template<typename T> T lagrangeGaussQuadrature(T a, T b, Context Context * context, Preferences::AngleUnit angleUnit context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
#else
template<typename T> DetailedResult<T> kronrodGaussQuadrature(T a, T b, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> T adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> DetailedResult<T> kronrodGaussQuadrature(T a, T b, ApproximationContext approximationContext) const;
template<typename T> T adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, ApproximationContext approximationContext) const;
#endif
template<typename T> T functionValueAtAbscissa(T x, Context * xcontext, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> T functionValueAtAbscissa(T x, ApproximationContext approximationContext) const;
};
class Integral final : public ParameteredExpression {

6
poincare/include/poincare/inv_binom.h
View File

@@ -30,9 +30,9 @@ private:
Expression shallowReduce(ReductionContext reductionContext) override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class InvBinom final : public BinomialDistributionFunction {

6
poincare/include/poincare/inv_norm.h
View File

@@ -30,9 +30,9 @@ private:
Expression shallowReduce(ReductionContext reductionContext) override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class InvNorm final : public NormalDistributionFunction {

6
poincare/include/poincare/least_common_multiple.h
View File

@@ -30,9 +30,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class LeastCommonMultiple final : public NAryExpression {

8
poincare/include/poincare/logarithm.h
View File

@@ -42,9 +42,9 @@ public:
* (warning: log takes the other side of the cut values on ]-inf-0i, 0-0i]). */
return Complex<U>::Builder(std::log10(c));
}
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename U> Evaluation<U> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename U> Evaluation<U> 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;

10
poincare/include/poincare/matrix.h
View File

@@ -40,18 +40,18 @@ public:
Expression shallowReduce(ReductionContext reductionContext) override;
// Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return templatedApproximate<float>(context, complexFormat, angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>(approximationContext);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return templatedApproximate<double>(context, complexFormat, angleUnit);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>(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<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> Evaluation<T> 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. */

6
poincare/include/poincare/matrix_dimension.h
View File

@@ -29,9 +29,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class MatrixDimension final : public Expression {

6
poincare/include/poincare/matrix_echelon_form.h
View File

@@ -21,9 +21,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
// Properties
virtual const char * functionHelperName() const = 0;

6
poincare/include/poincare/matrix_identity.h
View File

@@ -27,9 +27,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class MatrixIdentity final : public Expression {

6
poincare/include/poincare/matrix_inverse.h
View File

@@ -28,9 +28,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class MatrixInverse final : public Expression {

6
poincare/include/poincare/matrix_trace.h
View File

@@ -28,9 +28,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class MatrixTrace final : public Expression {

6
poincare/include/poincare/matrix_transpose.h
View File

@@ -28,9 +28,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class MatrixTranspose final : public Expression {

8
poincare/include/poincare/multiplication.h
View File

@@ -56,11 +56,11 @@ private:
template<typename T> static MatrixComplex<T> computeOnMatrixAndComplex(const MatrixComplex<T> m, const std::complex<T> c, Preferences::ComplexFormat complexFormat) {
return ApproximationHelper::ElementWiseOnMatrixComplexAndComplex(m, c, complexFormat, compute<T>);
}
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::MapReduce<float>(this, context, complexFormat, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<float>(this, approximationContext, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::MapReduce<double>(this, context, complexFormat, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<double>(this, approximationContext, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
}
};

8
poincare/include/poincare/naperian_logarithm.h
View File

@@ -35,11 +35,11 @@ private:
* (warning: ln takes the other side of the cut values on ]-inf-0i, 0-0i]). */
return Complex<T>::Builder(std::log(c));
}
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

6
poincare/include/poincare/norm_cdf.h
View File

@@ -29,9 +29,9 @@ private:
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class NormCDF final : public NormalDistributionFunction {

6
poincare/include/poincare/norm_cdf2.h
View File

@@ -31,9 +31,9 @@ private:
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class NormCDF2 final : public NormalDistributionFunction {

6
poincare/include/poincare/norm_pdf.h
View File

@@ -29,9 +29,9 @@ private:
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class NormPDF final : public NormalDistributionFunction {

6
poincare/include/poincare/nth_root.h
View File

@@ -29,9 +29,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::NthRoot; };
LayoutShape rightLayoutShape() const override { return LayoutShape::Root; };
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};

8
poincare/include/poincare/opposite.h
View File

@@ -30,11 +30,11 @@ public:
bool childAtIndexNeedsUserParentheses(const Expression & child, int childIndex) const override;
// Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit, compute<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, compute<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, compute<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, compute<double>);
}
// Layout

6
poincare/include/poincare/parenthesis.h
View File

@@ -33,10 +33,10 @@ public:
LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; };
// Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
private:
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class Parenthesis final : public Expression {

6
poincare/include/poincare/permute_coefficient.h
View File

@@ -33,9 +33,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class PermuteCoefficient final : public Expression {

10
poincare/include/poincare/power.h
View File

@@ -64,13 +64,13 @@ private:
template<typename T> static MatrixComplex<T> computeOnComplexAndMatrix(const std::complex<T> c, const MatrixComplex<T> n, Preferences::ComplexFormat complexFormat);
template<typename T> static MatrixComplex<T> computeOnMatrixAndComplex(const MatrixComplex<T> m, const std::complex<T> d, Preferences::ComplexFormat complexFormat);
template<typename T> static MatrixComplex<T> computeOnMatrices(const MatrixComplex<T> m, const MatrixComplex<T> n, Preferences::ComplexFormat complexFormat);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return templatedApproximate<float>(context, complexFormat, angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>(approximationContext);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return templatedApproximate<double>(context, complexFormat, angleUnit);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>(approximationContext);
}
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class Power final : public Expression {

6
poincare/include/poincare/prediction_interval.h
View File

@@ -31,9 +31,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class PredictionInterval final : public Expression {

10
poincare/include/poincare/randint.h
View File

@@ -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<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return templateApproximate<float>(context, complexFormat, angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templateApproximate<float>(approximationContext);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return templateApproximate<double>(context, complexFormat, angleUnit);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templateApproximate<double>(approximationContext);
}
template <typename T> Evaluation<T> templateApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, bool * inputIsUndefined = nullptr) const;
template <typename T> Evaluation<T> templateApproximate(ApproximationContext approximationContext, bool * inputIsUndefined = nullptr) const;
// Simplification
Expression shallowReduce(ReductionContext reductionContext) override;
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };

4
poincare/include/poincare/random.h
View File

@@ -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<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templateApproximate<float>();
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templateApproximate<double>();
}
template <typename T> Evaluation<T> templateApproximate() const;

4
poincare/include/poincare/rational.h
View File

@@ -39,8 +39,8 @@ public:
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return Complex<float>::Builder(templatedApproximate<float>()); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return Complex<double>::Builder(templatedApproximate<double>()); }
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return Complex<float>::Builder(templatedApproximate<float>()); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return Complex<double>::Builder(templatedApproximate<double>()); }
template<typename T> T templatedApproximate() const;
// Basic test

8
poincare/include/poincare/real_part.h
View File

@@ -36,11 +36,11 @@ private:
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
return Complex<T>::Builder(std::real(c));
}
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

6
poincare/include/poincare/round.h
View File

@@ -31,9 +31,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class Round final : public Expression {

6
poincare/include/poincare/sequence.h
View File

@@ -34,9 +34,9 @@ private:
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override;
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override;
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override;
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override;
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class Sequence : public SymbolAbstract {

8
poincare/include/poincare/sign_function.h
View File

@@ -35,11 +35,11 @@ private:
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit, computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/sine.h
View File

@@ -39,11 +39,11 @@ private:
Expression unaryFunctionDifferential() override;
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/square_root.h
View File

@@ -32,11 +32,11 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::Root; };
// Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

8
poincare/include/poincare/store.h
View File

@@ -23,9 +23,9 @@ private:
// Simplification
Expression shallowReduce(ReductionContext reductionContext) override;
// Evalutation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> 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<StoreNode *>(Expression::node()); }
};

8
poincare/include/poincare/subtraction.h
View File

@@ -28,11 +28,11 @@ public:
// Approximation
template<typename T> static Complex<T> compute(const std::complex<T> c, const std::complex<T> d, Preferences::ComplexFormat complexFormat) { return Complex<T>::Builder(c - d); }
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::MapReduce<float>(this, context, complexFormat, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<float>(this, approximationContext, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::MapReduce<double>(this, context, complexFormat, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<double>(this, approximationContext, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
}
/* Layout */

6
poincare/include/poincare/sum_and_product.h
View File

@@ -17,9 +17,9 @@ private:
Expression shallowReduce(ReductionContext reductionContext) override;
LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; };
/* Approximation */
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
virtual float emptySumAndProductValue() const = 0;
virtual Evaluation<float> evaluateWithNextTerm(SinglePrecision p, Evaluation<float> a, Evaluation<float> b, Preferences::ComplexFormat complexFormat) const = 0;
virtual Evaluation<double> evaluateWithNextTerm(DoublePrecision p, Evaluation<double> a, Evaluation<double> b, Preferences::ComplexFormat complexFormat) const = 0;

6
poincare/include/poincare/symbol.h
View File

@@ -40,15 +40,15 @@ public:
bool derivate(ReductionContext reductionContext, Expression symbol, Expression symbolValue) override;
/* Approximation */
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
bool isUnknown() const;
private:
char m_name[0]; // MUST be the last member variable
size_t nodeSize() const override { return sizeof(SymbolNode); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class Symbol final : public SymbolAbstract {

8
poincare/include/poincare/tangent.h
View File

@@ -37,11 +37,11 @@ private:
// Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Radian);
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>);
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>);
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
}
};

4
poincare/include/poincare/undefined.h
View File

@@ -22,10 +22,10 @@ public:
Expression setSign(Sign s, ReductionContext reductionContext) override;
// Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>();
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>();
}

6
poincare/include/poincare/unit.h
View File

@@ -465,8 +465,8 @@ public:
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
/* Approximation */
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(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<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
const Representative * m_representative;
const Prefix * m_prefix;

6
poincare/include/poincare/unit_convert.h
View File

@@ -25,9 +25,9 @@ private:
void deepReduceChildren(ExpressionNode::ReductionContext reductionContext) override;
Expression shallowBeautify(ReductionContext reductionContext) override;
// Evalutation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class UnitConvert final : public Expression {

4
poincare/include/poincare/unreal.h
View File

@@ -20,10 +20,10 @@ public:
Type type() const override { return Type::Unreal; }
// Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override {
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>();
}
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override {
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>();
}

6
poincare/include/poincare/vector_cross.h
View File

@@ -28,9 +28,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class VectorCross final : public Expression {

6
poincare/include/poincare/vector_dot.h
View File

@@ -28,9 +28,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class VectorDot final : public Expression {

6
poincare/include/poincare/vector_norm.h
View File

@@ -28,9 +28,9 @@ private:
Expression shallowReduce(ReductionContext reductionContext) override;
LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(context, complexFormat, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(context, complexFormat, angleUnit); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(approximationContext); }
Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(approximationContext); }
template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
};
class VectorNorm final : public Expression {