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

[poincare] Change name: evaluate->approximate

Browse Source 
Change-Id: I649a7c640190713dcf063a4148decd6038e62796
This commit is contained in:
Émilie Feral
2017-11-24 13:25:27 +01:00
parent 76cbd2678d
commit fda382cc0d
107 changed files with 385 additions and 385 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
apps/calculation/calculation.cpp
View File

@@ -70,7 +70,7 @@ void Calculation::setContent(const char * c, Context * context) {
m_exactOutput = input()->clone();
Expression::Simplify(&m_exactOutput, *context);
m_exactOutput->writeTextInBuffer(m_exactOutputText, sizeof(m_exactOutputText));
m_approximateOutput = m_exactOutput->evaluate<double>(*context);
m_approximateOutput = m_exactOutput->approximate<double>(*context);
m_approximateOutput->writeTextInBuffer(m_approximateOutputText, sizeof(m_approximateOutputText));
}
@@ -189,7 +189,7 @@ Expression * Calculation::approximateOutput(Context * context) {
* call 'evaluate'. */
Expression * exp = Expression::parse(m_approximateOutputText);
if (exp != nullptr) {
m_approximateOutput = exp->evaluate<double>(*context);
m_approximateOutput = exp->approximate<double>(*context);
delete exp;
} else {
m_approximateOutput = new Complex<double>(Complex<double>::Float(NAN));

6
apps/probability/law/binomial_law.cpp
View File

@@ -102,7 +102,7 @@ double BinomialLaw::rightIntegralInverseForProbability(double * probability) {
}
template<typename T>
T BinomialLaw::templatedEvaluateAtAbscissa(T x) const {
T BinomialLaw::templatedApproximateAtAbscissa(T x) const {
if (m_parameter1 == 0) {
if (m_parameter2 == 0 || m_parameter2 == 1) {
return NAN;
@@ -134,5 +134,5 @@ T BinomialLaw::templatedEvaluateAtAbscissa(T x) const {
}
template float Probability::BinomialLaw::templatedEvaluateAtAbscissa(float x) const;
template double Probability::BinomialLaw::templatedEvaluateAtAbscissa(double x) const;
template float Probability::BinomialLaw::templatedApproximateAtAbscissa(float x) const;
template double Probability::BinomialLaw::templatedApproximateAtAbscissa(double x) const;

6
apps/probability/law/binomial_law.h
View File

@@ -18,16 +18,16 @@ public:
I18n::Message parameterNameAtIndex(int index) override;
I18n::Message parameterDefinitionAtIndex(int index) override;
float evaluateAtAbscissa(float x) const override {
return templatedEvaluateAtAbscissa(x);
return templatedApproximateAtAbscissa(x);
}
bool authorizedValueAtIndex(float x, int index) const override;
double cumulativeDistributiveInverseForProbability(double * probability) override;
double rightIntegralInverseForProbability(double * probability) override;
protected:
double evaluateAtDiscreteAbscissa(int k) const override {
return templatedEvaluateAtAbscissa((double)k);
return templatedApproximateAtAbscissa((double)k);
}
template<typename T> T templatedEvaluateAtAbscissa(T x) const;
template<typename T> T templatedApproximateAtAbscissa(T x) const;
};
}

6
apps/probability/law/poisson_law.cpp
View File

@@ -63,7 +63,7 @@ bool PoissonLaw::authorizedValueAtIndex(float x, int index) const {
}
template<typename T>
T PoissonLaw::templatedEvaluateAtAbscissa(T x) const {
T PoissonLaw::templatedApproximateAtAbscissa(T x) const {
if (x < 0) {
return NAN;
}
@@ -73,5 +73,5 @@ T PoissonLaw::templatedEvaluateAtAbscissa(T x) const {
}
template float Probability::PoissonLaw::templatedEvaluateAtAbscissa(float x) const;
template double Probability::PoissonLaw::templatedEvaluateAtAbscissa(double x) const;
template float Probability::PoissonLaw::templatedApproximateAtAbscissa(float x) const;
template double Probability::PoissonLaw::templatedApproximateAtAbscissa(double x) const;

6
apps/probability/law/poisson_law.h
View File

@@ -18,14 +18,14 @@ public:
I18n::Message parameterNameAtIndex(int index) override;
I18n::Message parameterDefinitionAtIndex(int index) override;
float evaluateAtAbscissa(float x) const override {
return templatedEvaluateAtAbscissa(x);
return templatedApproximateAtAbscissa(x);
}
bool authorizedValueAtIndex(float x, int index) const override;
private:
double evaluateAtDiscreteAbscissa(int k) const override {
return templatedEvaluateAtAbscissa((double)k);
return templatedApproximateAtAbscissa((double)k);
}
template<typename T> T templatedEvaluateAtAbscissa(T x) const;
template<typename T> T templatedApproximateAtAbscissa(T x) const;
};
}

2
apps/sequence/sequence.cpp
View File

@@ -267,7 +267,7 @@ bool Sequence::isEmpty() {
}
template<typename T>
T Sequence::templatedEvaluateAtAbscissa(T x, Poincare::Context * context) const {
T Sequence::templatedApproximateAtAbscissa(T x, Poincare::Context * context) const {
T n = std::round(x);
switch (m_type) {
case Type::Explicite:

6
apps/sequence/sequence.h
View File

@@ -39,10 +39,10 @@ public:
bool isDefined() override;
bool isEmpty() override;
float evaluateAtAbscissa(float x, Poincare::Context * context) const override {
return templatedEvaluateAtAbscissa(x, context);
return templatedApproximateAtAbscissa(x, context);
}
double evaluateAtAbscissa(double x, Poincare::Context * context) const override {
return templatedEvaluateAtAbscissa(x, context);
return templatedApproximateAtAbscissa(x, context);
}
double sumOfTermsBetweenAbscissa(double start, double end, Poincare::Context * context);
void tidy() override;
@@ -52,7 +52,7 @@ private:
constexpr static size_t k_dataLengthInBytes = (3*TextField::maxBufferSize()+3)*sizeof(char)+1;
static_assert((k_dataLengthInBytes & 0x3) == 0, "The sequence data size is not a multiple of 4 bytes (cannot compute crc)"); // Assert that dataLengthInBytes is a multiple of 4
char symbol() const override;
template<typename T> T templatedEvaluateAtAbscissa(T x, Poincare::Context * context) const;
template<typename T> T templatedApproximateAtAbscissa(T x, Poincare::Context * context) const;
Type m_type;
char m_firstInitialConditionText[TextField::maxBufferSize()];
char m_secondInitialConditionText[TextField::maxBufferSize()];

6
apps/shared/function.cpp
View File

@@ -100,7 +100,7 @@ bool Function::isEmpty() {
}
template<typename T>
T Function::templatedEvaluateAtAbscissa(T x, Poincare::Context * context) const {
T Function::templatedApproximateAtAbscissa(T x, Poincare::Context * context) const {
Poincare::VariableContext<T> variableContext = Poincare::VariableContext<T>(symbol(), context);
Poincare::Symbol xSymbol(symbol());
Poincare::Complex<T> e = Poincare::Complex<T>::Float(x);
@@ -121,5 +121,5 @@ void Function::tidy() {
}
template float Shared::Function::templatedEvaluateAtAbscissa<float>(float, Poincare::Context*) const;
template double Shared::Function::templatedEvaluateAtAbscissa<double>(double, Poincare::Context*) const;
template float Shared::Function::templatedApproximateAtAbscissa<float>(float, Poincare::Context*) const;
template double Shared::Function::templatedApproximateAtAbscissa<double>(double, Poincare::Context*) const;

6
apps/shared/function.h
View File

@@ -28,16 +28,16 @@ public:
virtual void setContent(const char * c);
void setColor(KDColor m_color);
virtual float evaluateAtAbscissa(float x, Poincare::Context * context) const {
return templatedEvaluateAtAbscissa(x, context);
return templatedApproximateAtAbscissa(x, context);
}
virtual double evaluateAtAbscissa(double x, Poincare::Context * context) const {
return templatedEvaluateAtAbscissa(x, context);
return templatedApproximateAtAbscissa(x, context);
}
virtual void tidy();
private:
constexpr static size_t k_dataLengthInBytes = (TextField::maxBufferSize()+2)*sizeof(char)+2;
static_assert((k_dataLengthInBytes & 0x3) == 0, "The function data size is not a multiple of 4 bytes (cannot compute crc)"); // Assert that dataLengthInBytes is a multiple of 4
template<typename T> T templatedEvaluateAtAbscissa(T x, Poincare::Context * context) const;
template<typename T> T templatedApproximateAtAbscissa(T x, Poincare::Context * context) const;
virtual char symbol() const = 0;
mutable Poincare::Expression * m_expression;
char m_text[TextField::maxBufferSize()];

2
poincare/Makefile
View File

@@ -25,7 +25,7 @@ objs += $(addprefix poincare/src/,\
division_quotient.o\
division_remainder.o\
dynamic_hierarchy.o\
evaluation_engine.o\
approximation_engine.o\
expression.o\
expression_lexer.o\
expression_parser.o\

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

@@ -2,7 +2,7 @@
#define POINCARE_ABSOLUTE_VALUE_H
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
#include <poincare/layout_engine.h>
namespace Poincare {
@@ -24,11 +24,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -4,7 +4,7 @@
#include <poincare/dynamic_hierarchy.h>
#include <poincare/rational.h>
#include <poincare/layout_engine.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -19,10 +19,10 @@ public:
/* Evaluation */
template<typename T> static Complex<T> compute(const Complex<T> c, const Complex<T> d);
template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n) {
return EvaluationEngine::elementWiseOnComplexMatrices(m, n, compute<T>);
return ApproximationEngine::elementWiseOnComplexMatrices(m, n, compute<T>);
}
template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * m) {
return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
}
private:
/* Layout */
@@ -43,13 +43,13 @@ private:
static bool TermsHaveIdenticalNonRationalFactors(const Expression * e1, const Expression * e2);
/* Evaluation */
template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * c) {
return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
}
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
}
};

6
poincare/include/poincare/evaluation_engine.h → poincare/include/poincare/approximation_engine.h
View File

@@ -1,5 +1,5 @@
#ifndef POINCARE_EVALUATION_ENGINE_H
#define POINCARE_EVALUATION_ENGINE_H
#ifndef POINCARE_APPROXIMATION_ENGINE_H
#define POINCARE_APPROXIMATION_ENGINE_H
#include <poincare/expression.h>
#include <poincare/complex.h>
@@ -7,7 +7,7 @@
namespace Poincare {
class EvaluationEngine {
class ApproximationEngine {
public:
template <typename T> using ComplexCompute = Complex<T>(*)(const Complex<T>, Expression::AngleUnit angleUnit);
template<typename T> static Expression * map(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexCompute<T> compute);

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -27,11 +27,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -21,9 +21,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -23,11 +23,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -67,9 +67,9 @@ private:
Complex(T a, T b);
constexpr static int k_numberOfSignificantDigits = 7;
ExpressionLayout * privateCreateLayout(Expression::FloatDisplayMode floatDisplayMode, Expression::ComplexFormat complexFormat) const override;
Expression * privateEvaluate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename U> Complex<U> * templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const;
Expression * privateApproximate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename U> Complex<U> * templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const;
/* We here define the buffer size to write the lengthest float possible.
* At maximum, the number has 7 significant digits so, in the worst case it
* has the form -1.999999e-308 (7+7+1 char) (the auto mode is always

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -23,9 +23,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -2,7 +2,7 @@
#define POINCARE_CONJUGATE_H
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
#include <poincare/layout_engine.h>
namespace Poincare {
@@ -22,11 +22,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
#include <poincare/trigonometry.h>
namespace Poincare {
@@ -27,11 +27,11 @@ private:
/* Simplication */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -37,9 +37,9 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
Expression * shallowBeautify(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const;
constexpr static int k_maxLength = 10;
Integer m_mantissa;

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
template<typename T> T growthRateAroundAbscissa(T x, T h, VariableContext<T> variableContext, AngleUnit angleUnit) const;
template<typename T> T approximateDerivate2(T x, T h, VariableContext<T> xContext, AngleUnit angleUnit) const;
// TODO: Change coefficients?

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -2,7 +2,7 @@
#define POINCARE_DIVISION_H
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
#include <poincare/layout_engine.h>
namespace Poincare {
@@ -27,16 +27,16 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * c) {
return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
}
template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * n);
template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n);
virtual Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
virtual Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
}
virtual Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
virtual Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
}
};

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};

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

@@ -72,7 +72,7 @@ class Expression {
friend class SimplificationRoot;
friend class Sequence;
friend class Trigonometry;
friend class EvaluationEngine;
friend class ApproximationEngine;
friend class SimplificationEngine;
public:
@@ -213,7 +213,7 @@ public:
/* Evaluation Engine
* The function evaluate creates a new expression and thus mallocs memory.
* Do not forget to delete the new expression to avoid leaking. */
template<typename T> Expression * evaluate(Context& context, AngleUnit angleUnit = AngleUnit::Default) const;
template<typename T> Expression * approximate(Context& context, AngleUnit angleUnit = AngleUnit::Default) const;
template<typename T> T approximateToScalar(Context& context, AngleUnit angleUnit = AngleUnit::Default) const;
template<typename T> static T approximateToScalar(const char * text, Context& context, AngleUnit angleUnit = AngleUnit::Default);
protected:
@@ -267,8 +267,8 @@ private:
return nullptr;
}
/* Evaluation Engine */
virtual Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const = 0;
virtual Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const = 0;
virtual Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const = 0;
virtual Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const = 0;
Expression * m_parent;
};

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

@@ -2,7 +2,7 @@
#define POINCARE_FACTORIAL_H
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -14,11 +14,11 @@ public:
private:
constexpr static int k_maxOperandValue = 100;
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -23,11 +23,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit, computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -22,9 +22,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
template<typename T>
struct DetailedResult
{

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -26,9 +26,9 @@ private:
Expression * splitInteger(Integer i, bool isDenominator, Context & context, AngleUnit angleUnit);
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -33,9 +33,9 @@ private:
/* Layout */
ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
int m_numberOfRows;
};

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context & context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -3,7 +3,7 @@
#include <poincare/dynamic_hierarchy.h>
#include <poincare/layout_engine.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -22,7 +22,7 @@ public:
/* Evaluation */
template<typename T> static Complex<T> compute(const Complex<T> c, const Complex<T> d);
template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * m) {
return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
}
template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n);
private:
@@ -52,13 +52,13 @@ private:
/* Evaluation */
template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * c) {
return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
}
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -22,9 +22,9 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> compute(const Complex<T> c, const Complex<T> d);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};

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

@@ -3,7 +3,7 @@
#include <poincare/static_hierarchy.h>
#include <poincare/layout_engine.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -20,11 +20,11 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit, compute<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit, compute<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, compute<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, compute<double>);
}
};

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

@@ -21,9 +21,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};

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

@@ -25,9 +25,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -2,7 +2,7 @@
#define POINCARE_POWER_H
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
#include <poincare/rational.h>
#include <poincare/multiplication.h>
@@ -55,11 +55,11 @@ private:
template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * n) { return nullptr; }
template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * d);
template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n) { return nullptr; }
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
}
};

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

@@ -23,9 +23,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -15,12 +15,12 @@ private:
int emptySequenceValue() const override;
ExpressionLayout * createSequenceLayoutWithArgumentLayouts(ExpressionLayout * subscriptLayout, ExpressionLayout * superscriptLayout, ExpressionLayout * argumentLayout) const override;
Expression * evaluateWithNextTerm(DoublePrecision p, Expression * a, Expression * b) const override {
return templatedEvaluateWithNextTerm<double>(a, b);
return templatedApproximateWithNextTerm<double>(a, b);
}
Expression * evaluateWithNextTerm(SinglePrecision p, Expression * a, Expression * b) const override {
return templatedEvaluateWithNextTerm<float>(a, b);
return templatedApproximateWithNextTerm<float>(a, b);
}
template<typename T> Expression * templatedEvaluateWithNextTerm(Expression * a, Expression * b) const;
template<typename T> Expression * templatedApproximateWithNextTerm(Expression * a, Expression * b) const;
};
}

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

@@ -44,9 +44,9 @@ public:
private:
ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
int writeTextInBuffer(char * buffer, int bufferSize) const override;
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename U> Complex<U> * templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename U> Complex<U> * templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const;
Expression * shallowBeautify(Context & context, AngleUnit angleUnit) override;
Expression * setSign(Sign s);
Expression * setSign(Sign s, Context & context, AngleUnit angleUnit) override {

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -25,11 +25,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -24,9 +24,9 @@ private:
/* Simplification */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Complex */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -17,9 +17,9 @@ private:
virtual ExpressionLayout * createSequenceLayoutWithArgumentLayouts(ExpressionLayout * subscriptLayout, ExpressionLayout * superscriptLayout, ExpressionLayout * argumentLayout) const = 0;
virtual const char * name() const = 0;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
virtual int emptySequenceValue() const = 0;
virtual Expression * evaluateWithNextTerm(SinglePrecision p, Expression * a, Expression * b) const = 0;
virtual Expression * evaluateWithNextTerm(DoublePrecision p, Expression * a, Expression * b) const = 0;

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

@@ -23,11 +23,11 @@ public:
return nullptr;
}
int writeTextInBuffer(char * buffer, int bufferSize) const override { return 0; }
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
assert(false);
return nullptr;
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
assert(false);
return nullptr;
}

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
#include <poincare/trigonometry.h>
namespace Poincare {
@@ -27,11 +27,11 @@ private:
/* Simplication */
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -20,11 +20,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -18,9 +18,9 @@ private:
ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
int writeTextInBuffer(char * buffer, int bufferSize) const override;
/* Evalutation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
const Symbol * symbol() const { return static_cast<const Symbol *>(operand(1)); }
const Expression * value() const { return operand(0); }

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

@@ -3,7 +3,7 @@
#include <poincare/static_hierarchy.h>
#include <poincare/layout_engine.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -26,18 +26,18 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Matrix * computeOnMatrixAndComplex(const Matrix * m, const Complex<T> * c) {
return EvaluationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
return ApproximationEngine::elementWiseOnComplexAndComplexMatrix(c, m, compute<T>);
}
template<typename T> static Matrix * computeOnComplexAndMatrix(const Complex<T> * c, const Matrix * n);
template<typename T> static Matrix * computeOnMatrices(const Matrix * m, const Matrix * n) {
return EvaluationEngine::elementWiseOnComplexMatrices(m, n, compute<T>);
return ApproximationEngine::elementWiseOnComplexMatrices(m, n, compute<T>);
}
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<float>(this, context, angleUnit, compute<float>, computeOnComplexAndMatrix<float>, computeOnMatrixAndComplex<float>, computeOnMatrices<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::mapReduce<double>(this, context, angleUnit, compute<double>, computeOnComplexAndMatrix<double>, computeOnMatrixAndComplex<double>, computeOnMatrices<double>);
}
};

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

@@ -15,12 +15,12 @@ private:
int emptySequenceValue() const override;
ExpressionLayout * createSequenceLayoutWithArgumentLayouts(ExpressionLayout * subscriptLayout, ExpressionLayout * superscriptLayout, ExpressionLayout * argumentLayout) const override;
Expression * evaluateWithNextTerm(DoublePrecision p, Expression * a, Expression * b) const override {
return templatedEvaluateWithNextTerm<double>(a, b);
return templatedApproximateWithNextTerm<double>(a, b);
}
Expression * evaluateWithNextTerm(SinglePrecision p, Expression * a, Expression * b) const override {
return templatedEvaluateWithNextTerm<float>(a, b);
return templatedApproximateWithNextTerm<float>(a, b);
}
template<typename T> Expression * templatedEvaluateWithNextTerm(Expression * a, Expression * b) const;
template<typename T> Expression * templatedApproximateWithNextTerm(Expression * a, Expression * b) const;
};
}

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

@@ -44,9 +44,9 @@ private:
ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
int writeTextInBuffer(char * buffer, int bufferSize) const override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Expression * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Expression * templatedApproximate(Context& context, AngleUnit angleUnit) const;
const char m_name;
};

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

@@ -3,7 +3,7 @@
#include <poincare/layout_engine.h>
#include <poincare/static_hierarchy.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
namespace Poincare {
@@ -26,11 +26,11 @@ private:
Expression * shallowReduce(Context& context, AngleUnit angleUnit) override;
/* Evaluation */
template<typename T> static Complex<T> computeOnComplex(const Complex<T> c, AngleUnit angleUnit = AngleUnit::Radian);
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<float>(this, context, angleUnit,computeOnComplex<float>);
}
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return EvaluationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override {
return ApproximationEngine::map<double>(this, context, angleUnit, computeOnComplex<double>);
}
};

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

@@ -15,9 +15,9 @@ private:
/* Layout */
ExpressionLayout * privateCreateLayout(FloatDisplayMode floatDisplayMode, ComplexFormat complexFormat) const override;
/* Evaluation */
Expression * privateEvaluate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<float>(context, angleUnit); }
Expression * privateEvaluate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedEvaluate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedEvaluate(Context& context, AngleUnit angleUnit) const;
Expression * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Expression * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }
template<typename T> Complex<T> * templatedApproximate(Context& context, AngleUnit angleUnit) const;
};
}

32
poincare/src/evaluation_engine.cpp → poincare/src/approximation_engine.cpp
View File

@@ -1,4 +1,4 @@
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
#include <poincare/matrix.h>
#include <cmath>
extern "C" {
@@ -7,9 +7,9 @@ extern "C" {
namespace Poincare {
template<typename T> Expression * EvaluationEngine::map(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexCompute<T> compute) {
template<typename T> Expression * ApproximationEngine::map(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexCompute<T> compute) {
assert(expression->numberOfOperands() == 1);
Expression * input = expression->operand(0)->evaluate<T>(context, angleUnit);
Expression * input = expression->operand(0)->approximate<T>(context, angleUnit);
Expression * result = nullptr;
if (input->type() == Expression::Type::Complex) {
Complex<T> * c = static_cast<Complex<T> *>(input);
@@ -29,11 +29,11 @@ template<typename T> Expression * EvaluationEngine::map(const Expression * expre
return result;
}
template<typename T> Expression * EvaluationEngine::mapReduce(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexAndComplexReduction<T> computeOnComplexes, ComplexAndMatrixReduction<T> computeOnComplexAndMatrix, MatrixAndComplexReduction<T> computeOnMatrixAndComplex, MatrixAndMatrixReduction<T> computeOnMatrices) {
Expression * result = expression->operand(0)->evaluate<T>(context, angleUnit);
template<typename T> Expression * ApproximationEngine::mapReduce(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexAndComplexReduction<T> computeOnComplexes, ComplexAndMatrixReduction<T> computeOnComplexAndMatrix, MatrixAndComplexReduction<T> computeOnMatrixAndComplex, MatrixAndMatrixReduction<T> computeOnMatrices) {
Expression * result = expression->operand(0)->approximate<T>(context, angleUnit);
for (int i = 1; i < expression->numberOfOperands(); i++) {
Expression * intermediateResult = nullptr;
Expression * nextOperandEvaluation = expression->operand(i)->evaluate<T>(context, angleUnit);
Expression * nextOperandEvaluation = expression->operand(i)->approximate<T>(context, angleUnit);
if (result->type() == Expression::Type::Complex && nextOperandEvaluation->type() == Expression::Type::Complex) {
const Complex<T> * c = static_cast<const Complex<T> *>(result);
const Complex<T> * d = static_cast<const Complex<T> *>(nextOperandEvaluation);
@@ -65,7 +65,7 @@ template<typename T> Expression * EvaluationEngine::mapReduce(const Expression *
return result;
}
template<typename T> Matrix * EvaluationEngine::elementWiseOnComplexAndComplexMatrix(const Complex<T> * c, const Matrix * m, ComplexAndComplexReduction<T> computeOnComplexes) {
template<typename T> Matrix * ApproximationEngine::elementWiseOnComplexAndComplexMatrix(const Complex<T> * c, const Matrix * m, ComplexAndComplexReduction<T> computeOnComplexes) {
Expression ** operands = new Expression * [m->numberOfRows()*m->numberOfColumns()];
for (int i = 0; i < m->numberOfOperands(); i++) {
const Complex<T> * d = static_cast<const Complex<T> *>(m->operand(i));
@@ -76,7 +76,7 @@ template<typename T> Matrix * EvaluationEngine::elementWiseOnComplexAndComplexMa
return result;
}
template<typename T> Matrix * EvaluationEngine::elementWiseOnComplexMatrices(const Matrix * m, const Matrix * n, ComplexAndComplexReduction<T> computeOnComplexes) {
template<typename T> Matrix * ApproximationEngine::elementWiseOnComplexMatrices(const Matrix * m, const Matrix * n, ComplexAndComplexReduction<T> computeOnComplexes) {
if (m->numberOfRows() != n->numberOfRows() || m->numberOfColumns() != n->numberOfColumns()) {
return nullptr;
}
@@ -91,14 +91,14 @@ template<typename T> Matrix * EvaluationEngine::elementWiseOnComplexMatrices(con
return result;
}
template Poincare::Expression * Poincare::EvaluationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::EvaluationEngine::ComplexCompute<float> compute);
template Poincare::Expression * Poincare::EvaluationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::EvaluationEngine::ComplexCompute<double> compute);
template Poincare::Expression * Poincare::EvaluationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::EvaluationEngine::ComplexAndComplexReduction<float> computeOnComplexes, Poincare::EvaluationEngine::ComplexAndMatrixReduction<float> computeOnComplexAndMatrix, Poincare::EvaluationEngine::MatrixAndComplexReduction<float> computeOnMatrixAndComplex, Poincare::EvaluationEngine::MatrixAndMatrixReduction<float> computeOnMatrices);
template Poincare::Expression * Poincare::EvaluationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::EvaluationEngine::ComplexAndComplexReduction<double> computeOnComplexes, Poincare::EvaluationEngine::ComplexAndMatrixReduction<double> computeOnComplexAndMatrix, Poincare::EvaluationEngine::MatrixAndComplexReduction<double> computeOnMatrixAndComplex, Poincare::EvaluationEngine::MatrixAndMatrixReduction<double> computeOnMatrices);
template Poincare::Matrix * Poincare::EvaluationEngine::elementWiseOnComplexAndComplexMatrix<float>(Poincare::Complex<float> const*, const Poincare::Matrix *, Poincare::Complex<float> (*)(Poincare::Complex<float>, Poincare::Complex<float>));
template Poincare::Matrix* Poincare::EvaluationEngine::elementWiseOnComplexAndComplexMatrix<double>(Poincare::Complex<double> const*, const Poincare::Matrix*, Poincare::Complex<double> (*)(Poincare::Complex<double>, Poincare::Complex<double>));
template Poincare::Matrix* Poincare::EvaluationEngine::elementWiseOnComplexMatrices<float>(const Poincare::Matrix*, const Poincare::Matrix*, Poincare::Complex<float> (*)(Poincare::Complex<float>, Poincare::Complex<float>));
template Poincare::Matrix* Poincare::EvaluationEngine::elementWiseOnComplexMatrices<double>(const Poincare::Matrix*, const Poincare::Matrix*, Poincare::Complex<double> (*)(Poincare::Complex<double>, Poincare::Complex<double>));
template Poincare::Expression * Poincare::ApproximationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexCompute<float> compute);
template Poincare::Expression * Poincare::ApproximationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexCompute<double> compute);
template Poincare::Expression * Poincare::ApproximationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexAndComplexReduction<float> computeOnComplexes, Poincare::ApproximationEngine::ComplexAndMatrixReduction<float> computeOnComplexAndMatrix, Poincare::ApproximationEngine::MatrixAndComplexReduction<float> computeOnMatrixAndComplex, Poincare::ApproximationEngine::MatrixAndMatrixReduction<float> computeOnMatrices);
template Poincare::Expression * Poincare::ApproximationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexAndComplexReduction<double> computeOnComplexes, Poincare::ApproximationEngine::ComplexAndMatrixReduction<double> computeOnComplexAndMatrix, Poincare::ApproximationEngine::MatrixAndComplexReduction<double> computeOnMatrixAndComplex, Poincare::ApproximationEngine::MatrixAndMatrixReduction<double> computeOnMatrices);
template Poincare::Matrix * Poincare::ApproximationEngine::elementWiseOnComplexAndComplexMatrix<float>(Poincare::Complex<float> const*, const Poincare::Matrix *, Poincare::Complex<float> (*)(Poincare::Complex<float>, Poincare::Complex<float>));
template Poincare::Matrix* Poincare::ApproximationEngine::elementWiseOnComplexAndComplexMatrix<double>(Poincare::Complex<double> const*, const Poincare::Matrix*, Poincare::Complex<double> (*)(Poincare::Complex<double>, Poincare::Complex<double>));
template Poincare::Matrix* Poincare::ApproximationEngine::elementWiseOnComplexMatrices<float>(const Poincare::Matrix*, const Poincare::Matrix*, Poincare::Complex<float> (*)(Poincare::Complex<float>, Poincare::Complex<float>));
template Poincare::Matrix* Poincare::ApproximationEngine::elementWiseOnComplexMatrices<double>(const Poincare::Matrix*, const Poincare::Matrix*, Poincare::Complex<double> (*)(Poincare::Complex<double>, Poincare::Complex<double>));
}

6
poincare/src/binomial_coefficient.cpp
View File

@@ -83,9 +83,9 @@ ExpressionLayout * BinomialCoefficient::privateCreateLayout(FloatDisplayMode flo
}
template<typename T>
Expression * BinomialCoefficient::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * nInput = operand(0)->evaluate<T>(context, angleUnit);
Expression * kInput = operand(1)->evaluate<T>(context, angleUnit);
Expression * BinomialCoefficient::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * nInput = operand(0)->approximate<T>(context, angleUnit);
Expression * kInput = operand(1)->approximate<T>(context, angleUnit);
if (nInput->type() != Type::Complex || kInput->type() != Type::Complex) {
return new Complex<T>(Complex<T>::Float(NAN));
}

10
poincare/src/complex.cpp
View File

@@ -248,7 +248,7 @@ ExpressionLayout * Complex<T>::privateCreateLayout(Expression::FloatDisplayMode
template<typename T>
template<typename U>
Complex<U> * Complex<T>::templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const {
Complex<U> * Complex<T>::templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const {
return new Complex<U>(Complex<U>::Cartesian((U)m_a, (U)m_b));
}
@@ -478,10 +478,10 @@ ExpressionLayout * Complex<T>::createCartesianLayout(Expression::FloatDisplayMod
template class Complex<float>;
template class Complex<double>;
template Complex<double>* Complex<double>::templatedEvaluate<double>(Context&, Expression::AngleUnit) const;
template Complex<float>* Complex<double>::templatedEvaluate<float>(Context&, Expression::AngleUnit) const;
template Complex<double>* Complex<float>::templatedEvaluate<double>(Context&, Expression::AngleUnit) const;
template Complex<float>* Complex<float>::templatedEvaluate<float>(Context&, Expression::AngleUnit) const;
template Complex<double>* Complex<double>::templatedApproximate<double>(Context&, Expression::AngleUnit) const;
template Complex<float>* Complex<double>::templatedApproximate<float>(Context&, Expression::AngleUnit) const;
template Complex<double>* Complex<float>::templatedApproximate<double>(Context&, Expression::AngleUnit) const;
template Complex<float>* Complex<float>::templatedApproximate<float>(Context&, Expression::AngleUnit) const;
}

6
poincare/src/confidence_interval.cpp
View File

@@ -59,9 +59,9 @@ Expression * ConfidenceInterval::shallowReduce(Context& context, AngleUnit angle
}
template<typename T>
Expression * ConfidenceInterval::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * fInput = operand(0)->evaluate<T>(context, angleUnit);
Expression * nInput = operand(1)->evaluate<T>(context, angleUnit);
Expression * ConfidenceInterval::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * fInput = operand(0)->approximate<T>(context, angleUnit);
Expression * nInput = operand(1)->approximate<T>(context, angleUnit);
if (fInput->type() != Type::Complex || nInput->type() != Type::Complex) {
return new Complex<T>(Complex<T>::Float(NAN));
}

2
poincare/src/decimal.cpp
View File

@@ -107,7 +107,7 @@ Expression * Decimal::clone() const {
return new Decimal(m_mantissa, m_exponent);
}
template<typename T> Expression * Decimal::templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const {
template<typename T> Expression * Decimal::templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const {
T m = m_mantissa.approximate<T>();
int numberOfDigits = numberOfDigitsInMantissaWithoutSign();
return new Complex<T>(Complex<T>::Float(m*std::pow((T)10.0, (T)(m_exponent-numberOfDigits+1))));

16
poincare/src/derivative.cpp
View File

@@ -35,17 +35,17 @@ Expression * Derivative::shallowReduce(Context& context, AngleUnit angleUnit) {
}
template<typename T>
Expression * Derivative::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * Derivative::templatedApproximate(Context& context, AngleUnit angleUnit) const {
static T min = sizeof(T) == sizeof(double) ? DBL_MIN : FLT_MIN;
static T max = sizeof(T) == sizeof(double) ? DBL_MAX : FLT_MAX;
VariableContext<T> xContext = VariableContext<T>('x', &context);
Symbol xSymbol('x');
Expression * xInput = operand(1)->evaluate<T>(context, angleUnit);
Expression * xInput = operand(1)->approximate<T>(context, angleUnit);
T x = xInput->type() == Type::Complex ? static_cast<Complex<T> *>(xInput)->toScalar() : NAN;
delete xInput;
Complex<T> e = Complex<T>::Float(x);
xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
Expression * fInput = operand(0)->evaluate<T>(xContext, angleUnit);
Expression * fInput = operand(0)->approximate<T>(xContext, angleUnit);
T functionValue = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
delete fInput;
@@ -123,12 +123,12 @@ T Derivative::growthRateAroundAbscissa(T x, T h, VariableContext<T> xContext, An
Symbol xSymbol('x');
Complex<T> e = Complex<T>::Float(x + h);
xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
Expression * fInput = operand(0)->evaluate<T>(xContext, angleUnit);
Expression * fInput = operand(0)->approximate<T>(xContext, angleUnit);
T expressionPlus = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
delete fInput;
e = Complex<T>::Float(x-h);
xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
fInput = operand(0)->evaluate<T>(xContext, angleUnit);
fInput = operand(0)->approximate<T>(xContext, angleUnit);
T expressionMinus = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
delete fInput;
return (expressionPlus - expressionMinus)/(2*h);
@@ -139,17 +139,17 @@ T Derivative::approximateDerivate2(T x, T h, VariableContext<T> xContext, AngleU
Symbol xSymbol('x');
Complex<T> e = Complex<T>::Float(x + h);
xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
Expression * fInput = operand(0)->evaluate<T>(xContext, angleUnit);
Expression * fInput = operand(0)->approximate<T>(xContext, angleUnit);
T expressionPlus = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
delete fInput;
e = Complex<T>::Float(x);
xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
fInput = operand(0)->evaluate<T>(xContext, angleUnit);
fInput = operand(0)->approximate<T>(xContext, angleUnit);
T expression = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
delete fInput;
e = Complex<T>::Float(x-h);
xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
fInput = operand(0)->evaluate<T>(xContext, angleUnit);
fInput = operand(0)->approximate<T>(xContext, angleUnit);
T expressionMinus = fInput->type() == Type::Complex ? static_cast<Complex<T> *>(fInput)->toScalar() : NAN;
delete fInput;
return expressionPlus - 2.0*expression + expressionMinus;

4
poincare/src/determinant.cpp
View File

@@ -34,8 +34,8 @@ Expression * Determinant::shallowReduce(Context& context, AngleUnit angleUnit) {
// TODO: handle this exactly in shallowReduce for small dimensions.
template<typename T>
Expression * Determinant::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->evaluate<T>(context, angleUnit);
Expression * Determinant::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->approximate<T>(context, angleUnit);
Expression * result = nullptr;
if (input->type() == Type::Complex) {
result = input->clone();

6
poincare/src/division_quotient.cpp
View File

@@ -58,9 +58,9 @@ Expression * DivisionQuotient::shallowReduce(Context& context, AngleUnit angleUn
}
template<typename T>
Complex<T> * DivisionQuotient::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
Complex<T> * DivisionQuotient::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
delete f1Input;

6
poincare/src/division_remainder.cpp
View File

@@ -58,9 +58,9 @@ Expression * DivisionRemainder::shallowReduce(Context& context, AngleUnit angleU
}
template<typename T>
Complex<T> * DivisionRemainder::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
Complex<T> * DivisionRemainder::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
delete f1Input;

12
poincare/src/expression.cpp
View File

@@ -253,17 +253,17 @@ Expression * Expression::deepBeautify(Context & context, AngleUnit angleUnit) {
/* Evaluation */
template<typename T> Expression * Expression::evaluate(Context& context, AngleUnit angleUnit) const {
template<typename T> Expression * Expression::approximate(Context& context, AngleUnit angleUnit) const {
switch (angleUnit) {
case AngleUnit::Default:
return privateEvaluate(T(), context, Preferences::sharedPreferences()->angleUnit());
return privateApproximate(T(), context, Preferences::sharedPreferences()->angleUnit());
default:
return privateEvaluate(T(), context, angleUnit);
return privateApproximate(T(), context, angleUnit);
}
}
template<typename T> T Expression::approximateToScalar(Context& context, AngleUnit angleUnit) const {
Expression * evaluation = evaluate<T>(context, angleUnit);
Expression * evaluation = approximate<T>(context, angleUnit);
assert(evaluation->type() == Type::Complex || evaluation->type() == Type::Matrix);
T result = NAN;
if (evaluation->type() == Type::Complex) {
@@ -292,8 +292,8 @@ template<typename T> T Expression::epsilon() {
}
template Poincare::Expression * Poincare::Expression::evaluate<double>(Context& context, AngleUnit angleUnit) const;
template Poincare::Expression * Poincare::Expression::evaluate<float>(Context& context, AngleUnit angleUnit) const;
template Poincare::Expression * Poincare::Expression::approximate<double>(Context& context, AngleUnit angleUnit) const;
template Poincare::Expression * Poincare::Expression::approximate<float>(Context& context, AngleUnit angleUnit) const;
template double Poincare::Expression::approximateToScalar<double>(char const*, Poincare::Context&, Poincare::Expression::AngleUnit);
template float Poincare::Expression::approximateToScalar<float>(char const*, Poincare::Context&, Poincare::Expression::AngleUnit);
template double Poincare::Expression::approximateToScalar<double>(Poincare::Context&, Poincare::Expression::AngleUnit) const;

4
poincare/src/global_context.cpp
View File

@@ -77,7 +77,7 @@ void GlobalContext::setExpressionForSymbolName(const Expression * expression, co
if (symbol->isMatrixSymbol()) {
int indexMatrix = symbol->name() - (char)Symbol::SpecialSymbols::M0;
assert(indexMatrix >= 0 && indexMatrix < k_maxNumberOfMatrixExpressions);
Expression * evaluation = expression ? expression->evaluate<double>(context) : nullptr; // evaluate before deleting anything (to be able to evaluate M1+2->M1)
Expression * evaluation = expression ? expression->approximate<double>(context) : nullptr; // evaluate before deleting anything (to be able to evaluate M1+2->M1)
if (m_matrixExpressions[indexMatrix] != nullptr) {
delete m_matrixExpressions[indexMatrix];
m_matrixExpressions[indexMatrix] = nullptr;
@@ -95,7 +95,7 @@ void GlobalContext::setExpressionForSymbolName(const Expression * expression, co
if (index < 0 || index >= k_maxNumberOfScalarExpressions) {
return;
}
Expression * evaluation = expression ? expression->evaluate<double>(context) : nullptr; // evaluate before deleting anything (to be able to evaluate A+2->A)
Expression * evaluation = expression ? expression->approximate<double>(context) : nullptr; // evaluate before deleting anything (to be able to evaluate A+2->A)
if (m_expressions[index] != nullptr) {
delete m_expressions[index];
m_expressions[index] = nullptr;

6
poincare/src/great_common_divisor.cpp
View File

@@ -57,9 +57,9 @@ Expression * GreatCommonDivisor::shallowReduce(Context& context, AngleUnit angle
}
template<typename T>
Complex<T> * GreatCommonDivisor::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
Complex<T> * GreatCommonDivisor::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
delete f1Input;

8
poincare/src/integral.cpp
View File

@@ -37,12 +37,12 @@ Expression * Integral::shallowReduce(Context& context, AngleUnit angleUnit) {
}
template<typename T>
Complex<T> * Integral::templatedEvaluate(Context & context, AngleUnit angleUnit) const {
Complex<T> * Integral::templatedApproximate(Context & context, AngleUnit angleUnit) const {
VariableContext<T> xContext = VariableContext<T>('x', &context);
Expression * aInput = operand(1)->evaluate<T>(context, angleUnit);
Expression * aInput = operand(1)->approximate<T>(context, angleUnit);
T a = aInput->type() == Type::Complex ? static_cast<Complex<T> *>(aInput)->toScalar() : NAN;
delete aInput;
Expression * bInput = operand(2)->evaluate<T>(context, angleUnit);
Expression * bInput = operand(2)->approximate<T>(context, angleUnit);
T b = bInput->type() == Type::Complex ? static_cast<Complex<T> *>(bInput)->toScalar() : NAN;
delete bInput;
if (std::isnan(a) || std::isnan(b)) {
@@ -70,7 +70,7 @@ T Integral::functionValueAtAbscissa(T x, VariableContext<T> xContext, AngleUnit
Complex<T> e = Complex<T>::Float(x);
Symbol xSymbol('x');
xContext.setExpressionForSymbolName(&e, &xSymbol, xContext);
Expression * f = operand(0)->evaluate<T>(xContext, angleUnit);
Expression * f = operand(0)->approximate<T>(xContext, angleUnit);
T result = f->type() == Type::Complex ? static_cast<Complex<T> *>(f)->toScalar() : NAN;
delete f;
return result;

6
poincare/src/least_common_multiple.cpp
View File

@@ -57,9 +57,9 @@ Expression * LeastCommonMultiple::shallowReduce(Context& context, AngleUnit angl
}
template<typename T>
Complex<T> * LeastCommonMultiple::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
Complex<T> * LeastCommonMultiple::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
delete f1Input;

10
poincare/src/logarithm.cpp
View File

@@ -8,7 +8,7 @@
#include <poincare/arithmetic.h>
#include <poincare/power.h>
#include <poincare/naperian_logarithm.h>
#include <poincare/evaluation_engine.h>
#include <poincare/approximation_engine.h>
#include <poincare/simplification_engine.h>
#include <cmath>
#include <ion.h>
@@ -192,12 +192,12 @@ Expression * Logarithm::shallowBeautify(Context & context, AngleUnit angleUnit)
}
template<typename T>
Expression * Logarithm::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * Logarithm::templatedApproximate(Context& context, AngleUnit angleUnit) const {
if (numberOfOperands() == 1) {
return EvaluationEngine::map(this, context, angleUnit, computeOnComplex<T>);
return ApproximationEngine::map(this, context, angleUnit, computeOnComplex<T>);
}
Expression * x = operand(0)->evaluate<T>(context, angleUnit);
Expression * n = operand(1)->evaluate<T>(context, angleUnit);
Expression * x = operand(0)->approximate<T>(context, angleUnit);
Expression * n = operand(1)->approximate<T>(context, angleUnit);
Complex<T> result = Complex<T>::Float(NAN);
if (x->type() == Type::Complex && n->type() == Type::Complex) {
Complex<T> * xc = static_cast<Complex<T> *>(x);

4
poincare/src/matrix.cpp
View File

@@ -312,10 +312,10 @@ Matrix * Matrix::createApproximateIdentity(int dim) {
}
template<typename T>
Expression * Matrix::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * Matrix::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression ** operands = new Expression * [numberOfOperands()];
for (int i = 0; i < numberOfOperands(); i++) {
Expression * operandEvaluation = operand(i)->evaluate<T>(context, angleUnit);
Expression * operandEvaluation = operand(i)->approximate<T>(context, angleUnit);
if (operandEvaluation->type() != Type::Complex) {
operands[i] = new Complex<T>(Complex<T>::Float(NAN));
delete operandEvaluation;

4
poincare/src/matrix_dimension.cpp
View File

@@ -40,8 +40,8 @@ Expression * MatrixDimension::shallowReduce(Context& context, AngleUnit angleUni
}
template<typename T>
Expression * MatrixDimension::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->evaluate<T>(context, angleUnit);
Expression * MatrixDimension::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->approximate<T>(context, angleUnit);
Expression * operands[2];
if (input->type() == Type::Matrix) {
operands[0] = new Complex<T>(Complex<T>::Float((T)static_cast<Matrix *>(input)->numberOfRows()));

4
poincare/src/matrix_inverse.cpp
View File

@@ -46,8 +46,8 @@ Expression * MatrixInverse::shallowReduce(Context& context, AngleUnit angleUnit)
// TODO: handle this exactly in shallowReduce for small dimensions.
template<typename T>
Expression * MatrixInverse::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->evaluate<T>(context, angleUnit);
Expression * MatrixInverse::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->approximate<T>(context, angleUnit);
Expression * result = nullptr;
if (input->type() == Type::Complex) {
Complex<T> * c = static_cast<Complex<T> *>(input);

4
poincare/src/matrix_trace.cpp
View File

@@ -49,8 +49,8 @@ Expression * MatrixTrace::shallowReduce(Context& context, AngleUnit angleUnit) {
}
template<typename T>
Expression * MatrixTrace::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->evaluate<T>(context, angleUnit);
Expression * MatrixTrace::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->approximate<T>(context, angleUnit);
Expression * result = nullptr;
if (input->type() == Type::Complex) {
result = input->clone();

4
poincare/src/matrix_transpose.cpp
View File

@@ -39,8 +39,8 @@ Expression * MatrixTranspose::shallowReduce(Context& context, AngleUnit angleUni
}
template<typename T>
Expression * MatrixTranspose::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->evaluate<T>(context, angleUnit);
Expression * MatrixTranspose::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * input = operand(0)->approximate<T>(context, angleUnit);
Expression * result = nullptr;
if (input->type() == Type::Complex) {
result = input->clone();

6
poincare/src/nth_root.cpp
View File

@@ -54,9 +54,9 @@ Complex<T> NthRoot::compute(const Complex<T> c, const Complex<T> d) {
}
template<typename T>
Expression * NthRoot::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * base = operand(0)->evaluate<T>(context, angleUnit);
Expression * index = operand(1)->evaluate<T>(context, angleUnit);
Expression * NthRoot::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * base = operand(0)->approximate<T>(context, angleUnit);
Expression * index = operand(1)->approximate<T>(context, angleUnit);
Complex<T> result = Complex<T>::Float(NAN);
if (base->type() == Type::Complex && index->type() == Type::Complex) {
Complex<T> * basec = static_cast<Complex<T> *>(base);

4
poincare/src/parenthesis.cpp
View File

@@ -32,8 +32,8 @@ Expression * Parenthesis::shallowReduce(Context& context, AngleUnit angleUnit) {
}
template<typename T>
Expression * Parenthesis::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
return operand(0)->evaluate<T>(context, angleUnit);
Expression * Parenthesis::templatedApproximate(Context& context, AngleUnit angleUnit) const {
return operand(0)->approximate<T>(context, angleUnit);
}
}

6
poincare/src/permute_coefficient.cpp
View File

@@ -68,9 +68,9 @@ Expression * PermuteCoefficient::shallowReduce(Context& context, AngleUnit angle
}
template<typename T>
Complex<T> * PermuteCoefficient::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * nInput = operand(0)->evaluate<T>(context, angleUnit);
Expression * kInput = operand(1)->evaluate<T>(context, angleUnit);
Complex<T> * PermuteCoefficient::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * nInput = operand(0)->approximate<T>(context, angleUnit);
Expression * kInput = operand(1)->approximate<T>(context, angleUnit);
if (nInput->type() != Type::Complex || kInput->type() != Type::Complex) {
return new Complex<T>(Complex<T>::Float(NAN));
}

4
poincare/src/power.cpp
View File

@@ -183,8 +183,8 @@ Expression * Power::shallowReduce(Context& context, AngleUnit angleUnit) {
/* Step 0: if both operands are true complexes, the result is undefined.
* We can assert that evaluations is a complex as matrix are not simplified */
Complex<float> * op0 = static_cast<Complex<float> *>(operand(0)->evaluate<float>(context, angleUnit));
Complex<float> * op1 = static_cast<Complex<float> *>(operand(1)->evaluate<float>(context, angleUnit));
Complex<float> * op0 = static_cast<Complex<float> *>(operand(0)->approximate<float>(context, angleUnit));
Complex<float> * op1 = static_cast<Complex<float> *>(operand(1)->approximate<float>(context, angleUnit));
bool bothOperandsComplexes = op0->b() != 0 && op1->b() != 0;
delete op0;
delete op1;

6
poincare/src/prediction_interval.cpp
View File

@@ -68,9 +68,9 @@ Expression * PredictionInterval::shallowReduce(Context& context, AngleUnit angle
}
template<typename T>
Expression * PredictionInterval::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * pInput = operand(0)->evaluate<T>(context, angleUnit);
Expression * nInput = operand(1)->evaluate<T>(context, angleUnit);
Expression * PredictionInterval::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * pInput = operand(0)->approximate<T>(context, angleUnit);
Expression * nInput = operand(1)->approximate<T>(context, angleUnit);
if (pInput->type() != Type::Complex || nInput->type() != Type::Complex) {
return new Complex<T>(Complex<T>::Float(NAN));
}

2
poincare/src/product.cpp
View File

@@ -31,7 +31,7 @@ ExpressionLayout * Product::createSequenceLayoutWithArgumentLayouts(ExpressionLa
}
template<typename T>
Expression * Product::templatedEvaluateWithNextTerm(Expression * a, Expression * b) const {
Expression * Product::templatedApproximateWithNextTerm(Expression * a, Expression * b) const {
if (a->type() == Type::Complex && b->type() == Type::Complex) {
Complex<T> * c = static_cast<Complex<T> *>(a);
Complex<T> * d = static_cast<Complex<T> *>(b);

2
poincare/src/rational.cpp
View File

@@ -138,7 +138,7 @@ int Rational::simplificationOrderSameType(const Expression * e) const {
return NaturalOrder(*this, *other);
}
template<typename T> Complex<T> * Rational::templatedEvaluate(Context& context, Expression::AngleUnit angleUnit) const {
template<typename T> Complex<T> * Rational::templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const {
T n = m_numerator.approximate<T>();
T d = m_denominator.approximate<T>();
return new Complex<T>(Complex<T>::Float(n/d));

6
poincare/src/round.cpp
View File

@@ -48,9 +48,9 @@ Expression * Round::shallowReduce(Context& context, AngleUnit angleUnit) {
}
template<typename T>
Complex<T> * Round::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->evaluate<T>(context, angleUnit);
Expression * f2Input = operand(1)->evaluate<T>(context, angleUnit);
Complex<T> * Round::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * f1Input = operand(0)->approximate<T>(context, angleUnit);
Expression * f2Input = operand(1)->approximate<T>(context, angleUnit);
T f1 = f1Input->type() == Type::Complex ? static_cast<Complex<T> *>(f1Input)->toScalar() : NAN;
T f2 = f2Input->type() == Type::Complex ? static_cast<Complex<T> *>(f2Input)->toScalar() : NAN;
delete f1Input;

8
poincare/src/sequence.cpp
View File

@@ -23,9 +23,9 @@ ExpressionLayout * Sequence::privateCreateLayout(FloatDisplayMode floatDisplayMo
}
template<typename T>
Expression * Sequence::templatedEvaluate(Context& context, AngleUnit angleUnit) const {
Expression * aInput = operand(1)->evaluate<T>(context, angleUnit);
Expression * bInput = operand(2)->evaluate<T>(context, angleUnit);
Expression * Sequence::templatedApproximate(Context& context, AngleUnit angleUnit) const {
Expression * aInput = operand(1)->approximate<T>(context, angleUnit);
Expression * bInput = operand(2)->approximate<T>(context, angleUnit);
T start = aInput->type() == Type::Complex ? static_cast<Complex<T> *>(aInput)->toScalar() : NAN;
T end = bInput->type() == Type::Complex ? static_cast<Complex<T> *>(bInput)->toScalar() : NAN;
delete aInput;
@@ -43,7 +43,7 @@ Expression * Sequence::templatedEvaluate(Context& context, AngleUnit angleUnit)
}
Complex<T> iExpression = Complex<T>::Float(i);
nContext.setExpressionForSymbolName(&iExpression, &nSymbol, nContext);
Expression * expression = operand(0)->evaluate<T>(nContext, angleUnit);
Expression * expression = operand(0)->approximate<T>(nContext, angleUnit);
Expression * newResult = evaluateWithNextTerm(T(), result, expression);
delete result;
delete expression;

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