UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-01-18 16:27:34 +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) { 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)); return Complex<T>::Builder(std::abs(c));
} }
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit, computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
} }
// Layout // 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) { template<typename T> static MatrixComplex<T> computeOnMatrixAndComplex(const MatrixComplex<T> m, const std::complex<T> c, Preferences::ComplexFormat complexFormat) {
return MatrixComplex<T>::Undefined(); return MatrixComplex<T>::Undefined();
} }
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<float>(this, context, complexFormat, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>); return ApproximationHelper::MapReduce<float>(this, approximationContext, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<double>(this, context, complexFormat, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>); 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 { namespace ApproximationHelper {
template <typename T> T Epsilon(); 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> 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> 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 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 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 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> 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> 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); 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 //Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
} }
}; };

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

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

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

@@ -35,11 +35,11 @@ private:
//Evaluation //Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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 Expression LCM(const Expression & expression);
static int GCD(int i, int j); static int GCD(int i, int j);
static int LCM(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> GCD(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext);
template<typename T> static Evaluation<T> LCM(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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: /* When outputCoefficients[0] is set to -1, that indicates a special case:
* i could not be factorized. * i could not be factorized.
* Before calling PrimeFactorization, we initiate two tables of Integers * 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; Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Approximation // Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return Complex<float>::Builder(templatedApproximate<float>()); } Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return Complex<float>::Builder(templatedApproximate<float>()); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return Complex<double>::Builder(templatedApproximate<double>()); } Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return Complex<double>::Builder(templatedApproximate<double>()); }
template<typename T> T templatedApproximate() const; template<typename T> T templatedApproximate() const;
private: 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation // Evaluation
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 BinomCDF final : public BinomialDistributionFunction { 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation // Evaluation
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 BinomPDF final : public BinomialDistributionFunction { 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; }; LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; };
// Evaluation // Evaluation
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> Complex<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; template<typename T> Complex<T> templatedApproximate(ApproximationContext approximationContext) const;
}; };
class BinomialCoefficient final : public Expression { class BinomialCoefficient final : public Expression {

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

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

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

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

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

@@ -26,8 +26,8 @@ private:
// Layout // Layout
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { assert(false); return Layout(); } Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { assert(false); return Layout(); }
// Evaluation // Evaluation
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); }
// Simplification // Simplification
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
Expression shallowBeautify(ReductionContext reductionContext) override; Expression shallowBeautify(ReductionContext reductionContext) override;
@@ -38,7 +38,7 @@ private:
return LayoutShape::BoundaryPunctuation; 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 { 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; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 SimplePredictionIntervalNode final : public ConfidenceIntervalNode { class SimplePredictionIntervalNode final : public ConfidenceIntervalNode {

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

@@ -33,11 +33,11 @@ private:
// Evaluation // Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
/* Approximation */ /* Approximation */
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<float>(); } Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<float>(); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return templatedApproximate<double>(); } Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return templatedApproximate<double>(); }
/* Symbol properties */ /* Symbol properties */
bool isPi() const { return isConstantCodePoint(UCodePointGreekSmallLetterPi); } bool isPi() const { return isConstantCodePoint(UCodePointGreekSmallLetterPi); }

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

@@ -38,11 +38,11 @@ private:
Expression unaryFunctionDifferential() override; Expression unaryFunctionDifferential() override;
// Evaluation // Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; Expression setSign(Sign s, ReductionContext reductionContext) override;
// Approximation // 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>()); 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>()); 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; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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;
template<typename T> T approximateWithArgument(T x, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; template<typename T> T approximateWithArgument(T x, ApproximationContext approximationContext) const;
template<typename T> T growthRateAroundAbscissa(T x, T h, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; template<typename T> T growthRateAroundAbscissa(T x, T h, ApproximationContext approximationContext) const;
template<typename T> T riddersApproximation(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, T x, T h, T * error) const; template<typename T> T riddersApproximation(ApproximationContext approximationContext, T x, T h, T * error) const;
// TODO: Change coefficients? // TODO: Change coefficients?
constexpr static double k_maxErrorRateOnApproximation = 0.001; constexpr static double k_maxErrorRateOnApproximation = 0.001;
constexpr static double k_minInitialRate = 0.01; 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
/* Approximation */ /* 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); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; 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); } Expression removeUnit(Expression * unit) override { assert(false); return ExpressionNode::removeUnit(unit); }
// Approximation // 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>( return ApproximationHelper::MapReduce<float>(
this, context, complexFormat, angleUnit, compute<float>, this, approximationContext, compute<float>,
computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>,
computeOnMatrices<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>( return ApproximationHelper::MapReduce<double>(
this, context, complexFormat, angleUnit, compute<double>, this, approximationContext, compute<double>,
computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>,
computeOnMatrices<double>); computeOnMatrices<double>);
} }

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

@@ -33,9 +33,9 @@ private:
// Simplification // Simplification
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
// Evaluation // Evaluation
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 DivisionQuotient final : public Expression { class DivisionQuotient final : public Expression {

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

@@ -35,9 +35,9 @@ private:
// Simplification // Simplification
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
// Evaluation // Evaluation
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 DivisionRemainder final : public Expression { class DivisionRemainder final : public Expression {

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

@@ -33,9 +33,9 @@ private:
// Layout // Layout
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation // Evaluation
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 EmptyExpression final : public Expression { 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; Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evalutation // Evalutation
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 Equal final : public Expression { class Equal final : public Expression {

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

@@ -162,54 +162,60 @@ public:
Null = 1, Null = 1,
}; };
class ReductionContext { class ComputationContext {
public: 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_context(context),
m_complexFormat(complexFormat), 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_unitFormat(unitFormat),
m_target(target), m_target(target),
m_symbolicComputation(symbolicComputation), m_symbolicComputation(symbolicComputation),
m_unitConversion(unitConversion) 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; } Preferences::UnitFormat unitFormat() const { return m_unitFormat; }
ReductionTarget target() const { return m_target; } ReductionTarget target() const { return m_target; }
SymbolicComputation symbolicComputation() const { return m_symbolicComputation; } SymbolicComputation symbolicComputation() const { return m_symbolicComputation; }
UnitConversion unitConversion() const { return m_unitConversion; } UnitConversion unitConversion() const { return m_unitConversion; }
private: private:
Context * m_context;
Preferences::ComplexFormat m_complexFormat;
Preferences::AngleUnit m_angleUnit;
Preferences::UnitFormat m_unitFormat; Preferences::UnitFormat m_unitFormat;
ReductionTarget m_target; ReductionTarget m_target;
SymbolicComputation m_symbolicComputation; SymbolicComputation m_symbolicComputation;
UnitConversion m_unitConversion; UnitConversion m_unitConversion;
}; };
class ApproximationContext { class ApproximationContext : public ComputationContext {
public: public:
ApproximationContext( ApproximationContext(
Context * context, Context * context,
Preferences::ComplexFormat complexFormat, Preferences::ComplexFormat complexFormat,
Preferences::AngleUnit angleUnit, Preferences::AngleUnit angleUnit,
bool withinReduce = false) : bool withinReduce = false) :
m_context(context), ComputationContext(context, complexFormat, angleUnit),
m_complexFormat(complexFormat),
m_angleUnit(angleUnit),
m_withinReduce(withinReduce) m_withinReduce(withinReduce)
{} {}
Context * context() { return m_context; } ApproximationContext(ReductionContext reductionContext, bool withinReduce) :
Preferences::ComplexFormat complexFormat() const { return m_complexFormat; } ApproximationContext(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), withinReduce) {}
Preferences::AngleUnit angleUnit() const { return m_angleUnit; }
bool withinReduce() const { return m_withinReduce; } bool withinReduce() const { return m_withinReduce; }
private: private:
Context * m_context;
Preferences::ComplexFormat m_complexFormat;
Preferences::AngleUnit m_angleUnit;
bool m_withinReduce; bool m_withinReduce;
}; };

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

@@ -33,9 +33,9 @@ private:
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
/* Evaluation */ /* Evaluation */
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 Factor final : public Expression { class Factor final : public Expression {
@@ -45,7 +45,7 @@ public:
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("factor", 1, &UntypedBuilderOneChild<Factor>); 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
Expression shallowReduce(Context * context); Expression shallowReduce(Context * context);

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

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

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

@@ -47,13 +47,13 @@ public:
/* Layout */ /* Layout */
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
/* Evaluation */ /* Evaluation */
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); }
private: private:
// Simplification // Simplification
LayoutShape leftLayoutShape() const override { return LayoutShape::Decimal; } 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); return Complex<U>::Builder((U)m_value);
} }
T m_value; T m_value;

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

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

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

@@ -33,11 +33,11 @@ private:
// Evaluation // Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit, computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override; Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override;
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override; Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override;
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 Function : public SymbolAbstract { 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 GreatCommonDivisor final : public NAryExpression { 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
//Evaluation //Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
//Evaluation //Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
//Evaluation //Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; Expression unaryFunctionDifferential() override;
//Evaluation //Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; Expression unaryFunctionDifferential() override;
//Evaluation //Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; Expression unaryFunctionDifferential() override;
//Evaluation //Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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) { 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)); return Complex<T>::Builder(std::imag(c));
} }
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; Expression setSign(Sign s, ReductionContext reductionContext) override;
// Approximation // Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>(); return templatedApproximate<float>();
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>(); return templatedApproximate<double>();
} }

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

@@ -31,9 +31,9 @@ private:
LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }; LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; };
LayoutShape rightLayoutShape() const override { return LayoutShape::MoreLetters; } LayoutShape rightLayoutShape() const override { return LayoutShape::MoreLetters; }
// Evaluation // Evaluation
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;
template<typename T> template<typename T>
struct DetailedResult struct DetailedResult
{ {
@@ -44,10 +44,10 @@ private:
#ifdef LAGRANGE_METHOD #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; template<typename T> T lagrangeGaussQuadrature(T a, T b, Context Context * context, Preferences::AngleUnit angleUnit context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
#else #else
template<typename T> DetailedResult<T> kronrodGaussQuadrature(T a, T b, 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, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; template<typename T> T adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, ApproximationContext approximationContext) const;
#endif #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 { class Integral final : public ParameteredExpression {

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

@@ -30,9 +30,9 @@ private:
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
// Evaluation // Evaluation
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 InvBinom final : public BinomialDistributionFunction { class InvBinom final : public BinomialDistributionFunction {

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

@@ -30,9 +30,9 @@ private:
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
// Evaluation // Evaluation
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 InvNorm final : public NormalDistributionFunction { 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 LeastCommonMultiple final : public NAryExpression { 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]). */ * (warning: log takes the other side of the cut values on ]-inf-0i, 0-0i]). */
return Complex<U>::Builder(std::log10(c)); return Complex<U>::Builder(std::log10(c));
} }
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 U> Evaluation<U> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; template<typename U> Evaluation<U> templatedApproximate(ApproximationContext approximationContext) const;
}; };
class Logarithm final : public Expression { class Logarithm final : public Expression {
@@ -61,7 +61,7 @@ public:
private: private:
void deepReduceChildren(ExpressionNode::ReductionContext reductionContext); 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); Integer simplifyLogarithmIntegerBaseInteger(Integer i, Integer & base, Addition & a, bool isDenominator);
Expression splitLogarithmInteger(Integer i, bool isDenominator, ExpressionNode::ReductionContext reductionContext); Expression splitLogarithmInteger(Integer i, bool isDenominator, ExpressionNode::ReductionContext reductionContext);
bool parentIsAPowerOfSameBase() const; bool parentIsAPowerOfSameBase() const;

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

@@ -40,18 +40,18 @@ public:
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
// Approximation // Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>(context, complexFormat, angleUnit); return templatedApproximate<float>(approximationContext);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>(context, complexFormat, angleUnit); return templatedApproximate<double>(approximationContext);
} }
// Layout // Layout
Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode = Preferences::PrintFloatMode::Decimal, int numberOfSignificantDigits = 0) const override;
private: 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 /* We could store 2 uint8_t but multiplying m_numberOfRows and
* m_numberOfColumns could then lead to overflow. As we are unlikely to use * m_numberOfColumns could then lead to overflow. As we are unlikely to use
* greater matrix than 100*100, uint16_t is fine. */ * 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 MatrixDimension final : public Expression { 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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;
// Properties // Properties
virtual const char * functionHelperName() const = 0; 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 MatrixIdentity final : public Expression { 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 MatrixInverse final : public Expression { 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 MatrixTrace final : public Expression { 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 MatrixTranspose final : public Expression { 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) { 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>); return ApproximationHelper::ElementWiseOnMatrixComplexAndComplex(m, c, complexFormat, compute<T>);
} }
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<float>(this, context, complexFormat, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>); return ApproximationHelper::MapReduce<float>(this, approximationContext, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<double>(this, context, complexFormat, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>); 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]). */ * (warning: ln takes the other side of the cut values on ]-inf-0i, 0-0i]). */
return Complex<T>::Builder(std::log(c)); return Complex<T>::Builder(std::log(c));
} }
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation // Evaluation
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 NormCDF final : public NormalDistributionFunction { 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation // Evaluation
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 NormCDF2 final : public NormalDistributionFunction { 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation // Evaluation
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 NormPDF final : public NormalDistributionFunction { 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 leftLayoutShape() const override { return LayoutShape::NthRoot; };
LayoutShape rightLayoutShape() const override { return LayoutShape::Root; }; LayoutShape rightLayoutShape() const override { return LayoutShape::Root; };
// Evaluation // Evaluation
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;
}; };

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

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

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

@@ -33,10 +33,10 @@ public:
LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }; LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; };
// Approximation // 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); }
private: 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 { 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 PermuteCoefficient final : public Expression { 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> 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> 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); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>(context, complexFormat, angleUnit); return templatedApproximate<float>(approximationContext);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>(context, complexFormat, angleUnit); 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 { 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 PredictionInterval final : public Expression { 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; Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation // Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templateApproximate<float>(context, complexFormat, angleUnit); return templateApproximate<float>(approximationContext);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templateApproximate<double>(context, complexFormat, angleUnit); 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 // Simplification
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
LayoutShape leftLayoutShape() const override { return LayoutShape::MoreLetters; }; 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; Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Evaluation // Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templateApproximate<float>(); return templateApproximate<float>();
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templateApproximate<double>(); return templateApproximate<double>();
} }
template <typename T> Evaluation<T> templateApproximate() const; 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; Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
// Approximation // Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { return Complex<float>::Builder(templatedApproximate<float>()); } Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override { return Complex<float>::Builder(templatedApproximate<float>()); }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { return Complex<double>::Builder(templatedApproximate<double>()); } Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override { return Complex<double>::Builder(templatedApproximate<double>()); }
template<typename T> T templatedApproximate() const; template<typename T> T templatedApproximate() const;
// Basic test // 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) { 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)); return Complex<T>::Builder(std::real(c));
} }
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 Round final : public Expression { 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; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override; Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override;
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override; Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override;
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 Sequence : public SymbolAbstract { 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; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit, computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); return ApproximationHelper::Map<double>(this, approximationContext, computeOnComplex<double>);
} }
}; };

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

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

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

@@ -23,9 +23,9 @@ private:
// Simplification // Simplification
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
// Evalutation // Evalutation
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 Store final : public Expression { class Store final : public Expression {
@@ -48,7 +48,7 @@ public:
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext); Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
private: 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()); } StoreNode * node() const { return static_cast<StoreNode *>(Expression::node()); }
}; };

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

@@ -28,11 +28,11 @@ public:
// Approximation // 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); } 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<float>(this, context, complexFormat, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>); return ApproximationHelper::MapReduce<float>(this, approximationContext, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::MapReduce<double>(this, context, complexFormat, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>); return ApproximationHelper::MapReduce<double>(this, approximationContext, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
} }
/* Layout */ /* Layout */

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

@@ -17,9 +17,9 @@ private:
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }; LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; };
/* Approximation */ /* 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); }
template<typename T> Evaluation<T> templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; template<typename T> Evaluation<T> templatedApproximate(ApproximationContext approximationContext) const;
virtual float emptySumAndProductValue() const = 0; virtual float emptySumAndProductValue() const = 0;
virtual Evaluation<float> evaluateWithNextTerm(SinglePrecision p, Evaluation<float> a, Evaluation<float> b, Preferences::ComplexFormat complexFormat) 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; 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; bool derivate(ReductionContext reductionContext, Expression symbol, Expression symbolValue) override;
/* Approximation */ /* 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); }
bool isUnknown() const; bool isUnknown() const;
private: private:
char m_name[0]; // MUST be the last member variable char m_name[0]; // MUST be the last member variable
size_t nodeSize() const override { return sizeof(SymbolNode); } 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 { class Symbol final : public SymbolAbstract {

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

@@ -37,11 +37,11 @@ private:
// Evaluation // Evaluation
template<typename T> static Complex<T> computeOnComplex(const std::complex<T> c, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Radian); 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 { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<float>(this, context, complexFormat, angleUnit,computeOnComplex<float>); return ApproximationHelper::Map<float>(this, approximationContext, computeOnComplex<float>);
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return ApproximationHelper::Map<double>(this, context, complexFormat, angleUnit, computeOnComplex<double>); 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; Expression setSign(Sign s, ReductionContext reductionContext) override;
// Approximation // Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>(); return templatedApproximate<float>();
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>(); 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; int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override;
/* Approximation */ /* 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); }
// Comparison // Comparison
int simplificationOrderSameType(const ExpressionNode * e, bool ascending, bool canBeInterrupted, bool ignoreParentheses) const override; 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; } void setPrefix(const Prefix * prefix) { m_prefix = prefix; }
private: 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 Representative * m_representative;
const Prefix * m_prefix; const Prefix * m_prefix;

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

@@ -25,9 +25,9 @@ private:
void deepReduceChildren(ExpressionNode::ReductionContext reductionContext) override; void deepReduceChildren(ExpressionNode::ReductionContext reductionContext) override;
Expression shallowBeautify(ReductionContext reductionContext) override; Expression shallowBeautify(ReductionContext reductionContext) override;
// Evalutation // Evalutation
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 UnitConvert final : public Expression { 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; } Type type() const override { return Type::Unreal; }
// Approximation // Approximation
Evaluation<float> approximate(SinglePrecision p, ApproximateContext approximateContext) const override { Evaluation<float> approximate(SinglePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<float>(); return templatedApproximate<float>();
} }
Evaluation<double> approximate(DoublePrecision p, ApproximateContext approximateContext) const override { Evaluation<double> approximate(DoublePrecision p, ApproximationContext approximationContext) const override {
return templatedApproximate<double>(); 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 VectorCross final : public Expression { 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 leftLayoutShape() const override { return LayoutShape::MoreLetters; };
LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape rightLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 VectorDot final : public Expression { class VectorDot final : public Expression {

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

@@ -28,9 +28,9 @@ private:
Expression shallowReduce(ReductionContext reductionContext) override; Expression shallowReduce(ReductionContext reductionContext) override;
LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; } LayoutShape leftLayoutShape() const override { return LayoutShape::BoundaryPunctuation; }
// Evaluation // Evaluation
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 VectorNorm final : public Expression { class VectorNorm final : public Expression {

2
poincare/src/absolute_value.cpp
View File

@@ -52,7 +52,7 @@ Expression AbsoluteValue::shallowReduce(ExpressionNode::ReductionContext reducti
} }
// |x| = ±x if x is real // |x| = ±x if x is real
if (c.isReal(reductionContext.context())) { if (c.isReal(reductionContext.context())) {
double app = c.node()->approximate<double>(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), true).toScalar(); double app = c.node()->approximate(double(), ExpressionNode::ApproximationContext(reductionContext, true)).toScalar();
if (!std::isnan(app)) { if (!std::isnan(app)) {
if ((c.isNumber() && app >= 0) || app >= Expression::Epsilon<double>()) { if ((c.isNumber() && app >= 0) || app >= Expression::Epsilon<double>()) {
/* abs(a) = a with a >= 0 /* abs(a) = a with a >= 0

38
poincare/src/approximation_helper.cpp
View File

@@ -44,8 +44,8 @@ T ApproximationHelper::Epsilon() {
return precision; return precision;
} }
template <typename T> int ApproximationHelper::PositiveIntegerApproximationIfPossible(const ExpressionNode * expression, bool * isUndefined, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { template <typename T> int ApproximationHelper::PositiveIntegerApproximationIfPossible(const ExpressionNode * expression, bool * isUndefined, ExpressionNode::ApproximationContext approximationContext) {
Evaluation<T> evaluation = expression->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> evaluation = expression->approximate(T(), approximationContext);
T scalar = evaluation.toScalar(); T scalar = evaluation.toScalar();
if (std::isnan(scalar) || scalar != (int)scalar) { if (std::isnan(scalar) || scalar != (int)scalar) {
*isUndefined = true; *isUndefined = true;
@@ -79,41 +79,41 @@ template <typename T> std::complex<T> ApproximationHelper::NeglectRealOrImaginar
return result; return result;
} }
template<typename T> Evaluation<T> ApproximationHelper::Map(const ExpressionNode * expression, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, ComplexCompute<T> compute) { template<typename T> Evaluation<T> ApproximationHelper::Map(const ExpressionNode * expression, ExpressionNode::ApproximationContext approximationContext, ComplexCompute<T> compute) {
assert(expression->numberOfChildren() == 1); assert(expression->numberOfChildren() == 1);
Evaluation<T> input = expression->childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> input = expression->childAtIndex(0)->approximate(T(), approximationContext);
if (input.type() == EvaluationNode<T>::Type::Complex) { if (input.type() == EvaluationNode<T>::Type::Complex) {
return compute(static_cast<Complex<T> &>(input).stdComplex(), complexFormat, angleUnit); return compute(static_cast<Complex<T> &>(input).stdComplex(), approximationContext.complexFormat(), approximationContext.angleUnit());
} else { } else {
assert(input.type() == EvaluationNode<T>::Type::MatrixComplex); assert(input.type() == EvaluationNode<T>::Type::MatrixComplex);
MatrixComplex<T> m = static_cast<MatrixComplex<T> &>(input); MatrixComplex<T> m = static_cast<MatrixComplex<T> &>(input);
MatrixComplex<T> result = MatrixComplex<T>::Builder(); MatrixComplex<T> result = MatrixComplex<T>::Builder();
for (int i = 0; i < m.numberOfChildren(); i++) { for (int i = 0; i < m.numberOfChildren(); i++) {
result.addChildAtIndexInPlace(compute(m.complexAtIndex(i), complexFormat, angleUnit), i, i); result.addChildAtIndexInPlace(compute(m.complexAtIndex(i), approximationContext.complexFormat(), approximationContext.angleUnit()), i, i);
} }
result.setDimensions(m.numberOfRows(), m.numberOfColumns()); result.setDimensions(m.numberOfRows(), m.numberOfColumns());
return std::move(result); return std::move(result);
} }
} }
template<typename T> Evaluation<T> ApproximationHelper::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> ApproximationHelper::MapReduce(const ExpressionNode * expression, ExpressionNode::ApproximationContext approximationContext, ComplexAndComplexReduction<T> computeOnComplexes, ComplexAndMatrixReduction<T> computeOnComplexAndMatrix, MatrixAndComplexReduction<T> computeOnMatrixAndComplex, MatrixAndMatrixReduction<T> computeOnMatrices) {
assert(expression->numberOfChildren() > 0); assert(expression->numberOfChildren() > 0);
Evaluation<T> result = expression->childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> result = expression->childAtIndex(0)->approximate(T(), approximationContext);
for (int i = 1; i < expression->numberOfChildren(); i++) { for (int i = 1; i < expression->numberOfChildren(); i++) {
Evaluation<T> intermediateResult; Evaluation<T> intermediateResult;
Evaluation<T> nextOperandEvaluation = expression->childAtIndex(i)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> nextOperandEvaluation = expression->childAtIndex(i)->approximate(T(), approximationContext);
if (result.type() == EvaluationNode<T>::Type::Complex && nextOperandEvaluation.type() == EvaluationNode<T>::Type::Complex) { if (result.type() == EvaluationNode<T>::Type::Complex && nextOperandEvaluation.type() == EvaluationNode<T>::Type::Complex) {
intermediateResult = computeOnComplexes(static_cast<Complex<T> &>(result).stdComplex(), static_cast<Complex<T> &>(nextOperandEvaluation).stdComplex(), complexFormat); intermediateResult = computeOnComplexes(static_cast<Complex<T> &>(result).stdComplex(), static_cast<Complex<T> &>(nextOperandEvaluation).stdComplex(), approximationContext.complexFormat());
} else if (result.type() == EvaluationNode<T>::Type::Complex) { } else if (result.type() == EvaluationNode<T>::Type::Complex) {
assert(nextOperandEvaluation.type() == EvaluationNode<T>::Type::MatrixComplex); assert(nextOperandEvaluation.type() == EvaluationNode<T>::Type::MatrixComplex);
intermediateResult = computeOnComplexAndMatrix(static_cast<Complex<T> &>(result).stdComplex(), static_cast<MatrixComplex<T> &>(nextOperandEvaluation), complexFormat); intermediateResult = computeOnComplexAndMatrix(static_cast<Complex<T> &>(result).stdComplex(), static_cast<MatrixComplex<T> &>(nextOperandEvaluation), approximationContext.complexFormat());
} else if (nextOperandEvaluation.type() == EvaluationNode<T>::Type::Complex) { } else if (nextOperandEvaluation.type() == EvaluationNode<T>::Type::Complex) {
assert(result.type() == EvaluationNode<T>::Type::MatrixComplex); assert(result.type() == EvaluationNode<T>::Type::MatrixComplex);
intermediateResult = computeOnMatrixAndComplex(static_cast<MatrixComplex<T> &>(result), static_cast<Complex<T> &>(nextOperandEvaluation).stdComplex(), complexFormat); intermediateResult = computeOnMatrixAndComplex(static_cast<MatrixComplex<T> &>(result), static_cast<Complex<T> &>(nextOperandEvaluation).stdComplex(), approximationContext.complexFormat());
} else { } else {
assert(result.node()->type() == EvaluationNode<T>::Type::MatrixComplex); assert(result.node()->type() == EvaluationNode<T>::Type::MatrixComplex);
assert(nextOperandEvaluation.node()->type() == EvaluationNode<T>::Type::MatrixComplex); assert(nextOperandEvaluation.node()->type() == EvaluationNode<T>::Type::MatrixComplex);
intermediateResult = computeOnMatrices(static_cast<MatrixComplex<T> &>(result), static_cast<MatrixComplex<T> &>(nextOperandEvaluation), complexFormat); intermediateResult = computeOnMatrices(static_cast<MatrixComplex<T> &>(result), static_cast<MatrixComplex<T> &>(nextOperandEvaluation), approximationContext.complexFormat());
} }
result = intermediateResult; result = intermediateResult;
if (result.isUndefined()) { if (result.isUndefined()) {
@@ -145,14 +145,14 @@ template<typename T> MatrixComplex<T> ApproximationHelper::ElementWiseOnComplexM
} }
template float Poincare::ApproximationHelper::Epsilon<float>(); template float Poincare::ApproximationHelper::Epsilon<float>();
template double Poincare::ApproximationHelper::Epsilon<double>(); template double Poincare::ApproximationHelper::Epsilon<double>();
template int Poincare::ApproximationHelper::PositiveIntegerApproximationIfPossible<float>(Poincare::ExpressionNode const*, bool*, Poincare::Context*, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit); template int Poincare::ApproximationHelper::PositiveIntegerApproximationIfPossible<float>(Poincare::ExpressionNode const*, bool*, ExpressionNode::ApproximationContext);
template int Poincare::ApproximationHelper::PositiveIntegerApproximationIfPossible<double>(Poincare::ExpressionNode const*, bool*, Poincare::Context*, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit); template int Poincare::ApproximationHelper::PositiveIntegerApproximationIfPossible<double>(Poincare::ExpressionNode const*, bool*, ExpressionNode::ApproximationContext);
template std::complex<float> Poincare::ApproximationHelper::NeglectRealOrImaginaryPartIfNeglectable<float>(std::complex<float>,std::complex<float>,std::complex<float>,bool); template std::complex<float> Poincare::ApproximationHelper::NeglectRealOrImaginaryPartIfNeglectable<float>(std::complex<float>,std::complex<float>,std::complex<float>,bool);
template std::complex<double> Poincare::ApproximationHelper::NeglectRealOrImaginaryPartIfNeglectable<double>(std::complex<double>,std::complex<double>,std::complex<double>,bool); template std::complex<double> Poincare::ApproximationHelper::NeglectRealOrImaginaryPartIfNeglectable<double>(std::complex<double>,std::complex<double>,std::complex<double>,bool);
template Poincare::Evaluation<float> Poincare::ApproximationHelper::Map(const Poincare::ExpressionNode * expression, Poincare::Context * context, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationHelper::ComplexCompute<float> compute); template Poincare::Evaluation<float> Poincare::ApproximationHelper::Map(const Poincare::ExpressionNode * expression, ExpressionNode::ApproximationContext, Poincare::ApproximationHelper::ComplexCompute<float> compute);
template Poincare::Evaluation<double> Poincare::ApproximationHelper::Map(const Poincare::ExpressionNode * expression, Poincare::Context * context, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationHelper::ComplexCompute<double> compute); template Poincare::Evaluation<double> Poincare::ApproximationHelper::Map(const Poincare::ExpressionNode * expression, ExpressionNode::ApproximationContext, Poincare::ApproximationHelper::ComplexCompute<double> compute);
template Poincare::Evaluation<float> Poincare::ApproximationHelper::MapReduce(const Poincare::ExpressionNode * expression, Poincare::Context * context, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationHelper::ComplexAndComplexReduction<float> computeOnComplexes, Poincare::ApproximationHelper::ComplexAndMatrixReduction<float> computeOnComplexAndMatrix, Poincare::ApproximationHelper::MatrixAndComplexReduction<float> computeOnMatrixAndComplex, Poincare::ApproximationHelper::MatrixAndMatrixReduction<float> computeOnMatrices); template Poincare::Evaluation<float> Poincare::ApproximationHelper::MapReduce(const Poincare::ExpressionNode * expression, ExpressionNode::ApproximationContext, Poincare::ApproximationHelper::ComplexAndComplexReduction<float> computeOnComplexes, Poincare::ApproximationHelper::ComplexAndMatrixReduction<float> computeOnComplexAndMatrix, Poincare::ApproximationHelper::MatrixAndComplexReduction<float> computeOnMatrixAndComplex, Poincare::ApproximationHelper::MatrixAndMatrixReduction<float> computeOnMatrices);
template Poincare::Evaluation<double> Poincare::ApproximationHelper::MapReduce(const Poincare::ExpressionNode * expression, Poincare::Context * context, Poincare::Preferences::ComplexFormat, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationHelper::ComplexAndComplexReduction<double> computeOnComplexes, Poincare::ApproximationHelper::ComplexAndMatrixReduction<double> computeOnComplexAndMatrix, Poincare::ApproximationHelper::MatrixAndComplexReduction<double> computeOnMatrixAndComplex, Poincare::ApproximationHelper::MatrixAndMatrixReduction<double> computeOnMatrices); template Poincare::Evaluation<double> Poincare::ApproximationHelper::MapReduce(const Poincare::ExpressionNode * expression, ExpressionNode::ApproximationContext, Poincare::ApproximationHelper::ComplexAndComplexReduction<double> computeOnComplexes, Poincare::ApproximationHelper::ComplexAndMatrixReduction<double> computeOnComplexAndMatrix, Poincare::ApproximationHelper::MatrixAndComplexReduction<double> computeOnMatrixAndComplex, Poincare::ApproximationHelper::MatrixAndMatrixReduction<double> computeOnMatrices);
template Poincare::MatrixComplex<float> Poincare::ApproximationHelper::ElementWiseOnMatrixComplexAndComplex<float>(const Poincare::MatrixComplex<float>, const std::complex<float>, Poincare::Preferences::ComplexFormat, Poincare::Complex<float> (*)(std::complex<float>, std::complex<float>, Poincare::Preferences::ComplexFormat)); template Poincare::MatrixComplex<float> Poincare::ApproximationHelper::ElementWiseOnMatrixComplexAndComplex<float>(const Poincare::MatrixComplex<float>, const std::complex<float>, Poincare::Preferences::ComplexFormat, Poincare::Complex<float> (*)(std::complex<float>, std::complex<float>, Poincare::Preferences::ComplexFormat));
template Poincare::MatrixComplex<double> Poincare::ApproximationHelper::ElementWiseOnMatrixComplexAndComplex<double>(const Poincare::MatrixComplex<double>, std::complex<double> const, Poincare::Preferences::ComplexFormat, Poincare::Complex<double> (*)(std::complex<double>, std::complex<double>, Poincare::Preferences::ComplexFormat)); template Poincare::MatrixComplex<double> Poincare::ApproximationHelper::ElementWiseOnMatrixComplexAndComplex<double>(const Poincare::MatrixComplex<double>, std::complex<double> const, Poincare::Preferences::ComplexFormat, Poincare::Complex<double> (*)(std::complex<double>, std::complex<double>, Poincare::Preferences::ComplexFormat));
template Poincare::MatrixComplex<float> Poincare::ApproximationHelper::ElementWiseOnComplexMatrices<float>(const Poincare::MatrixComplex<float>, const Poincare::MatrixComplex<float>, Poincare::Preferences::ComplexFormat, Poincare::Complex<float> (*)(std::complex<float>, std::complex<float>, Poincare::Preferences::ComplexFormat)); template Poincare::MatrixComplex<float> Poincare::ApproximationHelper::ElementWiseOnComplexMatrices<float>(const Poincare::MatrixComplex<float>, const Poincare::MatrixComplex<float>, Poincare::Preferences::ComplexFormat, Poincare::Complex<float> (*)(std::complex<float>, std::complex<float>, Poincare::Preferences::ComplexFormat));

22
poincare/src/arithmetic.cpp
View File

@@ -109,15 +109,15 @@ Expression Arithmetic::LCM(const Expression & expression) {
} }
template<typename T> template<typename T>
Evaluation<T> applyAssociativeFunctionOnChildren(const ExpressionNode & expressionNode, int (*f)(int, int), Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { Evaluation<T> applyAssociativeFunctionOnChildren(const ExpressionNode & expressionNode, int (*f)(int, int), ExpressionNode::ApproximationContext approximationContext) {
/* Use function associativity to compute a function of expression's children. /* Use function associativity to compute a function of expression's children.
* The function can be GCD or LCM. */ * The function can be GCD or LCM. */
bool isUndefined = false; bool isUndefined = false;
// We define f(a) = f(a,a) = a // We define f(a) = f(a,a) = a
int a = ApproximationHelper::PositiveIntegerApproximationIfPossible<T>(expressionNode.childAtIndex(0), &isUndefined, context, complexFormat, angleUnit); int a = ApproximationHelper::PositiveIntegerApproximationIfPossible<T>(expressionNode.childAtIndex(0), &isUndefined, approximationContext);
// f is associative, f(a,b,c,d) = f(f(f(a,b),c),d) // f is associative, f(a,b,c,d) = f(f(f(a,b),c),d)
for (int i = 1; i < expressionNode.numberOfChildren(); ++i) { for (int i = 1; i < expressionNode.numberOfChildren(); ++i) {
int b = ApproximationHelper::PositiveIntegerApproximationIfPossible<T>(expressionNode.childAtIndex(i), &isUndefined, context, complexFormat, angleUnit); int b = ApproximationHelper::PositiveIntegerApproximationIfPossible<T>(expressionNode.childAtIndex(i), &isUndefined, approximationContext);
if (isUndefined) { if (isUndefined) {
return Complex<T>::RealUndefined(); return Complex<T>::RealUndefined();
} }
@@ -127,15 +127,15 @@ Evaluation<T> applyAssociativeFunctionOnChildren(const ExpressionNode & expressi
} }
template<typename T> template<typename T>
Evaluation<T> Arithmetic::GCD(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { Evaluation<T> Arithmetic::GCD(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext) {
// Evaluate GCD of expression's children // Evaluate GCD of expression's children
return applyAssociativeFunctionOnChildren<T>(expressionNode, Arithmetic::GCD, context, complexFormat, angleUnit); return applyAssociativeFunctionOnChildren<T>(expressionNode, Arithmetic::GCD, approximationContext);
} }
template<typename T> template<typename T>
Evaluation<T> Arithmetic::LCM(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { Evaluation<T> Arithmetic::LCM(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext) {
// Evaluate LCM of expression's children // Evaluate LCM of expression's children
return applyAssociativeFunctionOnChildren<T>(expressionNode, Arithmetic::LCM, context, complexFormat, angleUnit); return applyAssociativeFunctionOnChildren<T>(expressionNode, Arithmetic::LCM, approximationContext);
} }
const short primeFactors[Arithmetic::k_numberOfPrimeFactors] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, const short primeFactors[Arithmetic::k_numberOfPrimeFactors] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643,
@@ -200,9 +200,9 @@ int Arithmetic::PrimeFactorization(const Integer & n, Integer outputFactors[], I
return t+1; return t+1;
} }
template Evaluation<double> Arithmetic::GCD<double>(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); template Evaluation<double> Arithmetic::GCD<double>(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext);
template Evaluation<float> Arithmetic::GCD<float>(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); template Evaluation<float> Arithmetic::GCD<float>(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext);
template Evaluation<double> Arithmetic::LCM<double>(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); template Evaluation<double> Arithmetic::LCM<double>(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext);
template Evaluation<float> Arithmetic::LCM<float>(const ExpressionNode & expressionNode, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit); template Evaluation<float> Arithmetic::LCM<float>(const ExpressionNode & expressionNode, ExpressionNode::ApproximationContext approximationContext);
} }

8
poincare/src/binom_cdf.cpp
View File

@@ -24,10 +24,10 @@ int BinomCDFNode::serialize(char * buffer, int bufferSize, Preferences::PrintFlo
} }
template<typename T> template<typename T>
Evaluation<T> BinomCDFNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { Evaluation<T> BinomCDFNode::templatedApproximate(ApproximationContext approximationContext) const {
Evaluation<T> xEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> xEvaluation = childAtIndex(0)->approximate(T(), approximationContext);
Evaluation<T> nEvaluation = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> nEvaluation = childAtIndex(1)->approximate(T(), approximationContext);
Evaluation<T> pEvaluation = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> pEvaluation = childAtIndex(2)->approximate(T(), approximationContext);
const T x = xEvaluation.toScalar(); const T x = xEvaluation.toScalar();
const T n = nEvaluation.toScalar(); const T n = nEvaluation.toScalar();

8
poincare/src/binom_pdf.cpp
View File

@@ -24,10 +24,10 @@ int BinomPDFNode::serialize(char * buffer, int bufferSize, Preferences::PrintFlo
} }
template<typename T> template<typename T>
Evaluation<T> BinomPDFNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { Evaluation<T> BinomPDFNode::templatedApproximate(ApproximationContext approximationContext) const {
Evaluation<T> xEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> xEvaluation = childAtIndex(0)->approximate(T(), approximationContext);
Evaluation<T> nEvaluation = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> nEvaluation = childAtIndex(1)->approximate(T(), approximationContext);
Evaluation<T> pEvaluation = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> pEvaluation = childAtIndex(2)->approximate(T(), approximationContext);
T x = xEvaluation.toScalar(); T x = xEvaluation.toScalar();
T n = nEvaluation.toScalar(); T n = nEvaluation.toScalar();

6
poincare/src/binomial_coefficient.cpp
View File

@@ -30,9 +30,9 @@ int BinomialCoefficientNode::serialize(char * buffer, int bufferSize, Preference
} }
template<typename T> template<typename T>
Complex<T> BinomialCoefficientNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { Complex<T> BinomialCoefficientNode::templatedApproximate(ApproximationContext approximationContext) const {
Evaluation<T> nInput = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> nInput = childAtIndex(0)->approximate(T(), approximationContext);
Evaluation<T> kInput = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> kInput = childAtIndex(1)->approximate(T(), approximationContext);
T n = nInput.toScalar(); T n = nInput.toScalar();
T k = kInput.toScalar(); T k = kInput.toScalar();
return Complex<T>::Builder(compute(k, n)); return Complex<T>::Builder(compute(k, n));

2
poincare/src/complex_argument.cpp
View File

@@ -51,7 +51,7 @@ Expression ComplexArgument::shallowReduce(ExpressionNode::ReductionContext reduc
} }
bool real = c.isReal(reductionContext.context()); bool real = c.isReal(reductionContext.context());
if (real) { if (real) {
float app = c.node()->approximate(float(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit(), true).toScalar(); float app = c.node()->approximate(float(), ExpressionNode::ApproximationContext(reductionContext, true)).toScalar();
if (!std::isnan(app) && app >= Expression::Epsilon<float>()) { if (!std::isnan(app) && app >= Expression::Epsilon<float>()) {
// arg(x) = 0 if x > 0 // arg(x) = 0 if x > 0
Expression result = Rational::Builder(0); Expression result = Rational::Builder(0);

6
poincare/src/complex_cartesian.cpp
View File

@@ -37,9 +37,9 @@ Expression ComplexCartesianNode::shallowBeautify(ReductionContext reductionConte
} }
template<typename T> template<typename T>
Complex<T> ComplexCartesianNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { Complex<T> ComplexCartesianNode::templatedApproximate(ApproximationContext approximationContext) const {
Evaluation<T> realEvaluation = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> realEvaluation = childAtIndex(0)->approximate(T(), approximationContext);
Evaluation<T> imagEvalution = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> imagEvalution = childAtIndex(1)->approximate(T(), approximationContext);
assert(realEvaluation.type() == EvaluationNode<T>::Type::Complex); assert(realEvaluation.type() == EvaluationNode<T>::Type::Complex);
assert(imagEvalution.type() == EvaluationNode<T>::Type::Complex); assert(imagEvalution.type() == EvaluationNode<T>::Type::Complex);
std::complex<T> a = static_cast<Complex<T> &>(realEvaluation).stdComplex(); std::complex<T> a = static_cast<Complex<T> &>(realEvaluation).stdComplex();

6
poincare/src/confidence_interval.cpp
View File

@@ -31,9 +31,9 @@ Expression ConfidenceIntervalNode::shallowReduce(ReductionContext reductionConte
} }
template<typename T> template<typename T>
Evaluation<T> ConfidenceIntervalNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { Evaluation<T> ConfidenceIntervalNode::templatedApproximate(ApproximationContext approximationContext) const {
Evaluation<T> fInput = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> fInput = childAtIndex(0)->approximate(T(), approximationContext);
Evaluation<T> nInput = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> nInput = childAtIndex(1)->approximate(T(), approximationContext);
T f = static_cast<Complex<T> &>(fInput).toScalar(); T f = static_cast<Complex<T> &>(fInput).toScalar();
T n = static_cast<Complex<T> &>(nInput).toScalar(); T n = static_cast<Complex<T> &>(nInput).toScalar();
if (std::isnan(f) || std::isnan(n) || n != (int)n || n < 0 || f < 0 || f > 1) { if (std::isnan(f) || std::isnan(n) || n != (int)n || n < 0 || f < 0 || f > 1) {

27
poincare/src/derivative.cpp
View File

@@ -40,10 +40,10 @@ Expression DerivativeNode::shallowReduce(ReductionContext reductionContext) {
} }
template<typename T> template<typename T>
Evaluation<T> DerivativeNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { Evaluation<T> DerivativeNode::templatedApproximate(ApproximationContext approximationContext) const {
Evaluation<T> evaluationArgumentInput = childAtIndex(2)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> evaluationArgumentInput = childAtIndex(2)->approximate(T(), approximationContext);
T evaluationArgument = evaluationArgumentInput.toScalar(); T evaluationArgument = evaluationArgumentInput.toScalar();
T functionValue = approximateWithArgument(evaluationArgument, context, complexFormat, angleUnit); T functionValue = approximateWithArgument(evaluationArgument, approximationContext);
// No complex/matrix version of Derivative // No complex/matrix version of Derivative
if (std::isnan(evaluationArgument) || std::isnan(functionValue)) { if (std::isnan(evaluationArgument) || std::isnan(functionValue)) {
return Complex<T>::RealUndefined(); return Complex<T>::RealUndefined();
@@ -55,7 +55,7 @@ Evaluation<T> DerivativeNode::templatedApproximate(Context * context, Preference
static T tenEpsilon = sizeof(T) == sizeof(double) ? 10.0*DBL_EPSILON : 10.0f*FLT_EPSILON; static T tenEpsilon = sizeof(T) == sizeof(double) ? 10.0*DBL_EPSILON : 10.0f*FLT_EPSILON;
do { do {
T currentError; T currentError;
T currentResult = riddersApproximation(context, complexFormat, angleUnit, evaluationArgument, h, &currentError); T currentResult = riddersApproximation(approximationContext, evaluationArgument, h, &currentError);
h /= (T)10.0; h /= (T)10.0;
if (std::isnan(currentError) || currentError > error) { if (std::isnan(currentError) || currentError > error) {
continue; continue;
@@ -83,23 +83,24 @@ Evaluation<T> DerivativeNode::templatedApproximate(Context * context, Preference
} }
template<typename T> template<typename T>
T DerivativeNode::approximateWithArgument(T x, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { T DerivativeNode::approximateWithArgument(T x, ApproximationContext approximationContext) const {
assert(childAtIndex(1)->type() == Type::Symbol); assert(childAtIndex(1)->type() == Type::Symbol);
VariableContext variableContext = VariableContext(static_cast<SymbolNode *>(childAtIndex(1))->name(), context); VariableContext variableContext = VariableContext(static_cast<SymbolNode *>(childAtIndex(1))->name(), approximationContext.context());
variableContext.setApproximationForVariable<T>(x); variableContext.setApproximationForVariable<T>(x);
// Here we cannot use Expression::approximateWithValueForSymbol which would reset the sApproximationEncounteredComplex flag // Here we cannot use Expression::approximateWithValueForSymbol which would reset the sApproximationEncounteredComplex flag
return childAtIndex(0)->approximate(T(), &variableContext, complexFormat, angleUnit).toScalar(); approximationContext.setContext(&variableContext);
return childAtIndex(0)->approximate(T(), approximationContext).toScalar();
} }
template<typename T> template<typename T>
T DerivativeNode::growthRateAroundAbscissa(T x, T h, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { T DerivativeNode::growthRateAroundAbscissa(T x, T h, ApproximationContext approximationContext) const {
T expressionPlus = approximateWithArgument(x+h, context, complexFormat, angleUnit); T expressionPlus = approximateWithArgument(x+h, approximationContext);
T expressionMinus = approximateWithArgument(x-h, context, complexFormat, angleUnit); T expressionMinus = approximateWithArgument(x-h, approximationContext);
return (expressionPlus - expressionMinus)/(h+h); return (expressionPlus - expressionMinus)/(h+h);
} }
template<typename T> template<typename T>
T DerivativeNode::riddersApproximation(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit, T x, T h, T * error) const { T DerivativeNode::riddersApproximation(ApproximationContext approximationContext, T x, T h, T * error) const {
/* Ridders' Algorithm /* Ridders' Algorithm
* Blibliography: * Blibliography:
* - Ridders, C.J.F. 1982, Advances in Helperering Software, vol. 4, no. 2, * - Ridders, C.J.F. 1982, Advances in Helperering Software, vol. 4, no. 2,
@@ -118,7 +119,7 @@ T DerivativeNode::riddersApproximation(Context * context, Preferences::ComplexFo
a[i][j] = 1; a[i][j] = 1;
} }
} }
a[0][0] = growthRateAroundAbscissa(x, hh, context, complexFormat, angleUnit); a[0][0] = growthRateAroundAbscissa(x, hh, approximationContext);
T ans = 0; T ans = 0;
T errt = 0; T errt = 0;
// Loop on i: change the step size // Loop on i: change the step size
@@ -127,7 +128,7 @@ T DerivativeNode::riddersApproximation(Context * context, Preferences::ComplexFo
// Make hh an exactly representable number // Make hh an exactly representable number
volatile T temp = x+hh; volatile T temp = x+hh;
hh = temp - x; hh = temp - x;
a[0][i] = growthRateAroundAbscissa(x, hh, context, complexFormat, angleUnit); a[0][i] = growthRateAroundAbscissa(x, hh, approximationContext);
T fac = k_rateStepSize*k_rateStepSize; T fac = k_rateStepSize*k_rateStepSize;
// Loop on j: compute extrapolation for several orders // Loop on j: compute extrapolation for several orders
for (int j = 1; j < 10; j++) { for (int j = 1; j < 10; j++) {

4
poincare/src/determinant.cpp
View File

@@ -26,8 +26,8 @@ int DeterminantNode::serialize(char * buffer, int bufferSize, Preferences::Print
} }
template<typename T> template<typename T>
Evaluation<T> DeterminantNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { Evaluation<T> DeterminantNode::templatedApproximate(ApproximationContext approximationContext) const {
Evaluation<T> input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> input = childAtIndex(0)->approximate(T(), approximationContext);
return Complex<T>::Builder(input.determinant()); return Complex<T>::Builder(input.determinant());
} }

6
poincare/src/division_quotient.cpp
View File

@@ -33,9 +33,9 @@ int DivisionQuotientNode::serialize(char * buffer, int bufferSize, Preferences::
} }
template<typename T> template<typename T>
Evaluation<T> DivisionQuotientNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { Evaluation<T> DivisionQuotientNode::templatedApproximate(ApproximationContext approximationContext) const {
Evaluation<T> f1Input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> f1Input = childAtIndex(0)->approximate(T(), approximationContext);
Evaluation<T> f2Input = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> f2Input = childAtIndex(1)->approximate(T(), approximationContext);
T f1 = f1Input.toScalar(); T f1 = f1Input.toScalar();
T f2 = f2Input.toScalar(); T f2 = f2Input.toScalar();
if (std::isnan(f1) || std::isnan(f2) || f1 != (int)f1 || f2 != (int)f2) { if (std::isnan(f1) || std::isnan(f2) || f1 != (int)f1 || f2 != (int)f2) {

6
poincare/src/division_remainder.cpp
View File

@@ -25,9 +25,9 @@ Expression DivisionRemainderNode::shallowReduce(ReductionContext reductionContex
} }
template<typename T> template<typename T>
Evaluation<T> DivisionRemainderNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { Evaluation<T> DivisionRemainderNode::templatedApproximate(ApproximationContext approximationContext) const {
Evaluation<T> f1Input = childAtIndex(0)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> f1Input = childAtIndex(0)->approximate(T(), approximationContext);
Evaluation<T> f2Input = childAtIndex(1)->approximate(T(), context, complexFormat, angleUnit); Evaluation<T> f2Input = childAtIndex(1)->approximate(T(), approximationContext);
T f1 = f1Input.toScalar(); T f1 = f1Input.toScalar();
T f2 = f2Input.toScalar(); T f2 = f2Input.toScalar();
if (std::isnan(f1) || std::isnan(f2) || f1 != (int)f1 || f2 != (int)f2) { if (std::isnan(f1) || std::isnan(f2) || f1 != (int)f1 || f2 != (int)f2) {

2
poincare/src/empty_expression.cpp
View File

@@ -13,7 +13,7 @@ Layout EmptyExpressionNode::createLayout(Preferences::PrintFloatMode floatDispla
return EmptyLayout::Builder(); return EmptyLayout::Builder();
} }
template<typename T> Evaluation<T> EmptyExpressionNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { template<typename T> Evaluation<T> EmptyExpressionNode::templatedApproximate(ApproximationContext approximationContext) const {
return Complex<T>::Undefined(); return Complex<T>::Undefined();
} }

Some files were not shown because too many files have changed in this diff Show More