From 357f97112043a441ff170de7268f4c4a906c6bcd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89milie=20Feral?= Date: Thu, 8 Dec 2016 11:55:51 +0100 Subject: [PATCH] [poincare] Change name: createEvaluation -> evaluate Change-Id: I8f241541af0435c6ab4f7ba1f561f880c4e95ac0 --- apps/calculation/calculation.cpp | 2 +- apps/expression_text_field_delegate.cpp | 2 +- poincare/include/poincare/addition.h | 8 ++++---- poincare/include/poincare/cosine.h | 2 +- poincare/include/poincare/expression.h | 5 +++-- poincare/include/poincare/float.h | 2 +- poincare/include/poincare/fraction.h | 6 +++--- poincare/include/poincare/integer.h | 2 +- poincare/include/poincare/logarithm.h | 2 +- poincare/include/poincare/matrix.h | 2 +- poincare/include/poincare/parenthesis.h | 2 +- poincare/include/poincare/power.h | 4 ++-- poincare/include/poincare/product.h | 6 +++--- poincare/include/poincare/sine.h | 2 +- poincare/include/poincare/subtraction.h | 6 +++--- poincare/include/poincare/symbol.h | 2 +- poincare/include/poincare/tangent.h | 2 +- poincare/src/addition.cpp | 20 ++++++++++---------- poincare/src/cosine.cpp | 2 +- poincare/src/float.cpp | 2 +- poincare/src/fraction.cpp | 14 +++++++------- poincare/src/integer.cpp | 2 +- poincare/src/logarithm.cpp | 2 +- poincare/src/matrix.cpp | 2 +- poincare/src/parenthesis.cpp | 4 ++-- poincare/src/power.cpp | 13 +++++++------ poincare/src/product.cpp | 16 ++++++++-------- poincare/src/sine.cpp | 2 +- poincare/src/subtraction.cpp | 16 ++++++++-------- poincare/src/symbol.cpp | 4 ++-- poincare/src/tangent.cpp | 2 +- 31 files changed, 80 insertions(+), 78 deletions(-) diff --git a/apps/calculation/calculation.cpp b/apps/calculation/calculation.cpp index dea2900e6..cd21cd166 100644 --- a/apps/calculation/calculation.cpp +++ b/apps/calculation/calculation.cpp @@ -57,7 +57,7 @@ void Calculation::setContent(const char * c, Context * context) { if (m_evaluation != nullptr) { delete m_evaluationLayout; } - m_evaluation = m_expression->createEvaluation(*context); + m_evaluation = m_expression->evaluate(*context); if (m_evaluationLayout != nullptr) { delete m_evaluationLayout; } diff --git a/apps/expression_text_field_delegate.cpp b/apps/expression_text_field_delegate.cpp index fa96cb7f7..defbaccf0 100644 --- a/apps/expression_text_field_delegate.cpp +++ b/apps/expression_text_field_delegate.cpp @@ -32,7 +32,7 @@ bool ExpressionTextFieldDelegate::textFieldDidReceiveEvent(TextField * textField textField->app()->displayWarning("Attention a la syntaxe jeune padawan"); return true; } - Expression * evaluation = exp->createEvaluation(*evaluateContext()); + Expression * evaluation = exp->evaluate(*evaluateContext()); if (evaluation == nullptr) { delete exp; textField->app()->displayWarning("Relis ton cours de maths, veux tu?"); diff --git a/poincare/include/poincare/addition.h b/poincare/include/poincare/addition.h index 08842acc1..f31bdadbf 100644 --- a/poincare/include/poincare/addition.h +++ b/poincare/include/poincare/addition.h @@ -13,7 +13,7 @@ class Addition : public Expression { int numberOfOperands() const override; Type type() const override; float approximate(Context& context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Expression * clone() const override; Expression * cloneWithDifferentOperands(Expression** newOperands, int numberOfOperands, bool cloneOperands = true) const override; @@ -21,9 +21,9 @@ class Addition : public Expression { bool isCommutative() const override; private: float operateApproximatevelyOn(float a, float b) const; - Expression * createEvaluationOn(Expression * a, Expression * b, Context& context) const; - Expression * createEvaluationOnFloatAndMatrix(Float * a, Matrix * m, Context& context) const; - Expression * createEvaluationOnMatrices(Matrix * m, Matrix * n, Context& context) const; + Expression * evaluateOn(Expression * a, Expression * b, Context& context) const; + Expression * evaluateOnFloatAndMatrix(Float * a, Matrix * m, Context& context) const; + Expression * evaluateOnMatrices(Matrix * m, Matrix * n, Context& context) const; const int m_numberOfOperands; Expression ** m_operands; }; diff --git a/poincare/include/poincare/cosine.h b/poincare/include/poincare/cosine.h index fd0ca68f8..38313a5c5 100644 --- a/poincare/include/poincare/cosine.h +++ b/poincare/include/poincare/cosine.h @@ -7,7 +7,7 @@ class Cosine : public Function { public: Cosine(); float approximate(Context & context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; Expression * cloneWithDifferentOperands(Expression ** newOperands, int numberOfOperands, bool cloneOperands = true) const override; diff --git a/poincare/include/poincare/expression.h b/poincare/include/poincare/expression.h index 16601429b..fc883a646 100644 --- a/poincare/include/poincare/expression.h +++ b/poincare/include/poincare/expression.h @@ -65,8 +65,9 @@ class Expression { virtual Type type() const = 0; virtual bool isCommutative() const; - - virtual Expression * createEvaluation(Context& context) const = 0; + /* The function evaluate creates a new expression and thus mallocs memory. + * Do not forget to delete the new expression to avoid leaking. */ + virtual Expression * evaluate(Context& context) const = 0; virtual float approximate(Context& context) const = 0; char * text(); protected: diff --git a/poincare/include/poincare/float.h b/poincare/include/poincare/float.h index 5a58c2b86..b25988cee 100644 --- a/poincare/include/poincare/float.h +++ b/poincare/include/poincare/float.h @@ -9,7 +9,7 @@ public: ExpressionLayout * createLayout() const override; float approximate(Context& context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; Expression * clone() const override; bool valueEquals(const Expression * e) const override; diff --git a/poincare/include/poincare/fraction.h b/poincare/include/poincare/fraction.h index a31456ecc..7ab1643f2 100644 --- a/poincare/include/poincare/fraction.h +++ b/poincare/include/poincare/fraction.h @@ -10,13 +10,13 @@ class Fraction : public BinaryOperation { public: ExpressionLayout * createLayout() const override; float approximate(Context& context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; Expression * cloneWithDifferentOperands(Expression** newOperands, int numnerOfOperands, bool cloneOperands = true) const override; private: - Expression * createEvaluationOnMatrixAndFloat(Matrix * m, Float * f, Context& context) const; - Expression * createEvaluationOnMatrices(Matrix * m, Matrix * n, Context& context) const; + Expression * evaluateOnMatrixAndFloat(Matrix * m, Float * f, Context& context) const; + Expression * evaluateOnMatrices(Matrix * m, Matrix * n, Context& context) const; }; #endif diff --git a/poincare/include/poincare/integer.h b/poincare/include/poincare/integer.h index a6450f125..6e4079afb 100644 --- a/poincare/include/poincare/integer.h +++ b/poincare/include/poincare/integer.h @@ -33,7 +33,7 @@ class Integer : public LeafExpression { Expression * clone() const override; virtual ExpressionLayout * createLayout() const override; float approximate(Context& context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; private: Integer add(const Integer &other, bool inverse_other_negative) const; int8_t ucmp(const Integer &other) const; // -1, 0, or 1 diff --git a/poincare/include/poincare/logarithm.h b/poincare/include/poincare/logarithm.h index 8f38de319..eb5a6c5f7 100644 --- a/poincare/include/poincare/logarithm.h +++ b/poincare/include/poincare/logarithm.h @@ -7,7 +7,7 @@ class Logarithm : public Function { public: Logarithm(); float approximate(Context & context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; Expression * cloneWithDifferentOperands(Expression ** newOperands, int numberOfOperands, bool cloneOperands = true) const override; diff --git a/poincare/include/poincare/matrix.h b/poincare/include/poincare/matrix.h index ad545c253..3bb62ec4e 100644 --- a/poincare/include/poincare/matrix.h +++ b/poincare/include/poincare/matrix.h @@ -15,7 +15,7 @@ class Matrix : public Expression { Expression * clone() const override; ExpressionLayout * createLayout() const override; float approximate(Context& context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; Expression * cloneWithDifferentOperands(Expression** newOperands, int numberOfOperands, bool cloneOperands = true) const override; diff --git a/poincare/include/poincare/parenthesis.h b/poincare/include/poincare/parenthesis.h index 4ed43b4d1..5b183ad87 100644 --- a/poincare/include/poincare/parenthesis.h +++ b/poincare/include/poincare/parenthesis.h @@ -12,7 +12,7 @@ class Parenthesis : public Expression { Expression * clone() const override; ExpressionLayout * createLayout() const override; float approximate(Context& context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; Expression * cloneWithDifferentOperands(Expression** newOperands, int numnerOfOperands, bool cloneOperands = true) const override; diff --git a/poincare/include/poincare/power.h b/poincare/include/poincare/power.h index ed43530d9..4bdd69659 100644 --- a/poincare/include/poincare/power.h +++ b/poincare/include/poincare/power.h @@ -10,13 +10,13 @@ class Power : public BinaryOperation { using BinaryOperation::BinaryOperation; public: ExpressionLayout * createLayout() const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; float approximate(Context& context) const override; Type type() const override; Expression * cloneWithDifferentOperands(Expression** newOperands, int numnerOfOperands, bool cloneOperands = true) const override; private: - Expression * createEvaluationOnMatrixAndInteger(Matrix * m, Integer * i, Context& context) const; + Expression * evaluateOnMatrixAndInteger(Matrix * m, Integer * i, Context& context) const; }; #endif diff --git a/poincare/include/poincare/product.h b/poincare/include/poincare/product.h index 44c633e7f..1a97162b8 100644 --- a/poincare/include/poincare/product.h +++ b/poincare/include/poincare/product.h @@ -11,12 +11,12 @@ class Product : public BinaryOperation { Type type() const override; ExpressionLayout * createLayout() const override; float approximate(Context& context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Expression * cloneWithDifferentOperands(Expression** newOperands, int numnerOfOperands, bool cloneOperands = true) const override; private: - Expression * createEvaluationOnMatrixAndFloat(Matrix * m, Float * f, Context& context) const; - Expression * createEvaluationOnMatrices(Matrix * m, Matrix * n, Context& context) const; + Expression * evaluateOnMatrixAndFloat(Matrix * m, Float * f, Context& context) const; + Expression * evaluateOnMatrices(Matrix * m, Matrix * n, Context& context) const; }; #endif diff --git a/poincare/include/poincare/sine.h b/poincare/include/poincare/sine.h index 88395e1cb..feba67a3e 100644 --- a/poincare/include/poincare/sine.h +++ b/poincare/include/poincare/sine.h @@ -7,7 +7,7 @@ class Sine : public Function { public: Sine(); float approximate(Context & context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; Expression * cloneWithDifferentOperands(Expression ** newOperands, int numberOfOperands, bool cloneOperands = true) const override; diff --git a/poincare/include/poincare/subtraction.h b/poincare/include/poincare/subtraction.h index 5eaa5f84f..78117d298 100644 --- a/poincare/include/poincare/subtraction.h +++ b/poincare/include/poincare/subtraction.h @@ -11,13 +11,13 @@ class Subtraction : public BinaryOperation { public: ExpressionLayout * createLayout() const override; float approximate(Context& context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; Expression * cloneWithDifferentOperands(Expression** newOperands, int numnerOfOperands, bool cloneOperands = true) const override; private: - Expression * createEvaluationOnMatrixAndFloat(Matrix * m, Float * f, Context& context, bool matrixMinusFloat) const; - Expression * createEvaluationOnMatrices(Matrix * m, Matrix * n, Context& context) const; + Expression * evaluateOnMatrixAndFloat(Matrix * m, Float * f, Context& context, bool matrixMinusFloat) const; + Expression * evaluateOnMatrices(Matrix * m, Matrix * n, Context& context) const; }; #endif diff --git a/poincare/include/poincare/symbol.h b/poincare/include/poincare/symbol.h index 334abcc48..eb1cb1bc7 100644 --- a/poincare/include/poincare/symbol.h +++ b/poincare/include/poincare/symbol.h @@ -13,7 +13,7 @@ public: Symbol(char name); ExpressionLayout * createLayout() const override; float approximate(Context& context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; const char name() const; Expression * clone() const override; diff --git a/poincare/include/poincare/tangent.h b/poincare/include/poincare/tangent.h index 176fea371..87a136fd8 100644 --- a/poincare/include/poincare/tangent.h +++ b/poincare/include/poincare/tangent.h @@ -7,7 +7,7 @@ class Tangent : public Function { public: Tangent(); float approximate(Context & context) const override; - Expression * createEvaluation(Context& context) const override; + Expression * evaluate(Context& context) const override; Type type() const override; Expression * cloneWithDifferentOperands(Expression ** newOperands, int numnerOfOperands, bool cloneOperands = true) const override; diff --git a/poincare/src/addition.cpp b/poincare/src/addition.cpp index 85b60f8b2..bba7df02c 100644 --- a/poincare/src/addition.cpp +++ b/poincare/src/addition.cpp @@ -53,11 +53,11 @@ float Addition::approximate(Context& context) const { return result; } -Expression * Addition::createEvaluation(Context& context) const { - Expression * result = m_operands[0]->createEvaluation(context); +Expression * Addition::evaluate(Context& context) const { + Expression * result = m_operands[0]->evaluate(context); for (int i=1; icreateEvaluation(context); - Expression * newResult = this->createEvaluationOn(result, next, context); + Expression * next = m_operands[i]->evaluate(context); + Expression * newResult = this->evaluateOn(result, next, context); delete result; result = newResult; delete next; @@ -94,7 +94,7 @@ float Addition::operateApproximatevelyOn(float a, float b) const { return a + b; } -Expression * Addition::createEvaluationOn(Expression * a, Expression * b, Context& context) const { +Expression * Addition::evaluateOn(Expression * a, Expression * b, Context& context) const { if (a == nullptr || b == nullptr) { return nullptr; } @@ -105,18 +105,18 @@ Expression * Addition::createEvaluationOn(Expression * a, Expression * b, Contex result = new Float(a->approximate(context) + b->approximate(context)); } if (a->type() == Expression::Type::Float && b->type() == Expression::Type::Matrix) { - result = createEvaluationOnFloatAndMatrix((Float *)a, (Matrix *)b, context); + result = evaluateOnFloatAndMatrix((Float *)a, (Matrix *)b, context); } if (b->type() == Expression::Type::Float && a->type() == Expression::Type::Matrix) { - result = createEvaluationOnFloatAndMatrix((Float *)b, (Matrix *)a, context); + result = evaluateOnFloatAndMatrix((Float *)b, (Matrix *)a, context); } if (b->type() == Expression::Type::Matrix && a->type() == Expression::Type::Matrix) { - result = createEvaluationOnMatrices((Matrix *)a, (Matrix *)b, context); + result = evaluateOnMatrices((Matrix *)a, (Matrix *)b, context); } return result; } -Expression * Addition::createEvaluationOnFloatAndMatrix(Float * a, Matrix * m, Context& context) const { +Expression * Addition::evaluateOnFloatAndMatrix(Float * a, Matrix * m, Context& context) const { Expression * operands[m->numberOfRows() * m->numberOfColumns()]; for (int i = 0; i < m->numberOfRows() * m->numberOfColumns(); i++) { operands[i] = new Float(a->approximate(context) + m->operand(i)->approximate(context)); @@ -124,7 +124,7 @@ Expression * Addition::createEvaluationOnFloatAndMatrix(Float * a, Matrix * m, C return new Matrix(operands, m->numberOfRows() * m->numberOfColumns(), m->numberOfColumns(), m->numberOfRows(), false); } -Expression * Addition::createEvaluationOnMatrices(Matrix * m, Matrix * n, Context& context) const { +Expression * Addition::evaluateOnMatrices(Matrix * m, Matrix * n, Context& context) const { if (m->numberOfColumns() != n->numberOfColumns() || m->numberOfRows() != n->numberOfRows()) { return nullptr; } diff --git a/poincare/src/cosine.cpp b/poincare/src/cosine.cpp index e32d9dd17..aec4e4c35 100644 --- a/poincare/src/cosine.cpp +++ b/poincare/src/cosine.cpp @@ -28,6 +28,6 @@ float Cosine::approximate(Context& context) const { return cosf(m_arg->approximate(context)); } -Expression * Cosine::createEvaluation(Context& context) const { +Expression * Cosine::evaluate(Context& context) const { return new Float(cosf(m_arg->approximate(context))); } diff --git a/poincare/src/float.cpp b/poincare/src/float.cpp index 8a0f83f75..06cb77682 100644 --- a/poincare/src/float.cpp +++ b/poincare/src/float.cpp @@ -26,7 +26,7 @@ float Float::approximate(Context& context) const { return m_float; } -Expression * Float::createEvaluation(Context& context) const { +Expression * Float::evaluate(Context& context) const { return new Float(m_float); } diff --git a/poincare/src/fraction.cpp b/poincare/src/fraction.cpp index de9ad8982..0a8d8f8be 100644 --- a/poincare/src/fraction.cpp +++ b/poincare/src/fraction.cpp @@ -26,9 +26,9 @@ Expression::Type Fraction::type() const { return Expression::Type::Fraction; } -Expression * Fraction::createEvaluation(Context& context) const { - Expression * numerator = m_operands[0]->createEvaluation(context); - Expression * denominator = m_operands[1]->createEvaluation(context); +Expression * Fraction::evaluate(Context& context) const { + Expression * numerator = m_operands[0]->evaluate(context); + Expression * denominator = m_operands[1]->evaluate(context); if (numerator == nullptr || denominator == nullptr) { return nullptr; } @@ -37,20 +37,20 @@ Expression * Fraction::createEvaluation(Context& context) const { result = new Float(this->approximate(context)); } if (numerator->type() == Expression::Type::Matrix && denominator->type() == Expression::Type::Float) { - result = createEvaluationOnMatrixAndFloat((Matrix *)numerator, (Float *)denominator, context); + result = evaluateOnMatrixAndFloat((Matrix *)numerator, (Float *)denominator, context); } if (numerator->type() == Expression::Type::Float && denominator->type() == Expression::Type::Matrix) { result = nullptr; } if (numerator->type() == Expression::Type::Matrix && denominator->type() == Expression::Type::Matrix) { - result = createEvaluationOnMatrices((Matrix *)numerator, (Matrix *)denominator, context); + result = evaluateOnMatrices((Matrix *)numerator, (Matrix *)denominator, context); } delete numerator; delete denominator; return result; } -Expression * Fraction::createEvaluationOnMatrixAndFloat(Matrix * m, Float * a, Context& context) const { +Expression * Fraction::evaluateOnMatrixAndFloat(Matrix * m, Float * a, Context& context) const { Expression * operands[m->numberOfRows() * m->numberOfColumns()]; for (int i = 0; i < m->numberOfRows() * m->numberOfColumns(); i++) { operands[i] = new Float(m->operand(i)->approximate(context)/a->approximate(context)); @@ -59,7 +59,7 @@ Expression * Fraction::createEvaluationOnMatrixAndFloat(Matrix * m, Float * a, C return result; } -Expression * Fraction::createEvaluationOnMatrices(Matrix * m, Matrix * n, Context& context) const { +Expression * Fraction::evaluateOnMatrices(Matrix * m, Matrix * n, Context& context) const { if (m->numberOfColumns() != n->numberOfColumns()) { return nullptr; } diff --git a/poincare/src/integer.cpp b/poincare/src/integer.cpp index c943192b3..0b7e4f629 100644 --- a/poincare/src/integer.cpp +++ b/poincare/src/integer.cpp @@ -325,7 +325,7 @@ float Integer::approximate(Context& context) const { return float_result; } -Expression * Integer::createEvaluation(Context& context) const { +Expression * Integer::evaluate(Context& context) const { return new Float(approximate(context)); } diff --git a/poincare/src/logarithm.cpp b/poincare/src/logarithm.cpp index c58d72053..ac43b18bf 100644 --- a/poincare/src/logarithm.cpp +++ b/poincare/src/logarithm.cpp @@ -27,6 +27,6 @@ float Logarithm::approximate(Context& context) const { return log10f(m_arg->approximate(context)); } -Expression * Logarithm::createEvaluation(Context& context) const { +Expression * Logarithm::evaluate(Context& context) const { return new Float(log10f(m_arg->approximate(context))); } diff --git a/poincare/src/matrix.cpp b/poincare/src/matrix.cpp index f7eaaf2e6..1d24d0a6d 100644 --- a/poincare/src/matrix.cpp +++ b/poincare/src/matrix.cpp @@ -53,7 +53,7 @@ float Matrix::approximate(Context& context) const { return NAN; } -Expression * Matrix::createEvaluation(Context& context) const { +Expression * Matrix::evaluate(Context& context) const { Expression * operands[numberOfOperands()]; for (int i = 0; i < numberOfOperands(); i++) { operands[i] = new Float(operand(i)->approximate(context)); diff --git a/poincare/src/parenthesis.cpp b/poincare/src/parenthesis.cpp index 6286ff2e9..0b600af13 100644 --- a/poincare/src/parenthesis.cpp +++ b/poincare/src/parenthesis.cpp @@ -45,8 +45,8 @@ float Parenthesis::approximate(Context& context) const { return m_operand->approximate(context); } -Expression * Parenthesis::createEvaluation(Context& context) const { - return m_operand->createEvaluation(context); +Expression * Parenthesis::evaluate(Context& context) const { + return m_operand->evaluate(context); } Expression::Type Parenthesis::type() const { diff --git a/poincare/src/power.cpp b/poincare/src/power.cpp index fab2d9f85..1f1136120 100644 --- a/poincare/src/power.cpp +++ b/poincare/src/power.cpp @@ -10,9 +10,9 @@ float Power::approximate(Context& context) const { return powf(m_operands[0]->approximate(context), m_operands[1]->approximate(context)); } -Expression * Power::createEvaluation(Context& context) const { - Expression * base = m_operands[0]->createEvaluation(context); - Expression * exponent = m_operands[1]->createEvaluation(context); +Expression * Power::evaluate(Context& context) const { + Expression * base = m_operands[0]->evaluate(context); + Expression * exponent = m_operands[1]->evaluate(context); if (base == nullptr || exponent == nullptr) { return nullptr; } @@ -21,7 +21,7 @@ Expression * Power::createEvaluation(Context& context) const { result = new Float(this->approximate(context)); } if (base->type() == Expression::Type::Matrix && m_operands[1]->type() == Expression::Type::Integer) { - result = createEvaluationOnMatrixAndInteger((Matrix *)base, (Integer *)(m_operands[1]), context); + result = evaluateOnMatrixAndInteger((Matrix *)base, (Integer *)(m_operands[1]), context); } delete base; delete exponent; @@ -29,7 +29,7 @@ Expression * Power::createEvaluation(Context& context) const { } -Expression * Power::createEvaluationOnMatrixAndInteger(Matrix * m, Integer * i, Context& context) const { +Expression * Power::evaluateOnMatrixAndInteger(Matrix * m, Integer * i, Context& context) const { if (m->numberOfColumns() != m->numberOfRows()) { return nullptr; } @@ -43,9 +43,10 @@ Expression * Power::createEvaluationOnMatrixAndInteger(Matrix * m, Integer * i, Expression * next = new Product(operands, true); /* We do not need to suppress next, as we suppress result and m is handle by * another scope (TODO: something feels wrong. Check again) */ - Expression * newResult = next->createEvaluation(context); + Expression * newResult = next->evaluate(context); delete result; result = newResult; + delete next; } return result; } diff --git a/poincare/src/product.cpp b/poincare/src/product.cpp index 975bd00e4..2c1b9ed9c 100644 --- a/poincare/src/product.cpp +++ b/poincare/src/product.cpp @@ -30,9 +30,9 @@ Expression * Product::cloneWithDifferentOperands(Expression** newOperands, return new Product(newOperands, cloneOperands); } -Expression * Product::createEvaluation(Context& context) const { - Expression * leftOperand = m_operands[0]->createEvaluation(context); - Expression * rightOperand = m_operands[1]->createEvaluation(context); +Expression * Product::evaluate(Context& context) const { + Expression * leftOperand = m_operands[0]->evaluate(context); + Expression * rightOperand = m_operands[1]->evaluate(context); if (leftOperand == nullptr || rightOperand == nullptr) { return nullptr; } @@ -41,20 +41,20 @@ Expression * Product::createEvaluation(Context& context) const { result = new Float(this->approximate(context)); } if (leftOperand->type() == Expression::Type::Matrix && rightOperand->type() == Expression::Type::Float) { - result = createEvaluationOnMatrixAndFloat((Matrix *)leftOperand, (Float *)rightOperand, context); + result = evaluateOnMatrixAndFloat((Matrix *)leftOperand, (Float *)rightOperand, context); } if (leftOperand->type() == Expression::Type::Float && rightOperand->type() == Expression::Type::Matrix) { - result = createEvaluationOnMatrixAndFloat((Matrix *)rightOperand, (Float *)leftOperand, context); + result = evaluateOnMatrixAndFloat((Matrix *)rightOperand, (Float *)leftOperand, context); } if (leftOperand->type() == Expression::Type::Matrix && rightOperand->type() == Expression::Type::Matrix) { - result = createEvaluationOnMatrices((Matrix *)leftOperand, (Matrix *)rightOperand, context); + result = evaluateOnMatrices((Matrix *)leftOperand, (Matrix *)rightOperand, context); } delete leftOperand; delete rightOperand; return result; } -Expression * Product::createEvaluationOnMatrixAndFloat(Matrix * m, Float * a, Context& context) const { +Expression * Product::evaluateOnMatrixAndFloat(Matrix * m, Float * a, Context& context) const { Expression * operands[m->numberOfRows() * m->numberOfColumns()]; for (int i = 0; i < m->numberOfRows() * m->numberOfColumns(); i++) { operands[i] = new Float(m->operand(i)->approximate(context)*a->approximate(context)); @@ -62,7 +62,7 @@ Expression * Product::createEvaluationOnMatrixAndFloat(Matrix * m, Float * a, Co return new Matrix(operands, m->numberOfRows() * m->numberOfColumns(), m->numberOfColumns(), m->numberOfRows(), false); } -Expression * Product::createEvaluationOnMatrices(Matrix * m, Matrix * n, Context& context) const { +Expression * Product::evaluateOnMatrices(Matrix * m, Matrix * n, Context& context) const { if (m->numberOfColumns() != n->numberOfRows()) { return nullptr; } diff --git a/poincare/src/sine.cpp b/poincare/src/sine.cpp index fa786a61a..4e36f087c 100644 --- a/poincare/src/sine.cpp +++ b/poincare/src/sine.cpp @@ -28,6 +28,6 @@ float Sine::approximate(Context& context) const { return sinf(m_arg->approximate(context)); } -Expression * Sine::createEvaluation(Context& context) const { +Expression * Sine::evaluate(Context& context) const { return new Float(sinf(m_arg->approximate(context))); } \ No newline at end of file diff --git a/poincare/src/subtraction.cpp b/poincare/src/subtraction.cpp index 0be14cf92..28847251a 100644 --- a/poincare/src/subtraction.cpp +++ b/poincare/src/subtraction.cpp @@ -31,9 +31,9 @@ ExpressionLayout * Subtraction::createLayout() const { return new HorizontalLayout(children_layouts, 3); } -Expression * Subtraction::createEvaluation(Context& context) const { - Expression * leftOperand = m_operands[0]->createEvaluation(context); - Expression * rightOperand = m_operands[1]->createEvaluation(context); +Expression * Subtraction::evaluate(Context& context) const { + Expression * leftOperand = m_operands[0]->evaluate(context); + Expression * rightOperand = m_operands[1]->evaluate(context); if (leftOperand == nullptr || rightOperand == nullptr) { return nullptr; } @@ -42,20 +42,20 @@ Expression * Subtraction::createEvaluation(Context& context) const { result = new Float(this->approximate(context)); } if (leftOperand->type() == Expression::Type::Matrix && rightOperand->type() == Expression::Type::Float) { - result = createEvaluationOnMatrixAndFloat((Matrix *)leftOperand, (Float *)rightOperand, context, true); + result = evaluateOnMatrixAndFloat((Matrix *)leftOperand, (Float *)rightOperand, context, true); } if (leftOperand->type() == Expression::Type::Float && rightOperand->type() == Expression::Type::Matrix) { - result = createEvaluationOnMatrixAndFloat((Matrix *)rightOperand, (Float *)leftOperand, context, false); + result = evaluateOnMatrixAndFloat((Matrix *)rightOperand, (Float *)leftOperand, context, false); } if (leftOperand->type() == Expression::Type::Matrix && rightOperand->type() == Expression::Type::Matrix) { - result = createEvaluationOnMatrices((Matrix *)leftOperand, (Matrix *)rightOperand, context); + result = evaluateOnMatrices((Matrix *)leftOperand, (Matrix *)rightOperand, context); } delete leftOperand; delete rightOperand; return result; } -Expression * Subtraction::createEvaluationOnMatrixAndFloat(Matrix * m, Float * a, Context& context, bool matrixMinusFloat) const { +Expression * Subtraction::evaluateOnMatrixAndFloat(Matrix * m, Float * a, Context& context, bool matrixMinusFloat) const { Expression * operands[m->numberOfRows() * m->numberOfColumns()]; for (int i = 0; i < m->numberOfRows() * m->numberOfColumns(); i++) { if (matrixMinusFloat) { @@ -67,7 +67,7 @@ Expression * Subtraction::createEvaluationOnMatrixAndFloat(Matrix * m, Float * a return new Matrix(operands, m->numberOfRows() * m->numberOfColumns(), m->numberOfColumns(), m->numberOfRows(), false); } -Expression * Subtraction::createEvaluationOnMatrices(Matrix * m, Matrix * n, Context& context) const { +Expression * Subtraction::evaluateOnMatrices(Matrix * m, Matrix * n, Context& context) const { if (m->numberOfColumns() != n->numberOfColumns() || m->numberOfRows() != n->numberOfColumns()) { return nullptr; } diff --git a/poincare/src/symbol.cpp b/poincare/src/symbol.cpp index e22a663a5..33aefd4c1 100644 --- a/poincare/src/symbol.cpp +++ b/poincare/src/symbol.cpp @@ -19,8 +19,8 @@ float Symbol::approximate(Context& context) const { return NAN; } -Expression * Symbol::createEvaluation(Context& context) const { - return context.expressionForSymbol(this)->createEvaluation(context); +Expression * Symbol::evaluate(Context& context) const { + return context.expressionForSymbol(this)->evaluate(context); } Expression::Type Symbol::type() const { diff --git a/poincare/src/tangent.cpp b/poincare/src/tangent.cpp index 3872504d0..37c786215 100644 --- a/poincare/src/tangent.cpp +++ b/poincare/src/tangent.cpp @@ -28,6 +28,6 @@ float Tangent::approximate(Context& context) const { return tanf(m_arg->approximate(context)); } -Expression * Tangent::createEvaluation(Context& context) const { +Expression * Tangent::evaluate(Context& context) const { return new Float(tanf(m_arg->approximate(context))); }