From c1cd0302b88499f14b142f439c43fb982b221b66 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=89milie=20Feral?= Date: Fri, 2 Aug 2019 11:58:19 +0200 Subject: [PATCH] [poincare] Fix typo: explicite --> explicit, implicite --> implicit --- apps/probability/law/binomial_law.cpp | 2 +- apps/regression/model/cubic_model.cpp | 8 +- apps/regression/model/quadratic_model.cpp | 6 +- apps/regression/model/quartic_model.cpp | 10 +- apps/regression/model/trigonometric_model.cpp | 6 +- .../list/type_parameter_controller.cpp | 4 +- .../sequence/list/type_parameter_controller.h | 2 +- apps/solver/equation_store.cpp | 32 ++--- poincare/Makefile | 4 +- poincare/include/poincare/complex_cartesian.h | 4 +- poincare/include/poincare/expression.h | 6 +- poincare/include/poincare/expression_node.h | 4 +- poincare/include/poincare/factor.h | 4 +- ..._explicite.h => multiplication_explicit.h} | 28 ++--- ..._implicite.h => multiplication_implicit.h} | 22 ++-- poincare/include/poincare_nodes.h | 4 +- poincare/src/absolute_value.cpp | 4 +- poincare/src/addition.cpp | 22 ++-- poincare/src/complex_cartesian.cpp | 46 +++---- poincare/src/confidence_interval.cpp | 4 +- poincare/src/conjugate.cpp | 4 +- poincare/src/determinant.cpp | 2 +- poincare/src/division.cpp | 8 +- poincare/src/expression.cpp | 16 +-- poincare/src/factor.cpp | 8 +- poincare/src/factorial.cpp | 2 +- poincare/src/logarithm.cpp | 12 +- poincare/src/matrix.cpp | 22 ++-- poincare/src/multiplication.cpp | 6 +- ...licite.cpp => multiplication_explicit.cpp} | 114 +++++++++--------- ...licite.cpp => multiplication_implicit.cpp} | 20 +-- poincare/src/opposite.cpp | 4 +- poincare/src/parsing/parser.cpp | 10 +- poincare/src/power.cpp | 58 ++++----- poincare/src/prediction_interval.cpp | 6 +- poincare/src/sign_function.cpp | 2 +- poincare/src/subtraction.cpp | 4 +- poincare/src/tree_handle.cpp | 4 +- poincare/src/trigonometry.cpp | 20 +-- poincare/src/trigonometry_cheat_table.cpp | 4 +- poincare/test/expression_order.cpp | 38 +++--- poincare/test/expression_properties.cpp | 8 +- poincare/test/layout_to_expression.cpp | 6 +- poincare/test/parsing.cpp | 72 +++++------ 44 files changed, 336 insertions(+), 336 deletions(-) rename poincare/include/poincare/{multiplication_explicite.h => multiplication_explicit.h} (71%) rename poincare/include/poincare/{multiplication_implicite.h => multiplication_implicit.h} (55%) rename poincare/src/{multiplication_explicite.cpp => multiplication_explicit.cpp} (85%) rename poincare/src/{multiplication_implicite.cpp => multiplication_implicit.cpp} (50%) diff --git a/apps/probability/law/binomial_law.cpp b/apps/probability/law/binomial_law.cpp index 751247f62..82eeef682 100644 --- a/apps/probability/law/binomial_law.cpp +++ b/apps/probability/law/binomial_law.cpp @@ -57,7 +57,7 @@ bool BinomialLaw::authorizedValueAtIndex(float x, int index) const { * abscissa within the interesting range, the complexity of the cumulative * probability is linear with the size of the range. Here we cap the maximal * size of the range to 10000. If one day we want to increase or get rid of - * this cap, we should implement the explicite formula of the cumulative + * this cap, we should implement the explicit formula of the cumulative * probability (which depends on an incomplete beta function) to make the * comlexity O(1). */ if (x != (int)x || x < 0.0f || x > 99999.0f) { diff --git a/apps/regression/model/cubic_model.cpp b/apps/regression/model/cubic_model.cpp index 1c0a67747..2d5dde611 100644 --- a/apps/regression/model/cubic_model.cpp +++ b/apps/regression/model/cubic_model.cpp @@ -9,7 +9,7 @@ #include #include #include -#include +#include #include using namespace Poincare; @@ -83,17 +83,17 @@ Expression CubicModel::expression(double * modelCoefficients) { double c = modelCoefficients[2]; double d = modelCoefficients[3]; Expression addChildren[] = { - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(a), Power::Builder( Symbol::Builder('x'), Decimal::Builder(3.0))), - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(b), Power::Builder( Symbol::Builder('x'), Decimal::Builder(2.0))), - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(c), Symbol::Builder('x')), Number::DecimalNumber(d) diff --git a/apps/regression/model/quadratic_model.cpp b/apps/regression/model/quadratic_model.cpp index 8d4709ba9..3ab4a0810 100644 --- a/apps/regression/model/quadratic_model.cpp +++ b/apps/regression/model/quadratic_model.cpp @@ -9,7 +9,7 @@ #include #include #include -#include +#include #include using namespace Poincare; @@ -70,12 +70,12 @@ Expression QuadraticModel::expression(double * modelCoefficients) { double c = modelCoefficients[2]; // a*x^2+b*x+c Expression addChildren[] = { - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(a), Power::Builder( Symbol::Builder('x'), Decimal::Builder(2.0))), - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(b), Symbol::Builder('x')), Number::DecimalNumber(c) diff --git a/apps/regression/model/quartic_model.cpp b/apps/regression/model/quartic_model.cpp index 9289631d0..206d3694c 100644 --- a/apps/regression/model/quartic_model.cpp +++ b/apps/regression/model/quartic_model.cpp @@ -9,7 +9,7 @@ #include #include #include -#include +#include #include using namespace Poincare; @@ -98,25 +98,25 @@ Expression QuarticModel::expression(double * modelCoefficients) { double e = modelCoefficients[4]; Expression addChildren[] = { // a*x^4 - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(a), Power::Builder( Symbol::Builder('x'), Decimal::Builder(4.0))), // b*x^3 - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(b), Power::Builder( Symbol::Builder('x'), Decimal::Builder(3.0))), // c*x^2 - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(c), Power::Builder( Symbol::Builder('x'), Decimal::Builder(2.0))), // d*x - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(d), Symbol::Builder('x')), // e diff --git a/apps/regression/model/trigonometric_model.cpp b/apps/regression/model/trigonometric_model.cpp index f08dfd927..b346632b4 100644 --- a/apps/regression/model/trigonometric_model.cpp +++ b/apps/regression/model/trigonometric_model.cpp @@ -2,7 +2,7 @@ #include "../../shared/poincare_helpers.h" #include #include -#include +#include #include #include #include @@ -66,11 +66,11 @@ Expression TrigonometricModel::expression(double * modelCoefficients) { // a*sin(bx+c)+d Expression result = Addition::Builder( - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(a), Sine::Builder( Addition::Builder( - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Number::DecimalNumber(b), Symbol::Builder('x')), Number::DecimalNumber(c)))), diff --git a/apps/sequence/list/type_parameter_controller.cpp b/apps/sequence/list/type_parameter_controller.cpp index 40a7c30b6..3f30a08b3 100644 --- a/apps/sequence/list/type_parameter_controller.cpp +++ b/apps/sequence/list/type_parameter_controller.cpp @@ -14,7 +14,7 @@ namespace Sequence { TypeParameterController::TypeParameterController(Responder * parentResponder, ListController * list, TableCell::Layout cellLayout, KDCoordinate topMargin, KDCoordinate rightMargin, KDCoordinate bottomMargin, KDCoordinate leftMargin) : ViewController(parentResponder), - m_expliciteCell(I18n::Message::Explicit, cellLayout), + m_explicitCell(I18n::Message::Explicit, cellLayout), m_singleRecurrenceCell(I18n::Message::SingleRecurrence, cellLayout), m_doubleRecurenceCell(I18n::Message::DoubleRecurrence, cellLayout), m_layouts{}, @@ -99,7 +99,7 @@ int TypeParameterController::numberOfRows() { HighlightCell * TypeParameterController::reusableCell(int index) { assert(index >= 0); assert(index < k_totalNumberOfCell); - HighlightCell * cells[] = {&m_expliciteCell, &m_singleRecurrenceCell, &m_doubleRecurenceCell}; + HighlightCell * cells[] = {&m_explicitCell, &m_singleRecurrenceCell, &m_doubleRecurenceCell}; return cells[index]; } diff --git a/apps/sequence/list/type_parameter_controller.h b/apps/sequence/list/type_parameter_controller.h index 4c8a36136..58a944399 100644 --- a/apps/sequence/list/type_parameter_controller.h +++ b/apps/sequence/list/type_parameter_controller.h @@ -34,7 +34,7 @@ private: } SequenceStore * sequenceStore(); constexpr static int k_totalNumberOfCell = 3; - ExpressionTableCellWithPointer m_expliciteCell; + ExpressionTableCellWithPointer m_explicitCell; ExpressionTableCellWithPointer m_singleRecurrenceCell; ExpressionTableCellWithPointer m_doubleRecurenceCell; Poincare::Layout m_layouts[k_totalNumberOfCell]; diff --git a/apps/solver/equation_store.cpp b/apps/solver/equation_store.cpp index 31af8f7be..fe49b9822 100644 --- a/apps/solver/equation_store.cpp +++ b/apps/solver/equation_store.cpp @@ -10,7 +10,7 @@ #include #include #include -#include +#include #include #include #include @@ -274,20 +274,20 @@ EquationStore::Error EquationStore::oneDimensialPolynomialSolve(Expression exact /* Equation ax^2+bx+c = 0 */ assert(degree == 2); // Compute delta = b*b-4ac - Expression delta = Subtraction::Builder(Power::Builder(coefficients[1].clone(), Rational::Builder(2)), MultiplicationExplicite::Builder(Rational::Builder(4), coefficients[0].clone(), coefficients[2].clone())); + Expression delta = Subtraction::Builder(Power::Builder(coefficients[1].clone(), Rational::Builder(2)), MultiplicationExplicit::Builder(Rational::Builder(4), coefficients[0].clone(), coefficients[2].clone())); delta = delta.simplify(context, updatedComplexFormat(context), Poincare::Preferences::sharedPreferences()->angleUnit()); if (delta.isUninitialized()) { delta = Poincare::Undefined::Builder(); } if (delta.isRationalZero()) { // if delta = 0, x0=x1= -b/(2a) - exactSolutions[0] = Division::Builder(Opposite::Builder(coefficients[1]), MultiplicationExplicite::Builder(Rational::Builder(2), coefficients[2])); + exactSolutions[0] = Division::Builder(Opposite::Builder(coefficients[1]), MultiplicationExplicit::Builder(Rational::Builder(2), coefficients[2])); m_numberOfSolutions = 2; } else { // x0 = (-b-sqrt(delta))/(2a) - exactSolutions[0] = Division::Builder(Subtraction::Builder(Opposite::Builder(coefficients[1].clone()), SquareRoot::Builder(delta.clone())), MultiplicationExplicite::Builder(Rational::Builder(2), coefficients[2].clone())); + exactSolutions[0] = Division::Builder(Subtraction::Builder(Opposite::Builder(coefficients[1].clone()), SquareRoot::Builder(delta.clone())), MultiplicationExplicit::Builder(Rational::Builder(2), coefficients[2].clone())); // x1 = (-b+sqrt(delta))/(2a) - exactSolutions[1] = Division::Builder(Addition::Builder(Opposite::Builder(coefficients[1]), SquareRoot::Builder(delta.clone())), MultiplicationExplicite::Builder(Rational::Builder(2), coefficients[2])); + exactSolutions[1] = Division::Builder(Addition::Builder(Opposite::Builder(coefficients[1]), SquareRoot::Builder(delta.clone())), MultiplicationExplicit::Builder(Rational::Builder(2), coefficients[2])); m_numberOfSolutions = 3; } exactSolutions[m_numberOfSolutions-1] = delta; @@ -307,18 +307,18 @@ EquationStore::Error EquationStore::oneDimensialPolynomialSolve(Expression exact Expression * mult2Operands[3] = {new Rational::Builder(-27), new Power::Builder(a->clone(), new Rational::Builder(2), false), new Power::Builder(d->clone(), new Rational::Builder(2), false)}; Expression * mult3Operands[3] = {new Rational::Builder(-4), a->clone(), new Power::Builder(c->clone(), new Rational::Builder(3), false)}; Expression * mult4Operands[3] = {new Rational::Builder(-4), d->clone(), new Power::Builder(b->clone(), new Rational::Builder(3), false)}; - Expression * add0Operands[5] = {new MultiplicationExplicite::Builder(mult0Operands, 2, false), new MultiplicationExplicite::Builder(mult1Operands, 5, false), new MultiplicationExplicite::Builder(mult2Operands, 3, false), new MultiplicationExplicite::Builder(mult3Operands, 3, false), new MultiplicationExplicite::Builder(mult4Operands, 3, false)}; + Expression * add0Operands[5] = {new MultiplicationExplicit::Builder(mult0Operands, 2, false), new MultiplicationExplicit::Builder(mult1Operands, 5, false), new MultiplicationExplicit::Builder(mult2Operands, 3, false), new MultiplicationExplicit::Builder(mult3Operands, 3, false), new MultiplicationExplicit::Builder(mult4Operands, 3, false)}; Expression * delta = new Addition(add0Operands, 5, false); PoincareHelpers::Simplify(&delta, *context); // Delta0 = b^2-3ac Expression * mult5Operands[3] = {new Rational::Builder(3), a->clone(), c->clone()}; - Expression * delta0 = new Subtraction::Builder(new Power::Builder(b->clone(), new Rational::Builder(2), false), new MultiplicationExplicite::Builder(mult5Operands, 3, false), false); + Expression * delta0 = new Subtraction::Builder(new Power::Builder(b->clone(), new Rational::Builder(2), false), new MultiplicationExplicit::Builder(mult5Operands, 3, false), false); Reduce(&delta0, *context); if (delta->isRationalZero()) { if (delta0->isRationalZero()) { // delta0 = 0 && delta = 0 --> x0 = -b/(3a) delete delta0; - m_exactSolutions[0] = new Opposite::Builder(new Division::Builder(b, new MultiplicationExplicite::Builder(new Rational::Builder(3), a, false), false), false); + m_exactSolutions[0] = new Opposite::Builder(new Division::Builder(b, new MultiplicationExplicit::Builder(new Rational::Builder(3), a, false), false), false); m_numberOfSolutions = 1; delete c; delete d; @@ -326,33 +326,33 @@ EquationStore::Error EquationStore::oneDimensialPolynomialSolve(Expression exact // delta = 0 --> x0 = (9ad-bc)/(2delta0) // --> x1 = (4abc-9a^2d-b^3)/(a*delta0) Expression * mult6Operands[3] = {new Rational::Builder(9), a, d}; - m_exactSolutions[0] = new Division::Builder(new Subtraction::Builder(new MultiplicationExplicite::Builder(mult6Operands, 3, false), new MultiplicationExplicite::Builder(b, c, false), false), new MultiplicationExplicite::Builder(new Rational::Builder(2), delta0, false), false); + m_exactSolutions[0] = new Division::Builder(new Subtraction::Builder(new MultiplicationExplicit::Builder(mult6Operands, 3, false), new MultiplicationExplicit::Builder(b, c, false), false), new MultiplicationExplicit::Builder(new Rational::Builder(2), delta0, false), false); Expression * mult7Operands[4] = {new Rational::Builder(4), a->clone(), b->clone(), c->clone()}; Expression * mult8Operands[3] = {new Rational::Builder(-9), new Power::Builder(a->clone(), new Rational::Builder(2), false), d->clone()}; - Expression * add1Operands[3] = {new MultiplicationExplicite::Builder(mult7Operands, 4, false), new MultiplicationExplicite::Builder(mult8Operands,3, false), new Opposite::Builder(new Power::Builder(b->clone(), new Rational::Builder(3), false), false)}; - m_exactSolutions[1] = new Division::Builder(new Addition(add1Operands, 3, false), new MultiplicationExplicite::Builder(a->clone(), delta0, false), false); + Expression * add1Operands[3] = {new MultiplicationExplicit::Builder(mult7Operands, 4, false), new MultiplicationExplicit::Builder(mult8Operands,3, false), new Opposite::Builder(new Power::Builder(b->clone(), new Rational::Builder(3), false), false)}; + m_exactSolutions[1] = new Division::Builder(new Addition(add1Operands, 3, false), new MultiplicationExplicit::Builder(a->clone(), delta0, false), false); m_numberOfSolutions = 2; } } else { // delta1 = 2b^3-9abc+27a^2*d Expression * mult9Operands[4] = {new Rational::Builder(-9), a, b, c}; Expression * mult10Operands[3] = {new Rational::Builder(27), new Power::Builder(a->clone(), new Rational::Builder(2), false), d}; - Expression * add2Operands[3] = {new MultiplicationExplicite::Builder(new Rational::Builder(2), new Power::Builder(b->clone(), new Rational::Builder(3), false), false), new MultiplicationExplicite::Builder(mult9Operands, 4, false), new MultiplicationExplicite::Builder(mult10Operands, 3, false)}; + Expression * add2Operands[3] = {new MultiplicationExplicit::Builder(new Rational::Builder(2), new Power::Builder(b->clone(), new Rational::Builder(3), false), false), new MultiplicationExplicit::Builder(mult9Operands, 4, false), new MultiplicationExplicit::Builder(mult10Operands, 3, false)}; Expression * delta1 = new Addition(add2Operands, 3, false); // C = Root((delta1+sqrt(-27a^2*delta))/2, 3) Expression * mult11Operands[3] = {new Rational::Builder(-27), new Power::Builder(a->clone(), new Rational::Builder(2), false), (*delta)->clone()}; - Expression * c = new Power::Builder(new Division::Builder(new Addition(delta1, new SquareRoot(new MultiplicationExplicite::Builder(mult11Operands, 3, false), false), false), new Rational::Builder(2), false), new Rational::Builder(1,3), false); - Expression * unary3roots[2] = {new Addition(new Rational::Builder(-1,2), new Division::Builder(new MultiplicationExplicite::Builder(new SquareRoot(new Rational::Builder(3), false), new Constant::Builder(UCodePointMathematicalBoldSmallI), false), new Rational::Builder(2), false), false), new Subtraction::Builder(new Rational::Builder(-1,2), new Division::Builder(new MultiplicationExplicite::Builder(new SquareRoot(new Rational::Builder(3), false), new Constant::Builder(UCodePointMathematicalBoldSmallI), false), new Rational::Builder(2), false), false)}; + Expression * c = new Power::Builder(new Division::Builder(new Addition(delta1, new SquareRoot(new MultiplicationExplicit::Builder(mult11Operands, 3, false), false), false), new Rational::Builder(2), false), new Rational::Builder(1,3), false); + Expression * unary3roots[2] = {new Addition(new Rational::Builder(-1,2), new Division::Builder(new MultiplicationExplicit::Builder(new SquareRoot(new Rational::Builder(3), false), new Constant::Builder(UCodePointMathematicalBoldSmallI), false), new Rational::Builder(2), false), false), new Subtraction::Builder(new Rational::Builder(-1,2), new Division::Builder(new MultiplicationExplicit::Builder(new SquareRoot(new Rational::Builder(3), false), new Constant::Builder(UCodePointMathematicalBoldSmallI), false), new Rational::Builder(2), false), false)}; // x_k = -1/(3a)*(b+C*z+delta0/(zC)) with z = unary cube root for (int k = 0; k < 3; k++) { Expression * ccopy = c; Expression * delta0copy = delta0; if (k < 2) { - ccopy = new MultiplicationExplicite::Builder(c->clone(), unary3roots[k], false); + ccopy = new MultiplicationExplicit::Builder(c->clone(), unary3roots[k], false); delta0copy = delta0->clone(); } Expression * add3Operands[3] = {b->clone(), ccopy, new Division::Builder(delta0copy, ccopy->clone(), false)}; - m_exactSolutions[k] = new MultiplicationExplicite::Builder(new Division::Builder(new Rational::Builder(-1), new MultiplicationExplicite::Builder(new Rational::Builder(3), a->clone(), false), false), new Addition(add3Operands, 3, false), false); + m_exactSolutions[k] = new MultiplicationExplicit::Builder(new Division::Builder(new Rational::Builder(-1), new MultiplicationExplicit::Builder(new Rational::Builder(3), a->clone(), false), false), new Addition(add3Operands, 3, false), false); } m_numberOfSolutions = 3; } diff --git a/poincare/Makefile b/poincare/Makefile index 7de339584..1201d40e9 100644 --- a/poincare/Makefile +++ b/poincare/Makefile @@ -91,8 +91,8 @@ poincare_src += $(addprefix poincare/src/,\ matrix_trace.cpp \ matrix_transpose.cpp \ multiplication.cpp \ - multiplication_explicite.cpp \ - multiplication_implicite.cpp \ + multiplication_explicit.cpp \ + multiplication_implicit.cpp \ n_ary_expression.cpp \ naperian_logarithm.cpp \ nth_root.cpp \ diff --git a/poincare/include/poincare/complex_cartesian.h b/poincare/include/poincare/complex_cartesian.h index 8edfffbb4..0058fcf4a 100644 --- a/poincare/include/poincare/complex_cartesian.h +++ b/poincare/include/poincare/complex_cartesian.h @@ -2,7 +2,7 @@ #define POINCARE_COMPLEX_CARTESIAN_H #include -#include +#include namespace Poincare { @@ -67,7 +67,7 @@ private: static constexpr int k_maxNumberOfNodesBeforeInterrupting = 50; void factorAndArgumentOfFunction(Expression e, ExpressionNode::Type searchedType, Expression * factor, Expression * argument, ExpressionNode::ReductionContext reductionContext); ComplexCartesian interruptComputationIfManyNodes(); - static MultiplicationExplicite squareRootHelper(Expression e, ExpressionNode::ReductionContext reductionContext); + static MultiplicationExplicit squareRootHelper(Expression e, ExpressionNode::ReductionContext reductionContext); static Expression powerHelper(Expression norm, Expression trigo, ExpressionNode::ReductionContext reductionContext); }; diff --git a/poincare/include/poincare/expression.h b/poincare/include/poincare/expression.h index f00c4e8a1..5fa457025 100644 --- a/poincare/include/poincare/expression.h +++ b/poincare/include/poincare/expression.h @@ -61,8 +61,8 @@ class Expression : public TreeHandle { friend class MatrixTrace; friend class MatrixTranspose; friend class Multiplication; - friend class MultiplicationExplicite; - friend class MultiplicationImplicite; + friend class MultiplicationExplicit; + friend class MultiplicationImplicit; friend class MultiplicationNode; friend class NaperianLogarithm; friend class NthRoot; @@ -131,7 +131,7 @@ public: bool isOfType(ExpressionNode::Type * types, int length) const { return node()->isOfType(types, length); } ExpressionNode::Sign sign(Context * context) const { return node()->sign(context); } bool isUndefined() const { return node()->type() == ExpressionNode::Type::Undefined || node()->type() == ExpressionNode::Type::Unreal; } - bool isMultiplication() const { return node()->type() == ExpressionNode::Type::MultiplicationExplicite || node()->type() == ExpressionNode::Type::MultiplicationImplicite; } + bool isMultiplication() const { return node()->type() == ExpressionNode::Type::MultiplicationExplicit || node()->type() == ExpressionNode::Type::MultiplicationImplicit; } bool isNumber() const { return node()->isNumber(); } bool isRationalZero() const; bool isRationalOne() const; diff --git a/poincare/include/poincare/expression_node.h b/poincare/include/poincare/expression_node.h index 1098f432a..145b2ed79 100644 --- a/poincare/include/poincare/expression_node.h +++ b/poincare/include/poincare/expression_node.h @@ -31,8 +31,8 @@ public: Decimal, Float, Infinity, - MultiplicationExplicite, - MultiplicationImplicite, + MultiplicationExplicit, + MultiplicationImplicit, Power, Addition, Factorial, diff --git a/poincare/include/poincare/factor.h b/poincare/include/poincare/factor.h index 07b7881d4..45faaa687 100644 --- a/poincare/include/poincare/factor.h +++ b/poincare/include/poincare/factor.h @@ -3,7 +3,7 @@ #include #include -#include +#include #include namespace Poincare { @@ -45,7 +45,7 @@ public: static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("factor", 1, &UntypedBuilderOneChild); - MultiplicationExplicite createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; + MultiplicationExplicit createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const; // Expression Expression shallowReduce(Context * context); diff --git a/poincare/include/poincare/multiplication_explicite.h b/poincare/include/poincare/multiplication_explicit.h similarity index 71% rename from poincare/include/poincare/multiplication_explicite.h rename to poincare/include/poincare/multiplication_explicit.h index 986f7b3f0..5cc56ed9d 100644 --- a/poincare/include/poincare/multiplication_explicite.h +++ b/poincare/include/poincare/multiplication_explicit.h @@ -1,25 +1,25 @@ -#ifndef POINCARE_MULTIPLICATION_EXPLICITE_H -#define POINCARE_MULTIPLICATION_EXPLICITE_H +#ifndef POINCARE_MULTIPLICATION_EXPLICIT_H +#define POINCARE_MULTIPLICATION_EXPLICIT_H #include #include namespace Poincare { -class MultiplicationExpliciteNode /*final*/ : public MultiplicationNode { +class MultiplicationExplicitNode /*final*/ : public MultiplicationNode { friend class Addition; public: using MultiplicationNode::MultiplicationNode; // Tree - size_t size() const override { return sizeof(MultiplicationExpliciteNode); } + size_t size() const override { return sizeof(MultiplicationExplicitNode); } #if POINCARE_TREE_LOG virtual void logNodeName(std::ostream & stream) const override { - stream << "Multiplication Explicite"; + stream << "Multiplication Explicit"; } #endif // Properties - Type type() const override { return Type::MultiplicationExplicite; } + Type type() const override { return Type::MultiplicationExplicit; } private: // Property @@ -38,18 +38,18 @@ private: }; -class MultiplicationExplicite : public Multiplication { +class MultiplicationExplicit : public Multiplication { friend class AdditionNode; friend class Addition; friend class Power; public: - MultiplicationExplicite(const MultiplicationExpliciteNode * n) : Multiplication(n) {} - static MultiplicationExplicite Builder() { return TreeHandle::NAryBuilder(); } - static MultiplicationExplicite Builder(Expression e1) { return MultiplicationExplicite::Builder(&e1, 1); } - static MultiplicationExplicite Builder(Expression e1, Expression e2) { return MultiplicationExplicite::Builder(ArrayBuilder(e1, e2).array(), 2); } - static MultiplicationExplicite Builder(Expression e1, Expression e2, Expression e3) { return MultiplicationExplicite::Builder(ArrayBuilder(e1, e2, e3).array(), 3); } - static MultiplicationExplicite Builder(Expression e1, Expression e2, Expression e3, Expression e4) { return MultiplicationExplicite::Builder(ArrayBuilder(e1, e2, e3, e4).array(), 4); } - static MultiplicationExplicite Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder(children, numberOfChildren); } + MultiplicationExplicit(const MultiplicationExplicitNode * n) : Multiplication(n) {} + static MultiplicationExplicit Builder() { return TreeHandle::NAryBuilder(); } + static MultiplicationExplicit Builder(Expression e1) { return MultiplicationExplicit::Builder(&e1, 1); } + static MultiplicationExplicit Builder(Expression e1, Expression e2) { return MultiplicationExplicit::Builder(ArrayBuilder(e1, e2).array(), 2); } + static MultiplicationExplicit Builder(Expression e1, Expression e2, Expression e3) { return MultiplicationExplicit::Builder(ArrayBuilder(e1, e2, e3).array(), 3); } + static MultiplicationExplicit Builder(Expression e1, Expression e2, Expression e3, Expression e4) { return MultiplicationExplicit::Builder(ArrayBuilder(e1, e2, e3, e4).array(), 4); } + static MultiplicationExplicit Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder(children, numberOfChildren); } Expression setSign(ExpressionNode::Sign s, ExpressionNode::ReductionContext reductionContext); Expression shallowReduce(ExpressionNode::ReductionContext reductionContext); diff --git a/poincare/include/poincare/multiplication_implicite.h b/poincare/include/poincare/multiplication_implicit.h similarity index 55% rename from poincare/include/poincare/multiplication_implicite.h rename to poincare/include/poincare/multiplication_implicit.h index 2c3b955c3..6a99b5b1c 100644 --- a/poincare/include/poincare/multiplication_implicite.h +++ b/poincare/include/poincare/multiplication_implicit.h @@ -1,26 +1,26 @@ -#ifndef POINCARE_MULTIPLICATION_IMPLICITE_H -#define POINCARE_MULTIPLICATION_IMPLICITE_H +#ifndef POINCARE_MULTIPLICATION_IMPLICIT_H +#define POINCARE_MULTIPLICATION_IMPLICIT_H #include namespace Poincare { -class MultiplicationImplicite; +class MultiplicationImplicit; -class MultiplicationImpliciteNode /*final*/ : public MultiplicationNode { +class MultiplicationImplicitNode /*final*/ : public MultiplicationNode { public: using MultiplicationNode::MultiplicationNode; // Tree - size_t size() const override { return sizeof(MultiplicationImpliciteNode); } + size_t size() const override { return sizeof(MultiplicationImplicitNode); } #if POINCARE_TREE_LOG virtual void logNodeName(std::ostream & stream) const override { - stream << "Multiplication Implicite"; + stream << "Multiplication Implicit"; } #endif // Properties - Type type() const override { return Type::MultiplicationImplicite; } + Type type() const override { return Type::MultiplicationImplicit; } private: // Layout @@ -34,11 +34,11 @@ private: Expression shallowReduce(ReductionContext reductionContext) override; }; -class MultiplicationImplicite : public Multiplication { +class MultiplicationImplicit : public Multiplication { public: - MultiplicationImplicite(const MultiplicationImpliciteNode * n) : Multiplication(n) {} - static MultiplicationImplicite Builder(Expression e1, Expression e2) { return MultiplicationImplicite::Builder(ArrayBuilder(e1, e2).array(), 2); } - static MultiplicationImplicite Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder(children, numberOfChildren); } + MultiplicationImplicit(const MultiplicationImplicitNode * n) : Multiplication(n) {} + static MultiplicationImplicit Builder(Expression e1, Expression e2) { return MultiplicationImplicit::Builder(ArrayBuilder(e1, e2).array(), 2); } + static MultiplicationImplicit Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder(children, numberOfChildren); } // Simplification Expression shallowReduce(ExpressionNode::ReductionContext reductionContext); }; diff --git a/poincare/include/poincare_nodes.h b/poincare/include/poincare_nodes.h index 8e00126c7..a6b6ecc86 100644 --- a/poincare/include/poincare_nodes.h +++ b/poincare/include/poincare_nodes.h @@ -49,8 +49,8 @@ #include #include #include -#include -#include +#include +#include #include #include #include diff --git a/poincare/src/absolute_value.cpp b/poincare/src/absolute_value.cpp index 7f33488bb..5971d4de6 100644 --- a/poincare/src/absolute_value.cpp +++ b/poincare/src/absolute_value.cpp @@ -3,7 +3,7 @@ #include #include #include -#include +#include #include #include @@ -55,7 +55,7 @@ Expression AbsoluteValue::shallowReduce(ExpressionNode::ReductionContext reducti } else if (!std::isnan(app) && ((c.isNumber() && app < 0.0f) || app <= -Expression::Epsilon())) { // abs(a) = -a with a < 0 (same comment as above to check that a < 0) - MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1), c); + MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1), c); replaceWithInPlace(m); return m.shallowReduce(reductionContext); } diff --git a/poincare/src/addition.cpp b/poincare/src/addition.cpp index f7cd99964..3ca378cfa 100644 --- a/poincare/src/addition.cpp +++ b/poincare/src/addition.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -62,7 +62,7 @@ Expression AdditionNode::shallowBeautify(ReductionContext reductionContext) { // Addition const Number Addition::NumeralFactor(const Expression & e) { - if (e.type() == ExpressionNode::Type::MultiplicationExplicite && e.childAtIndex(0).isNumber()) { + if (e.type() == ExpressionNode::Type::MultiplicationExplicit && e.childAtIndex(0).isNumber()) { Number result = e.childAtIndex(0).convert(); return result; } @@ -306,7 +306,7 @@ Expression Addition::shallowReduce(ExpressionNode::ReductionContext reductionCon } int Addition::NumberOfNonNumeralFactors(const Expression & e) { - if (e.type() != ExpressionNode::Type::MultiplicationExplicite) { + if (e.type() != ExpressionNode::Type::MultiplicationExplicit) { return 1; // Or (e->type() != Type::Rational); } int result = e.numberOfChildren(); @@ -317,7 +317,7 @@ int Addition::NumberOfNonNumeralFactors(const Expression & e) { } const Expression Addition::FirstNonNumeralFactor(const Expression & e) { - if (e.type() != ExpressionNode::Type::MultiplicationExplicite) { + if (e.type() != ExpressionNode::Type::MultiplicationExplicit) { return e; } if (e.childAtIndex(0).isNumber()) { @@ -347,7 +347,7 @@ bool Addition::TermsHaveIdenticalNonNumeralFactors(const Expression & e1, const return FirstNonNumeralFactor(e1).isIdenticalTo(FirstNonNumeralFactor(e2)); } else { assert(numberOfNonNumeralFactors > 1); - return MultiplicationExplicite::HaveSameNonNumeralFactors(e1, e2); + return MultiplicationExplicit::HaveSameNonNumeralFactors(e1, e2); } } @@ -361,7 +361,7 @@ Expression Addition::factorizeOnCommonDenominator(ExpressionNode::ReductionConte Addition a = Addition::Builder(); // Step 1: We want to compute the common denominator, b*d - MultiplicationExplicite commonDenominator = MultiplicationExplicite::Builder(); + MultiplicationExplicit commonDenominator = MultiplicationExplicit::Builder(); for (int i = 0; i < numberOfChildren(); i++) { Expression childI = childAtIndex(i); Expression currentDenominator = childI.denominator(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); @@ -391,14 +391,14 @@ Expression Addition::factorizeOnCommonDenominator(ExpressionNode::ReductionConte assert(reductionContext.target() == ExpressionNode::ReductionTarget::User); // Else, before, the algorithm used User target -> put back ? Addition numerator = Addition::Builder(); for (int i = 0; i < numberOfChildren(); i++) { - MultiplicationExplicite m = MultiplicationExplicite::Builder(childAtIndex(i), commonDenominator.clone()); + MultiplicationExplicit m = MultiplicationExplicit::Builder(childAtIndex(i), commonDenominator.clone()); numerator.addChildAtIndexInPlace(m, numerator.numberOfChildren(), numerator.numberOfChildren()); m.privateShallowReduce(reductionContext, true, false); } // Step 3: Add the denominator Power inverseDenominator = Power::Builder(commonDenominator, Rational::Builder(-1)); - MultiplicationExplicite result = MultiplicationExplicite::Builder(numerator, inverseDenominator); + MultiplicationExplicit result = MultiplicationExplicit::Builder(numerator, inverseDenominator); // Step 4: Simplify the numerator numerator.shallowReduce(reductionContext); @@ -437,9 +437,9 @@ void Addition::factorizeChildrenAtIndexesInPlace(int index1, int index2, Express removeChildAtIndexInPlace(index2); // Step 3: Create a multiplication - MultiplicationExplicite m = MultiplicationExplicite::Builder(); - if (e1.type() == ExpressionNode::Type::MultiplicationExplicite) { - m = static_cast(e1); + MultiplicationExplicit m = MultiplicationExplicit::Builder(); + if (e1.type() == ExpressionNode::Type::MultiplicationExplicit) { + m = static_cast(e1); } else { replaceChildAtIndexInPlace(index1, m); m.addChildAtIndexInPlace(e1, 0, 0); diff --git a/poincare/src/complex_cartesian.cpp b/poincare/src/complex_cartesian.cpp index 0d7261b61..fde499660 100644 --- a/poincare/src/complex_cartesian.cpp +++ b/poincare/src/complex_cartesian.cpp @@ -83,12 +83,12 @@ void ComplexCartesian::factorAndArgumentOfFunction(Expression e, ExpressionNode: *argument = e.childAtIndex(0); return; } - if (e.type() == ExpressionNode::Type::MultiplicationExplicite) { + if (e.type() == ExpressionNode::Type::MultiplicationExplicit) { for (int i = 0; i < e.numberOfChildren(); i++) { if (e.childAtIndex(i).type() == searchedType) { *argument = e.childAtIndex(i).childAtIndex(0); *factor = e.clone(); - static_cast(factor)->removeChildAtIndexInPlace(i); + static_cast(factor)->removeChildAtIndexInPlace(i); *factor = factor->shallowReduce(reductionContext); Expression positiveFactor = factor->makePositiveAnyNegativeNumeralFactor(reductionContext); *factor = positiveFactor.isUninitialized() ? *factor : positiveFactor; @@ -157,7 +157,7 @@ Expression ComplexCartesian::argument(ExpressionNode::ReductionContext reduction } // Then, compute sign(b) * π/2 - atan(a/b) Expression signb = SignFunction::Builder(b); - Expression signbPi2 = MultiplicationExplicite::Builder(Rational::Builder(1,2), signb, Constant::Builder(UCodePointGreekSmallLetterPi)); + Expression signbPi2 = MultiplicationExplicit::Builder(Rational::Builder(1,2), signb, Constant::Builder(UCodePointGreekSmallLetterPi)); signb.shallowReduce(reductionContext); Expression sub = Subtraction::Builder(signbPi2, arcTangent); signbPi2.shallowReduce(reductionContext); @@ -168,7 +168,7 @@ Expression ComplexCartesian::argument(ExpressionNode::ReductionContext reduction Expression signa = SignFunction::Builder(a).shallowReduce(reductionContext); Subtraction sub = Subtraction::Builder(Rational::Builder(1), signa); signa.shallowReduce(reductionContext); - MultiplicationExplicite mul = MultiplicationExplicite::Builder(Rational::Builder(1,2), Constant::Builder(UCodePointGreekSmallLetterPi), sub); + MultiplicationExplicit mul = MultiplicationExplicit::Builder(Rational::Builder(1,2), Constant::Builder(UCodePointGreekSmallLetterPi), sub); sub.shallowReduce(reductionContext); return mul; } @@ -184,10 +184,10 @@ ComplexCartesian ComplexCartesian::inverse(ExpressionNode::ReductionContext redu denominatorReal.shallowReduce(reductionContext); Expression denominatorImagInv = Power::Builder(denominatorImag, Rational::Builder(-1)); denominatorImag.shallowReduce(reductionContext); - MultiplicationExplicite A = MultiplicationExplicite::Builder(a, denominatorRealInv); + MultiplicationExplicit A = MultiplicationExplicit::Builder(a, denominatorRealInv); denominatorRealInv.shallowReduce(reductionContext); - Expression numeratorImag = MultiplicationExplicite::Builder(Rational::Builder(-1), b); - MultiplicationExplicite B = MultiplicationExplicite::Builder(numeratorImag, denominatorImagInv); + Expression numeratorImag = MultiplicationExplicit::Builder(Rational::Builder(-1), b); + MultiplicationExplicit B = MultiplicationExplicit::Builder(numeratorImag, denominatorImagInv); numeratorImag.shallowReduce(reductionContext); denominatorImagInv.shallowReduce(reductionContext); ComplexCartesian result = ComplexCartesian::Builder(A,B); @@ -196,13 +196,13 @@ ComplexCartesian ComplexCartesian::inverse(ExpressionNode::ReductionContext redu return result.interruptComputationIfManyNodes(); } -MultiplicationExplicite ComplexCartesian::squareRootHelper(Expression e, ExpressionNode::ReductionContext reductionContext) { +MultiplicationExplicit ComplexCartesian::squareRootHelper(Expression e, ExpressionNode::ReductionContext reductionContext) { //(1/2)*sqrt(2*e) - MultiplicationExplicite doubleE = MultiplicationExplicite::Builder(Rational::Builder(2), e); + MultiplicationExplicit doubleE = MultiplicationExplicit::Builder(Rational::Builder(2), e); e.shallowReduce(reductionContext); Expression sqrt = SquareRoot::Builder(doubleE); doubleE.shallowReduce(reductionContext); - MultiplicationExplicite result = MultiplicationExplicite::Builder(Rational::Builder(1,2), sqrt); + MultiplicationExplicit result = MultiplicationExplicit::Builder(Rational::Builder(1,2), sqrt); sqrt.shallowReduce(reductionContext); return result; } @@ -217,11 +217,11 @@ ComplexCartesian ComplexCartesian::squareRoot(ExpressionNode::ReductionContext r // A = (1/2)*sqrt(2*(sqrt(a^2+b^2)+a)) Addition normAdda = Addition::Builder(normA, a.clone()); normA.shallowReduce(reductionContext); - MultiplicationExplicite A = squareRootHelper(normAdda, reductionContext); + MultiplicationExplicit A = squareRootHelper(normAdda, reductionContext); // B = B: (1/2)*sqrt(2*(sqrt(a^2+b^2)-a)) Subtraction normSuba = Subtraction::Builder(normB, a); normB.shallowReduce(reductionContext); - MultiplicationExplicite B = squareRootHelper(normSuba, reductionContext); + MultiplicationExplicit B = squareRootHelper(normSuba, reductionContext); // B = B: (1/2)*sqrt(2*(sqrt(a^2+b^2)-a))*sign(b) Expression signb = SignFunction::Builder(b); B.addChildAtIndexInPlace(signb, B.numberOfChildren(), B.numberOfChildren()); @@ -245,7 +245,7 @@ ComplexCartesian ComplexCartesian::powerInteger(int n, ExpressionNode::Reduction ComplexCartesian result; Expression bpow = Power::Builder(b, Rational::Builder(n)); if (n/2%2 == 1) { - Expression temp = MultiplicationExplicite::Builder(Rational::Builder(-1), bpow); + Expression temp = MultiplicationExplicit::Builder(Rational::Builder(-1), bpow); bpow.shallowReduce(reductionContext); bpow = temp; } @@ -269,7 +269,7 @@ ComplexCartesian ComplexCartesian::powerInteger(int n, ExpressionNode::Reduction Expression bclone = i == n ? b : b.clone(); Power apow = Power::Builder(aclone, Rational::Builder(n-i)); Power bpow = Power::Builder(bclone, Rational::Builder(i)); - MultiplicationExplicite m = MultiplicationExplicite::Builder(binom, apow, bpow); + MultiplicationExplicit m = MultiplicationExplicit::Builder(binom, apow, bpow); binom.shallowReduce(reductionContext.context()); apow.shallowReduce(reductionContext); bpow.shallowReduce(reductionContext); @@ -299,14 +299,14 @@ ComplexCartesian ComplexCartesian::multiply(ComplexCartesian & other, Expression Expression d = other.imag(); // (a+ib) * (c+id) = (ac-bd)+i*(ad+bc) // Compute ac-bd - Expression ac = MultiplicationExplicite::Builder(a.clone(), c.clone()); - Expression bd = MultiplicationExplicite::Builder(b.clone(), d.clone()); + Expression ac = MultiplicationExplicit::Builder(a.clone(), c.clone()); + Expression bd = MultiplicationExplicit::Builder(b.clone(), d.clone()); Subtraction A = Subtraction::Builder(ac, bd); ac.shallowReduce(reductionContext); bd.shallowReduce(reductionContext); // Compute ad+bc - Expression ad = MultiplicationExplicite::Builder(a, d); - Expression bc = MultiplicationExplicite::Builder(b, c); + Expression ad = MultiplicationExplicit::Builder(a, d); + Expression bc = MultiplicationExplicit::Builder(b, c); Addition B = Addition::Builder(ad, bc); ad.shallowReduce(reductionContext); bc.shallowReduce(reductionContext); @@ -317,7 +317,7 @@ ComplexCartesian ComplexCartesian::multiply(ComplexCartesian & other, Expression } Expression ComplexCartesian::powerHelper(Expression norm, Expression trigo, ExpressionNode::ReductionContext reductionContext) { - MultiplicationExplicite m = MultiplicationExplicite::Builder(norm, trigo); + MultiplicationExplicit m = MultiplicationExplicit::Builder(norm, trigo); norm.shallowReduce(reductionContext); trigo.shallowReduce(reductionContext); return m; @@ -333,20 +333,20 @@ ComplexCartesian ComplexCartesian::power(ComplexCartesian & other, ExpressionNod // R = r^c*e^(-th*d) Expression rpowc = Power::Builder(rclone, c.clone()); rclone.shallowReduce(reductionContext); - Expression thmuld = MultiplicationExplicite::Builder(Rational::Builder(-1), thclone, d.clone()); + Expression thmuld = MultiplicationExplicit::Builder(Rational::Builder(-1), thclone, d.clone()); thclone.shallowReduce(reductionContext); Expression exp = Power::Builder(Constant::Builder(UCodePointScriptSmallE), thmuld); thmuld.shallowReduce(reductionContext); - MultiplicationExplicite norm = MultiplicationExplicite::Builder(rpowc, exp); + MultiplicationExplicit norm = MultiplicationExplicit::Builder(rpowc, exp); rpowc.shallowReduce(reductionContext); exp.shallowReduce(reductionContext); // TH = d*ln(r)+c*th Expression lnr = NaperianLogarithm::Builder(r); r.shallowReduce(reductionContext); - MultiplicationExplicite dlnr = MultiplicationExplicite::Builder(d, lnr); + MultiplicationExplicit dlnr = MultiplicationExplicit::Builder(d, lnr); lnr.shallowReduce(reductionContext); - MultiplicationExplicite thc = MultiplicationExplicite::Builder(th, c); + MultiplicationExplicit thc = MultiplicationExplicit::Builder(th, c); th.shallowReduce(reductionContext); Expression argument = Addition::Builder(thc, dlnr); thc.shallowReduce(reductionContext); diff --git a/poincare/src/confidence_interval.cpp b/poincare/src/confidence_interval.cpp index ffdf04e8d..0ef9172c6 100644 --- a/poincare/src/confidence_interval.cpp +++ b/poincare/src/confidence_interval.cpp @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include #include @@ -84,7 +84,7 @@ Expression ConfidenceInterval::shallowReduce(ExpressionNode::ReductionContext re // Compute [r0-1/sqr(r1), r0+1/sqr(r1)] Expression sqr = Power::Builder(r1, Rational::Builder(-1, 2)); Matrix matrix = Matrix::Builder(); - matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), MultiplicationExplicite::Builder(Rational::Builder(-1), sqr.clone())), 0, 0); + matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), MultiplicationExplicit::Builder(Rational::Builder(-1), sqr.clone())), 0, 0); matrix.addChildAtIndexInPlace(Addition::Builder(r0, sqr), 1, 1); matrix.setDimensions(1, 2); replaceWithInPlace(matrix); diff --git a/poincare/src/conjugate.cpp b/poincare/src/conjugate.cpp index 231bf862f..a0f86aa02 100644 --- a/poincare/src/conjugate.cpp +++ b/poincare/src/conjugate.cpp @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include @@ -49,7 +49,7 @@ Expression Conjugate::shallowReduce(ExpressionNode::ReductionContext reductionCo } if (c.type() == ExpressionNode::Type::ComplexCartesian) { ComplexCartesian complexChild = static_cast(c); - MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1), complexChild.imag()); + MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1), complexChild.imag()); complexChild.replaceChildAtIndexInPlace(1, m); m.shallowReduce(reductionContext); replaceWithInPlace(complexChild); diff --git a/poincare/src/determinant.cpp b/poincare/src/determinant.cpp index 3ffec3f28..04770bcc4 100644 --- a/poincare/src/determinant.cpp +++ b/poincare/src/determinant.cpp @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/poincare/src/division.cpp b/poincare/src/division.cpp index 843213dcd..41eb74327 100644 --- a/poincare/src/division.cpp +++ b/poincare/src/division.cpp @@ -1,7 +1,7 @@ #include #include -#include -#include +#include +#include #include #include #include @@ -35,7 +35,7 @@ bool DivisionNode::childNeedsSystemParenthesesAtSerialization(const TreeNode * c if (static_cast(child)->type() == Type::Rational && !static_cast(child)->isInteger()) { return true; } - Type types[] = {Type::Subtraction, Type::Opposite, Type::MultiplicationExplicite, Type::Division, Type::Addition}; + Type types[] = {Type::Subtraction, Type::Opposite, Type::MultiplicationExplicit, Type::Division, Type::Addition}; return static_cast(child)->isOfType(types, 6); } @@ -81,7 +81,7 @@ Expression Division::shallowReduce(ExpressionNode::ReductionContext reductionCon /* For matrices: we decided that A/B is computed as A = A/B * B so A/B = AB^-1 * (it could have been A = B * A/B so A/B = B^-1*A). */ Expression p = Power::Builder(childAtIndex(1), Rational::Builder(-1)); - MultiplicationExplicite m = MultiplicationExplicite::Builder(childAtIndex(0), p); + MultiplicationExplicit m = MultiplicationExplicit::Builder(childAtIndex(0), p); p.shallowReduce(reductionContext); // For instance: Division::Builder(2,1). p would be 1^(-1) which can be simplified replaceWithInPlace(m); return m.shallowReduce(reductionContext); diff --git a/poincare/src/expression.cpp b/poincare/src/expression.cpp index 24e73ecbd..f666f07b6 100644 --- a/poincare/src/expression.cpp +++ b/poincare/src/expression.cpp @@ -111,7 +111,7 @@ bool Expression::IsRandom(const Expression e, Context * context) { } bool Expression::IsNAry(const Expression e, Context * context) { - return e.type() == ExpressionNode::Type::Addition || e.type() == ExpressionNode::Type::MultiplicationExplicite || e.type() == ExpressionNode::Type::MultiplicationImplicite; + return e.type() == ExpressionNode::Type::Addition || e.type() == ExpressionNode::Type::MultiplicationExplicit || e.type() == ExpressionNode::Type::MultiplicationImplicit; } bool Expression::IsMatrix(const Expression e, Context * context) { @@ -584,12 +584,12 @@ Expression Expression::mapOnMatrixFirstChild(ExpressionNode::ReductionContext re Expression Expression::radianToDegree() { // e*180/Pi - return MultiplicationExplicite::Builder(*this, Rational::Builder(180), Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Rational::Builder(-1))); + return MultiplicationExplicit::Builder(*this, Rational::Builder(180), Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Rational::Builder(-1))); } Expression Expression::degreeToRadian() { // e*Pi/180 - return MultiplicationExplicite::Builder(*this, Rational::Builder(1, 180), Constant::Builder(UCodePointGreekSmallLetterPi)); + return MultiplicationExplicit::Builder(*this, Rational::Builder(1, 180), Constant::Builder(UCodePointGreekSmallLetterPi)); } Expression Expression::reduce(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { @@ -617,8 +617,8 @@ Expression Expression::deepBeautify(ExpressionNode::ReductionContext reductionCo } } // We choose whether or not to omit multiplication sign after beautifying parent and child - if (e.type() == ExpressionNode::Type::MultiplicationExplicite) { - e = static_cast(e).omitMultiplicationWhenPossible(); + if (e.type() == ExpressionNode::Type::MultiplicationExplicit) { + e = static_cast(e).omitMultiplicationWhenPossible(); } return e; } @@ -695,7 +695,7 @@ Expression Expression::CreateComplexExpression(Expression ra, Expression tb, Pre if (isOneTb) { imag = Constant::Builder(UCodePointMathematicalBoldSmallI); } else { - imag = MultiplicationImplicite::Builder(tb, Constant::Builder(UCodePointMathematicalBoldSmallI)); + imag = MultiplicationImplicit::Builder(tb, Constant::Builder(UCodePointMathematicalBoldSmallI)); imag.shallowAddMissingParenthesis(); } } @@ -730,7 +730,7 @@ Expression Expression::CreateComplexExpression(Expression ra, Expression tb, Pre if (isOneTb) { arg = Constant::Builder(UCodePointMathematicalBoldSmallI); } else { - arg = MultiplicationImplicite::Builder(tb, Constant::Builder(UCodePointMathematicalBoldSmallI)); + arg = MultiplicationImplicit::Builder(tb, Constant::Builder(UCodePointMathematicalBoldSmallI)); } if (isNegativeTb) { arg = Opposite::Builder(arg); @@ -744,7 +744,7 @@ Expression Expression::CreateComplexExpression(Expression ra, Expression tb, Pre } else if (norm.isUninitialized()) { return exp; } else { - Expression result = MultiplicationImplicite::Builder(norm, exp); + Expression result = MultiplicationImplicit::Builder(norm, exp); result.shallowAddMissingParenthesis(); return result; } diff --git a/poincare/src/factor.cpp b/poincare/src/factor.cpp index 99f6c75d1..edab9d6f1 100644 --- a/poincare/src/factor.cpp +++ b/poincare/src/factor.cpp @@ -34,10 +34,10 @@ Expression FactorNode::shallowBeautify(ReductionContext reductionContext) { return Factor(this).shallowBeautify(reductionContext); } -MultiplicationExplicite Factor::createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +MultiplicationExplicit Factor::createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { assert(!i.isZero()); assert(!i.isNegative()); - MultiplicationExplicite m = MultiplicationExplicite::Builder(); + MultiplicationExplicit m = MultiplicationExplicit::Builder(); Integer factors[Arithmetic::k_maxNumberOfPrimeFactors]; Integer coefficients[Arithmetic::k_maxNumberOfPrimeFactors]; int numberOfPrimeFactors = Arithmetic::PrimeFactorization(i, factors, coefficients, Arithmetic::k_maxNumberOfPrimeFactors); @@ -82,13 +82,13 @@ Expression Factor::shallowBeautify(ExpressionNode::ReductionContext reductionCon replaceWithInPlace(r); return r; } - MultiplicationExplicite numeratorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.unsignedIntegerNumerator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); + MultiplicationExplicit numeratorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.unsignedIntegerNumerator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); if (numeratorDecomp.numberOfChildren() == 0) { return replaceWithUndefinedInPlace(); } Expression result = numeratorDecomp.squashUnaryHierarchyInPlace(); if (!r.isInteger()) { - MultiplicationExplicite denominatorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.integerDenominator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); + MultiplicationExplicit denominatorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.integerDenominator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); if (denominatorDecomp.numberOfChildren() == 0) { return replaceWithUndefinedInPlace(); } diff --git a/poincare/src/factorial.cpp b/poincare/src/factorial.cpp index f8e63fd8f..99216ca20 100644 --- a/poincare/src/factorial.cpp +++ b/poincare/src/factorial.cpp @@ -24,7 +24,7 @@ bool FactorialNode::childNeedsUserParentheses(const Expression & child) const { return true; } - Type types[] = {Type::Subtraction, Type::Opposite, Type::MultiplicationExplicite, Type::MultiplicationImplicite, Type::Addition}; + Type types[] = {Type::Subtraction, Type::Opposite, Type::MultiplicationExplicit, Type::MultiplicationImplicit, Type::Addition}; return child.isOfType(types, 5); } diff --git a/poincare/src/logarithm.cpp b/poincare/src/logarithm.cpp index b5a5b52b5..886b331ef 100644 --- a/poincare/src/logarithm.cpp +++ b/poincare/src/logarithm.cpp @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include #include #include @@ -182,20 +182,20 @@ Expression Logarithm::shallowReduce(ExpressionNode::ReductionContext reductionCo Expression x = p.childAtIndex(0); Expression y = p.childAtIndex(1); replaceChildInPlace(p, x); - MultiplicationExplicite mult = MultiplicationExplicite::Builder(y); + MultiplicationExplicit mult = MultiplicationExplicit::Builder(y); replaceWithInPlace(mult); mult.addChildAtIndexInPlace(*this, 1, 1); // --> y*log(x,b) shallowReduce(reductionContext); // reduce log (ie log(e, e) = 1) return mult.shallowReduce(reductionContext); } // log(x*y, b)->log(x,b)+log(y, b) if x,y>0 - if (c.type() == ExpressionNode::Type::MultiplicationExplicite) { + if (c.type() == ExpressionNode::Type::MultiplicationExplicit) { Addition a = Addition::Builder(); for (int i = 0; i < c.numberOfChildren()-1; i++) { Expression factor = c.childAtIndex(i); if (factor.sign(reductionContext.context()) == ExpressionNode::Sign::Positive) { Expression newLog = clone(); - static_cast(c).removeChildInPlace(factor, factor.numberOfChildren()); + static_cast(c).removeChildInPlace(factor, factor.numberOfChildren()); newLog.replaceChildAtIndexInPlace(0, factor); a.addChildAtIndexInPlace(newLog, a.numberOfChildren(), a.numberOfChildren()); newLog.shallowReduce(reductionContext); @@ -343,7 +343,7 @@ Expression Logarithm::splitLogarithmInteger(Integer i, bool isDenominator, Expre if (!isDenominator) { return e; } - MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1), e); + MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1), e); return m; } Addition a = Addition::Builder(); @@ -353,7 +353,7 @@ Expression Logarithm::splitLogarithmInteger(Integer i, bool isDenominator, Expre } Logarithm e = clone().convert(); e.replaceChildAtIndexInPlace(0, Rational::Builder(factors[index])); - MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(coefficients[index]), e); + MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(coefficients[index]), e); e.simpleShallowReduce(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit()); a.addChildAtIndexInPlace(m, a.numberOfChildren(), a.numberOfChildren()); m.shallowReduce(reductionContext); diff --git a/poincare/src/matrix.cpp b/poincare/src/matrix.cpp index a74f89bd2..0a291ce7b 100644 --- a/poincare/src/matrix.cpp +++ b/poincare/src/matrix.cpp @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include #include @@ -175,7 +175,7 @@ Matrix Matrix::rowCanonize(ExpressionNode::ReductionContext reductionContext, Ex // The matrix children have to be reduced to be able to spot 0 deepReduceChildren(reductionContext); - MultiplicationExplicite det = MultiplicationExplicite::Builder(); + MultiplicationExplicit det = MultiplicationExplicit::Builder(); int m = numberOfRows(); int n = numberOfColumns(); @@ -227,7 +227,7 @@ Matrix Matrix::rowCanonize(ExpressionNode::ReductionContext reductionContext, Ex Expression factor = matrixChild(i, k); for (int j = k+1; j < n; j++) { Expression opIJ = matrixChild(i, j); - Expression newOpIJ = Subtraction::Builder(opIJ, MultiplicationExplicite::Builder(matrixChild(h, j).clone(), factor.clone())); + Expression newOpIJ = Subtraction::Builder(opIJ, MultiplicationExplicit::Builder(matrixChild(h, j).clone(), factor.clone())); replaceChildAtIndexInPlace(i*n+j, newOpIJ); newOpIJ.childAtIndex(1).shallowReduce(reductionContext); newOpIJ = newOpIJ.shallowReduce(reductionContext); @@ -346,8 +346,8 @@ Expression Matrix::determinant(ExpressionNode::ReductionContext reductionContext if (dim == 2) { /* |a b| * Determinant of |c d| is ad-bc */ - MultiplicationExplicite ad = MultiplicationExplicite::Builder(m.matrixChild(0,0), m.matrixChild(1,1)); - MultiplicationExplicite bc = MultiplicationExplicite::Builder(m.matrixChild(0,1), m.matrixChild(1,0)); + MultiplicationExplicit ad = MultiplicationExplicit::Builder(m.matrixChild(0,0), m.matrixChild(1,1)); + MultiplicationExplicit bc = MultiplicationExplicit::Builder(m.matrixChild(0,1), m.matrixChild(1,0)); Expression result = Subtraction::Builder(ad, bc); ad.shallowReduce(reductionContext); bc.shallowReduce(reductionContext); @@ -368,12 +368,12 @@ Expression Matrix::determinant(ExpressionNode::ReductionContext reductionContext Expression i = m.matrixChild(2,2); constexpr int additionChildrenCount = 6; Expression additionChildren[additionChildrenCount] = { - MultiplicationExplicite::Builder(a.clone(), e.clone(), i.clone()), - MultiplicationExplicite::Builder(b.clone(), f.clone(), g.clone()), - MultiplicationExplicite::Builder(c.clone(), d.clone(), h.clone()), - MultiplicationExplicite::Builder(Rational::Builder(-1), c, e, g), - MultiplicationExplicite::Builder(Rational::Builder(-1), b, d, i), - MultiplicationExplicite::Builder(Rational::Builder(-1), a, f, h)}; + MultiplicationExplicit::Builder(a.clone(), e.clone(), i.clone()), + MultiplicationExplicit::Builder(b.clone(), f.clone(), g.clone()), + MultiplicationExplicit::Builder(c.clone(), d.clone(), h.clone()), + MultiplicationExplicit::Builder(Rational::Builder(-1), c, e, g), + MultiplicationExplicit::Builder(Rational::Builder(-1), b, d, i), + MultiplicationExplicit::Builder(Rational::Builder(-1), a, f, h)}; Expression result = Addition::Builder(additionChildren, additionChildrenCount); for (int i = 0; i < additionChildrenCount; i++) { additionChildren[i].shallowReduce(reductionContext); diff --git a/poincare/src/multiplication.cpp b/poincare/src/multiplication.cpp index 8cf9a3226..da3b4aa63 100644 --- a/poincare/src/multiplication.cpp +++ b/poincare/src/multiplication.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include @@ -120,14 +120,14 @@ int Multiplication::getPolynomialCoefficients(Context * context, const char * sy int jbis = j > degI ? degI : j; for (int l = 0; l <= jbis ; l++) { // Always copy the a and b coefficients are they are used multiple times - a.addChildAtIndexInPlace(MultiplicationExplicite::Builder(intermediateCoefficients[l].clone(), coefficients[j-l].clone()), a.numberOfChildren(), a.numberOfChildren()); + a.addChildAtIndexInPlace(MultiplicationExplicit::Builder(intermediateCoefficients[l].clone(), coefficients[j-l].clone()), a.numberOfChildren(), a.numberOfChildren()); } /* a(j) and b(j) are used only to compute coefficient at rank >= j, we * can delete them as we compute new coefficient by decreasing ranks. */ coefficients[j] = a; } // new coefficients[0] = a(0)*b(0) - coefficients[0] = MultiplicationExplicite::Builder(coefficients[0], intermediateCoefficients[0]); + coefficients[0] = MultiplicationExplicit::Builder(coefficients[0], intermediateCoefficients[0]); } return deg; } diff --git a/poincare/src/multiplication_explicite.cpp b/poincare/src/multiplication_explicit.cpp similarity index 85% rename from poincare/src/multiplication_explicite.cpp rename to poincare/src/multiplication_explicit.cpp index fc63e89ea..bf23bde03 100644 --- a/poincare/src/multiplication_explicite.cpp +++ b/poincare/src/multiplication_explicit.cpp @@ -1,5 +1,5 @@ -#include -#include +#include +#include #include #include #include @@ -19,40 +19,40 @@ namespace Poincare { -Expression MultiplicationExpliciteNode::setSign(Sign s, ReductionContext reductionContext) { +Expression MultiplicationExplicitNode::setSign(Sign s, ReductionContext reductionContext) { assert(s == ExpressionNode::Sign::Positive); - return MultiplicationExplicite(this).setSign(s, reductionContext); + return MultiplicationExplicit(this).setSign(s, reductionContext); } -Layout MultiplicationExpliciteNode::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { +Layout MultiplicationExplicitNode::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { constexpr int stringMaxSize = CodePoint::MaxCodePointCharLength + 1; char string[stringMaxSize]; SerializationHelper::CodePoint(string, stringMaxSize, UCodePointMultiplicationSign); - return LayoutHelper::Infix(MultiplicationExplicite(this), floatDisplayMode, numberOfSignificantDigits, string); + return LayoutHelper::Infix(MultiplicationExplicit(this), floatDisplayMode, numberOfSignificantDigits, string); } -int MultiplicationExpliciteNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { +int MultiplicationExplicitNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { constexpr int stringMaxSize = CodePoint::MaxCodePointCharLength + 1; char string[stringMaxSize]; SerializationHelper::CodePoint(string, stringMaxSize, UCodePointMultiplicationSign); return SerializationHelper::Infix(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, string); } -Expression MultiplicationExpliciteNode::shallowReduce(ReductionContext reductionContext) { - return MultiplicationExplicite(this).shallowReduce(reductionContext); +Expression MultiplicationExplicitNode::shallowReduce(ReductionContext reductionContext) { + return MultiplicationExplicit(this).shallowReduce(reductionContext); } -Expression MultiplicationExpliciteNode::shallowBeautify(ReductionContext reductionContext) { - return MultiplicationExplicite(this).shallowBeautify(reductionContext); +Expression MultiplicationExplicitNode::shallowBeautify(ReductionContext reductionContext) { + return MultiplicationExplicit(this).shallowBeautify(reductionContext); } -Expression MultiplicationExpliciteNode::denominator(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { - return MultiplicationExplicite(this).denominator(context, complexFormat, angleUnit); +Expression MultiplicationExplicitNode::denominator(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { + return MultiplicationExplicit(this).denominator(context, complexFormat, angleUnit); } -/* MultiplicationExplicite */ +/* MultiplicationExplicit */ -Expression MultiplicationExplicite::setSign(ExpressionNode::Sign s, ExpressionNode::ReductionContext reductionContext) { +Expression MultiplicationExplicit::setSign(ExpressionNode::Sign s, ExpressionNode::ReductionContext reductionContext) { assert(s == ExpressionNode::Sign::Positive); for (int i = 0; i < numberOfChildren(); i++) { if (childAtIndex(i).sign(reductionContext.context()) == ExpressionNode::Sign::Negative) { @@ -62,7 +62,7 @@ Expression MultiplicationExplicite::setSign(ExpressionNode::Sign s, ExpressionNo return shallowReduce(reductionContext); } -Expression MultiplicationExplicite::shallowReduce(ExpressionNode::ReductionContext reductionContext) { +Expression MultiplicationExplicit::shallowReduce(ExpressionNode::ReductionContext reductionContext) { return privateShallowReduce(reductionContext, true, true); } @@ -71,17 +71,17 @@ static bool canOmitSignBefore(ExpressionNode::LayoutShape right) { return right == ExpressionNode::LayoutShape::SpecialLetter || right == ExpressionNode::LayoutShape::BoundaryPunctuation; } -Expression MultiplicationExplicite::omitMultiplicationWhenPossible() { +Expression MultiplicationExplicit::omitMultiplicationWhenPossible() { int i = 0; while (i < numberOfChildren() - 1) { Expression childI = childAtIndex(i); Expression childI1 = childAtIndex(i+1); if (canOmitSignBefore(childI1.node()->leftLayoutShape())) { - if (childI.type() == ExpressionNode::Type::MultiplicationImplicite) { - static_cast(childI).addChildAtIndexInPlace(childI1, childI.numberOfChildren(), childI.numberOfChildren()); + if (childI.type() == ExpressionNode::Type::MultiplicationImplicit) { + static_cast(childI).addChildAtIndexInPlace(childI1, childI.numberOfChildren(), childI.numberOfChildren()); } else { - Expression impliciteMultiplication = MultiplicationImplicite::Builder(childI, childI1); - replaceChildAtIndexInPlace(i, impliciteMultiplication); + Expression implicitMultiplication = MultiplicationImplicit::Builder(childI, childI1); + replaceChildAtIndexInPlace(i, implicitMultiplication); } removeChildAtIndexInPlace(i+1); continue; @@ -91,7 +91,7 @@ Expression MultiplicationExplicite::omitMultiplicationWhenPossible() { return squashUnaryHierarchyInPlace(); } -Expression MultiplicationExplicite::shallowBeautify(ExpressionNode::ReductionContext reductionContext) { +Expression MultiplicationExplicit::shallowBeautify(ExpressionNode::ReductionContext reductionContext) { /* Beautifying a Multiplication consists in several possible operations: * - Add Opposite ((-3)*x -> -(3*x), useful when printing fractions) * - Adding parenthesis if needed (a*(b+c) is not a*b+c) @@ -114,7 +114,7 @@ Expression MultiplicationExplicite::shallowBeautify(ExpressionNode::ReductionCon if (thisExp.type() == ExpressionNode::Type::Power) { return thisExp.shallowBeautify(reductionContext); } - assert(thisExp.type() == ExpressionNode::Type::MultiplicationExplicite); + assert(thisExp.type() == ExpressionNode::Type::MultiplicationExplicit); // Step 3: Create a Division if needed for (int i = 0; i < numberOfChildren(); i++) { @@ -143,15 +143,15 @@ Expression MultiplicationExplicite::shallowBeautify(ExpressionNode::ReductionCon return thisExp; } -Expression MultiplicationExplicite::denominator(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { +Expression MultiplicationExplicit::denominator(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const { // Merge negative power: a*b^-1*c^(-Pi)*d = a*(b*c^Pi)^-1 // WARNING: we do not want to change the expression but to create a new one. - MultiplicationExplicite thisClone = clone().convert(); + MultiplicationExplicit thisClone = clone().convert(); Expression e = thisClone.mergeNegativePower(context, complexFormat, angleUnit); if (e.type() == ExpressionNode::Type::Power) { return e.denominator(context, complexFormat, angleUnit); } else { - assert(e.type() == ExpressionNode::Type::MultiplicationExplicite); + assert(e.type() == ExpressionNode::Type::MultiplicationExplicit); for (int i = 0; i < e.numberOfChildren(); i++) { // a*b^(-1)*... -> a*.../b if (e.childAtIndex(i).type() == ExpressionNode::Type::Power @@ -165,7 +165,7 @@ Expression MultiplicationExplicite::denominator(Context * context, Preferences:: return Expression(); } -Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::ReductionContext reductionContext, bool shouldExpand, bool canBeInterrupted) { +Expression MultiplicationExplicit::privateShallowReduce(ExpressionNode::ReductionContext reductionContext, bool shouldExpand, bool canBeInterrupted) { { Expression e = Expression::defaultShallowReduce(); if (e.isUndefined()) { @@ -173,7 +173,7 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti } } - /* Step 1: MultiplicationExpliciteNode is associative, so let's start by merging children + /* Step 1: MultiplicationExplicitNode is associative, so let's start by merging children * which also are multiplications themselves. */ mergeMultiplicationChildrenInPlace(); @@ -232,7 +232,7 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti for (int j = 0; j < newResultM; j++) { Addition a = Addition::Builder(); for (int k = 0; k < n; k++) { - Expression e = MultiplicationExplicite::Builder(currentMatrix.matrixChild(i, k).clone(), resultMatrix.matrixChild(k, j).clone()); + Expression e = MultiplicationExplicit::Builder(currentMatrix.matrixChild(i, k).clone(), resultMatrix.matrixChild(k, j).clone()); a.addChildAtIndexInPlace(e, a.numberOfChildren(), a.numberOfChildren()); e.shallowReduce(reductionContext); } @@ -258,7 +258,7 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti } removeChildInPlace(resultMatrix, resultMatrix.numberOfChildren()); for (int i = 0; i < n*m; i++) { - MultiplicationExplicite m = clone().convert(); + MultiplicationExplicit m = clone().convert(); Expression entryI = resultMatrix.childAtIndex(i); resultMatrix.replaceChildInPlace(entryI, m); m.addChildAtIndexInPlace(entryI, m.numberOfChildren(), m.numberOfChildren()); @@ -440,8 +440,8 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti i--; } // The real children are both factors of the real and the imaginary multiplication - MultiplicationExplicite real = *this; - MultiplicationExplicite imag = clone().convert(); + MultiplicationExplicit real = *this; + MultiplicationExplicit imag = clone().convert(); real.addChildAtIndexInPlace(child.real(), real.numberOfChildren(), real.numberOfChildren()); imag.addChildAtIndexInPlace(child.imag(), real.numberOfChildren(), real.numberOfChildren()); ComplexCartesian newComplexCartesian = ComplexCartesian::Builder(); @@ -456,12 +456,12 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti return result; } -void MultiplicationExplicite::mergeMultiplicationChildrenInPlace() { +void MultiplicationExplicit::mergeMultiplicationChildrenInPlace() { // Multiplication is associative: a*(b*c)->a*b*c int i = 0; while (i < numberOfChildren()) { Expression c = childAtIndex(i); - if (c.type() == ExpressionNode::Type::MultiplicationExplicite) { + if (c.type() == ExpressionNode::Type::MultiplicationExplicit) { mergeChildrenAtIndexInPlace(c, i); // TODO: ensure that matrix children are not swapped to implement MATRIX_EXACT_REDUCING continue; } @@ -469,10 +469,10 @@ void MultiplicationExplicite::mergeMultiplicationChildrenInPlace() { } } -void MultiplicationExplicite::factorizeBase(int i, int j, ExpressionNode::ReductionContext reductionContext) { +void MultiplicationExplicit::factorizeBase(int i, int j, ExpressionNode::ReductionContext reductionContext) { /* This function factorizes two children which have a common base. For example - * if this is MultiplicationExplicite::Builder(pi^2, pi^3), then pi^2 and pi^3 could be merged - * and this turned into MultiplicationExplicite::Builder(pi^5). */ + * if this is MultiplicationExplicit::Builder(pi^2, pi^3), then pi^2 and pi^3 could be merged + * and this turned into MultiplicationExplicit::Builder(pi^5). */ Expression e = childAtIndex(j); // Step 1: Get rid of the child j @@ -481,7 +481,7 @@ void MultiplicationExplicite::factorizeBase(int i, int j, ExpressionNode::Reduct mergeInChildByFactorizingBase(i, e, reductionContext); } -void MultiplicationExplicite::mergeInChildByFactorizingBase(int i, Expression e, ExpressionNode::ReductionContext reductionContext) { +void MultiplicationExplicit::mergeInChildByFactorizingBase(int i, Expression e, ExpressionNode::ReductionContext reductionContext) { /* This function replace the child at index i by its factorization with e. e * and childAtIndex(i) are supposed to have a common base. */ @@ -496,17 +496,17 @@ void MultiplicationExplicite::mergeInChildByFactorizingBase(int i, Expression e, /* Step 4: Reducing the new power might have turned it into a multiplication, * ie: 12^(1/2) -> 2*3^(1/2). In that case, we need to merge the multiplication * node with this. */ - if (p.type() == ExpressionNode::Type::MultiplicationExplicite) { + if (p.type() == ExpressionNode::Type::MultiplicationExplicit) { mergeMultiplicationChildrenInPlace(); } } -void MultiplicationExplicite::factorizeExponent(int i, int j, ExpressionNode::ReductionContext reductionContext) { +void MultiplicationExplicit::factorizeExponent(int i, int j, ExpressionNode::ReductionContext reductionContext) { /* This function factorizes children which share a common exponent. For - * example, it turns MultiplicationExplicite::Builder(2^x,3^x) into MultiplicationExplicite::Builder(6^x). */ + * example, it turns MultiplicationExplicit::Builder(2^x,3^x) into MultiplicationExplicit::Builder(6^x). */ // Step 1: Find the new base - Expression m = MultiplicationExplicite::Builder(Base(childAtIndex(i)), Base(childAtIndex(j))); // 2^x*3^x -> (2*3)^x -> 6^x + Expression m = MultiplicationExplicit::Builder(Base(childAtIndex(i)), Base(childAtIndex(j))); // 2^x*3^x -> (2*3)^x -> 6^x // Step 2: Get rid of one of the children removeChildAtIndexInPlace(j); // Step 3: Replace the other child @@ -517,12 +517,12 @@ void MultiplicationExplicite::factorizeExponent(int i, int j, ExpressionNode::Re /* Step 5: Reducing the new power might have turned it into a multiplication, * ie: 12^(1/2) -> 2*3^(1/2). In that case, we need to merge the multiplication * node with this. */ - if (p.type() == ExpressionNode::Type::MultiplicationExplicite) { + if (p.type() == ExpressionNode::Type::MultiplicationExplicit) { mergeMultiplicationChildrenInPlace(); } } -Expression MultiplicationExplicite::distributeOnOperandAtIndex(int i, ExpressionNode::ReductionContext reductionContext) { +Expression MultiplicationExplicit::distributeOnOperandAtIndex(int i, ExpressionNode::ReductionContext reductionContext) { /* This method creates a*...*b*y... + a*...*c*y... + ... from * a*...*(b+c+...)*y... */ assert(i >= 0 && i < numberOfChildren()); @@ -532,7 +532,7 @@ Expression MultiplicationExplicite::distributeOnOperandAtIndex(int i, Expression Expression childI = childAtIndex(i); int numberOfAdditionTerms = childI.numberOfChildren(); for (int j = 0; j < numberOfAdditionTerms; j++) { - MultiplicationExplicite m = clone().convert(); + MultiplicationExplicit m = clone().convert(); m.replaceChildAtIndexInPlace(i, childI.childAtIndex(j)); // Reduce m: pi^(-1)*(pi + x) -> pi^(-1)*pi + pi^(-1)*x -> 1 + pi^(-1)*x a.addChildAtIndexInPlace(m, a.numberOfChildren(), a.numberOfChildren()); @@ -542,8 +542,8 @@ Expression MultiplicationExplicite::distributeOnOperandAtIndex(int i, Expression return a.shallowReduce(reductionContext); // Order terms, put under a common denominator if needed } -void MultiplicationExplicite::addMissingFactors(Expression factor, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { - if (factor.type() == ExpressionNode::Type::MultiplicationExplicite) { +void MultiplicationExplicit::addMissingFactors(Expression factor, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { + if (factor.type() == ExpressionNode::Type::MultiplicationExplicit) { for (int j = 0; j < factor.numberOfChildren(); j++) { addMissingFactors(factor.childAtIndex(j), context, complexFormat, angleUnit); } @@ -590,7 +590,7 @@ void MultiplicationExplicite::addMissingFactors(Expression factor, Context * con sortChildrenInPlace([](const ExpressionNode * e1, const ExpressionNode * e2, bool canBeInterrupted) { return ExpressionNode::SimplificationOrder(e1, e2, true, canBeInterrupted); }, context, true); } -void MultiplicationExplicite::factorizeSineAndCosine(int i, int j, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { +void MultiplicationExplicit::factorizeSineAndCosine(int i, int j, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { /* This function turn sin(x)^p * cos(x)^q into either: * - tan(x)^p*cos(x)^(p+q) if |p|<|q| * - tan(x)^(-q)*sin(x)^(p+q) otherwise */ @@ -630,7 +630,7 @@ void MultiplicationExplicite::factorizeSineAndCosine(int i, int j, Context * con } } -bool MultiplicationExplicite::HaveSameNonNumeralFactors(const Expression & e1, const Expression & e2) { +bool MultiplicationExplicit::HaveSameNonNumeralFactors(const Expression & e1, const Expression & e2) { assert(e1.numberOfChildren() > 0); assert(e2.numberOfChildren() > 0); int numberOfNonNumeralFactors1 = e1.childAtIndex(0).isNumber() ? e1.numberOfChildren()-1 : e1.numberOfChildren(); @@ -651,26 +651,26 @@ bool MultiplicationExplicite::HaveSameNonNumeralFactors(const Expression & e1, c return true; } -const Expression MultiplicationExplicite::CreateExponent(Expression e) { +const Expression MultiplicationExplicit::CreateExponent(Expression e) { Expression result = e.type() == ExpressionNode::Type::Power ? e.childAtIndex(1).clone() : Rational::Builder(1); return result; } -bool MultiplicationExplicite::TermsHaveIdenticalBase(const Expression & e1, const Expression & e2) { +bool MultiplicationExplicit::TermsHaveIdenticalBase(const Expression & e1, const Expression & e2) { return Base(e1).isIdenticalTo(Base(e2)); } -bool MultiplicationExplicite::TermsHaveIdenticalExponent(const Expression & e1, const Expression & e2) { +bool MultiplicationExplicit::TermsHaveIdenticalExponent(const Expression & e1, const Expression & e2) { /* Note: We will return false for e1=2 and e2=Pi, even though one could argue * that these have the same exponent whose value is 1. */ return e1.type() == ExpressionNode::Type::Power && e2.type() == ExpressionNode::Type::Power && (e1.childAtIndex(1).isIdenticalTo(e2.childAtIndex(1))); } -bool MultiplicationExplicite::TermHasNumeralBase(const Expression & e) { +bool MultiplicationExplicit::TermHasNumeralBase(const Expression & e) { return Base(e).isNumber(); } -bool MultiplicationExplicite::TermHasNumeralExponent(const Expression & e) { +bool MultiplicationExplicit::TermHasNumeralExponent(const Expression & e) { if (e.type() != ExpressionNode::Type::Power) { return true; } @@ -680,10 +680,10 @@ bool MultiplicationExplicite::TermHasNumeralExponent(const Expression & e) { return false; } -Expression MultiplicationExplicite::mergeNegativePower(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { +Expression MultiplicationExplicit::mergeNegativePower(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) { /* mergeNegativePower groups all factors that are power of form a^(-b) together * for instance, a^(-1)*b^(-c)*c = c*(a*b^c)^(-1) */ - MultiplicationExplicite m = MultiplicationExplicite::Builder(); + MultiplicationExplicit m = MultiplicationExplicit::Builder(); // Special case for rational p/q: if q != 1, q should be at denominator if (childAtIndex(0).type() == ExpressionNode::Type::Rational && !childAtIndex(0).convert().isInteger()) { Rational r = childAtIndex(0).convert(); @@ -724,7 +724,7 @@ Expression MultiplicationExplicite::mergeNegativePower(Context * context, Prefer return squashUnaryHierarchyInPlace(); } -const Expression MultiplicationExplicite::Base(const Expression e) { +const Expression MultiplicationExplicit::Base(const Expression e) { if (e.type() == ExpressionNode::Type::Power) { return e.childAtIndex(0); } diff --git a/poincare/src/multiplication_implicite.cpp b/poincare/src/multiplication_implicit.cpp similarity index 50% rename from poincare/src/multiplication_implicite.cpp rename to poincare/src/multiplication_implicit.cpp index d66a425ff..26b34c0a1 100644 --- a/poincare/src/multiplication_implicite.cpp +++ b/poincare/src/multiplication_implicit.cpp @@ -1,5 +1,5 @@ -#include -#include +#include +#include #include #include #include @@ -9,19 +9,19 @@ namespace Poincare { -Layout MultiplicationImpliciteNode::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { - return LayoutHelper::Infix(MultiplicationImplicite(this), floatDisplayMode, numberOfSignificantDigits, ""); +Layout MultiplicationImplicitNode::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { + return LayoutHelper::Infix(MultiplicationImplicit(this), floatDisplayMode, numberOfSignificantDigits, ""); } -int MultiplicationImpliciteNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { +int MultiplicationImplicitNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return SerializationHelper::Infix(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, ""); } -Expression MultiplicationImpliciteNode::shallowReduce(ReductionContext reductionContext) { - return MultiplicationImplicite(this).shallowReduce(reductionContext); +Expression MultiplicationImplicitNode::shallowReduce(ReductionContext reductionContext) { + return MultiplicationImplicit(this).shallowReduce(reductionContext); } -bool MultiplicationImpliciteNode::childNeedsSystemParenthesesAtSerialization(const TreeNode * child) const { +bool MultiplicationImplicitNode::childNeedsSystemParenthesesAtSerialization(const TreeNode * child) const { /* 2 * ---i --> [2/3]i * 3 @@ -34,7 +34,7 @@ bool MultiplicationImpliciteNode::childNeedsSystemParenthesesAtSerialization(con /* Multiplication */ -Expression MultiplicationImplicite::shallowReduce(ExpressionNode::ReductionContext reductionContext) { +Expression MultiplicationImplicit::shallowReduce(ExpressionNode::ReductionContext reductionContext) { { Expression e = Expression::defaultShallowReduce(); if (e.isUndefined()) { @@ -42,7 +42,7 @@ Expression MultiplicationImplicite::shallowReduce(ExpressionNode::ReductionConte } } assert(numberOfChildren() == 2); - MultiplicationExplicite m = MultiplicationExplicite::Builder(); + MultiplicationExplicit m = MultiplicationExplicit::Builder(); for (int i = 0; i < numberOfChildren(); i++) { m.addChildAtIndexInPlace(childAtIndex(i), i, i); } diff --git a/poincare/src/opposite.cpp b/poincare/src/opposite.cpp index d4e0f5036..ef1653ed7 100644 --- a/poincare/src/opposite.cpp +++ b/poincare/src/opposite.cpp @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include @@ -79,7 +79,7 @@ Expression Opposite::shallowReduce(ExpressionNode::ReductionContext reductionCon return result; } Expression child = result.childAtIndex(0); - result = MultiplicationExplicite::Builder(Rational::Builder(-1), child); + result = MultiplicationExplicit::Builder(Rational::Builder(-1), child); replaceWithInPlace(result); return result.shallowReduce(reductionContext); } diff --git a/poincare/src/parsing/parser.cpp b/poincare/src/parsing/parser.cpp index 6f23389a5..442976c68 100644 --- a/poincare/src/parsing/parser.cpp +++ b/poincare/src/parsing/parser.cpp @@ -151,7 +151,7 @@ void Parser::parseNumber(Expression & leftHandSide, Token::Type stoppingType) { } leftHandSide = m_currentToken.expression(); if (m_nextToken.is(Token::Number)) { - m_status = Status::Error; // No implicite multiplication between two numbers + m_status = Status::Error; // No implicit multiplication between two numbers return; } isThereImplicitMultiplication(); @@ -196,11 +196,11 @@ void Parser::parseMinus(Expression & leftHandSide, Token::Type stoppingType) { void Parser::parseTimes(Expression & leftHandSide, Token::Type stoppingType) { Expression rightHandSide; if (parseBinaryOperator(leftHandSide, rightHandSide, Token::Times)) { - if (leftHandSide.type() == ExpressionNode::Type::MultiplicationExplicite) { + if (leftHandSide.type() == ExpressionNode::Type::MultiplicationExplicit) { int childrenCount = leftHandSide.numberOfChildren(); - static_cast(leftHandSide).addChildAtIndexInPlace(rightHandSide, childrenCount, childrenCount); + static_cast(leftHandSide).addChildAtIndexInPlace(rightHandSide, childrenCount, childrenCount); } else { - leftHandSide = MultiplicationExplicite::Builder(leftHandSide, rightHandSide); + leftHandSide = MultiplicationExplicit::Builder(leftHandSide, rightHandSide); } } } @@ -215,7 +215,7 @@ void Parser::parseSlash(Expression & leftHandSide, Token::Type stoppingType) { void Parser::parseImplicitTimes(Expression & leftHandSide, Token::Type stoppingType) { Expression rightHandSide; if (parseBinaryOperator(leftHandSide, rightHandSide, Token::Slash)) { - leftHandSide = MultiplicationImplicite::Builder(leftHandSide, rightHandSide); + leftHandSide = MultiplicationImplicit::Builder(leftHandSide, rightHandSide); } } diff --git a/poincare/src/power.cpp b/poincare/src/power.cpp index 05bea2833..bff77b1e7 100644 --- a/poincare/src/power.cpp +++ b/poincare/src/power.cpp @@ -109,7 +109,7 @@ bool PowerNode::childNeedsUserParentheses(const Expression & child) const { return true; } // ^(2+3,4) --> (2+3)^{4} - Type types[] = {Type::Power, Type::Subtraction, Type::Opposite, Type::MultiplicationExplicite, Type::MultiplicationImplicite, Type::Division, Type::Addition}; + Type types[] = {Type::Power, Type::Subtraction, Type::Opposite, Type::MultiplicationExplicit, Type::MultiplicationImplicit, Type::Division, Type::Addition}; return child.isOfType(types, 7); } return false; @@ -169,7 +169,7 @@ bool PowerNode::childNeedsSystemParenthesesAtSerialization(const TreeNode * chil if (static_cast(child)->type() == Type::Rational && !static_cast(child)->isInteger()) { return true; } - Type types[] = {Type::Power, Type::Subtraction, Type::Opposite, Type::MultiplicationExplicite, Type::MultiplicationImplicite, Type::Division, Type::Addition}; + Type types[] = {Type::Power, Type::Subtraction, Type::Opposite, Type::MultiplicationExplicit, Type::MultiplicationImplicit, Type::Division, Type::Addition}; return static_cast(child)->isOfType(types, 7); } @@ -345,7 +345,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex Expression result = matrixBase.clone(); // TODO: implement a quick exponentiation for (int k = 1; k < exp; k++) { - result = MultiplicationExplicite::Builder(result, matrixBase.clone()); + result = MultiplicationExplicit::Builder(result, matrixBase.clone()); result = result.shallowReduce(reductionContext); } assert(!result.isUninitialized()); @@ -515,7 +515,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex if (base.sign(reductionContext.context()) == ExpressionNode::Sign::Negative) { // (-inf)^x --> (-1)^x*inf Power p = Power::Builder(Rational::Builder(-1), childAtIndex(1)); - result = MultiplicationExplicite::Builder(p, result); + result = MultiplicationExplicit::Builder(p, result); p.shallowReduce(reductionContext); } } @@ -553,7 +553,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex replaceChildAtIndexInPlace(0, m0); /* m0 doesn't need to be shallowReduce as * makePositiveAnyNegativeNumeralFactor returns a reduced expression */ - MultiplicationExplicite m1 = MultiplicationExplicite::Builder(); + MultiplicationExplicit m1 = MultiplicationExplicit::Builder(); replaceWithInPlace(m1); // Multiply m1 by i complex Constant i = Constant::Builder(UCodePointMathematicalBoldSmallI); @@ -567,14 +567,14 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex // Step 8: e^(r*i*Pi) with r rational --> cos(pi*r) + i*sin(pi*r) if (!letPowerAtRoot && isNthRootOfUnity()) { Expression i = index.childAtIndex(index.numberOfChildren()-2); - static_cast(index).removeChildAtIndexInPlace(index.numberOfChildren()-2); + static_cast(index).removeChildAtIndexInPlace(index.numberOfChildren()-2); if (reductionContext.angleUnit() == Preferences::AngleUnit::Degree) { index.replaceChildAtIndexInPlace(index.numberOfChildren()-1, Rational::Builder(180)); } Expression cos = Cosine::Builder(index); index = index.shallowReduce(reductionContext); Expression sin = Sine::Builder(index.clone()); - Expression complexPart = MultiplicationExplicite::Builder(sin, i); + Expression complexPart = MultiplicationExplicit::Builder(sin, i); sin.shallowReduce(reductionContext); Expression a = Addition::Builder(cos, complexPart); cos.shallowReduce(reductionContext); @@ -643,8 +643,8 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex } } // Step 11: (a*b*c*...)^r ? - if (!letPowerAtRoot && baseType == ExpressionNode::Type::MultiplicationExplicite) { - MultiplicationExplicite multiplicationBase = static_cast(base); + if (!letPowerAtRoot && baseType == ExpressionNode::Type::MultiplicationExplicit) { + MultiplicationExplicit multiplicationBase = static_cast(base); // Case 1: (a*b*c*...)^n = a^n*b^n*c^n*... if n integer if (indexType == ExpressionNode::Type::Rational && static_cast(index).isInteger()) { return simplifyPowerMultiplication(reductionContext); @@ -674,7 +674,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex // |a|^r*(sign(a)*b*...)^r Power thisRef = *this; - MultiplicationExplicite root = MultiplicationExplicite::Builder(p); + MultiplicationExplicit root = MultiplicationExplicit::Builder(p); replaceWithInPlace(root); root.addChildAtIndexInPlace(thisRef, 1, 1); p.shallowReduce(reductionContext); @@ -718,7 +718,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex additionIndex.removeChildAtIndexInPlace(0); // p2 = a^(c+...) // if addition had only 2 children additionIndex.squashUnaryHierarchyInPlace(); - MultiplicationExplicite m = MultiplicationExplicite::Builder(p1); + MultiplicationExplicit m = MultiplicationExplicit::Builder(p1); replaceWithInPlace(m); m.addChildAtIndexInPlace(thisRef, 1, 1); p1.simplifyRationalRationalPower(reductionContext); @@ -762,7 +762,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex // We need a 'double' distribution and newA will hold the new expanded form Expression newA = Addition::Builder(); for (int j = 0; j < a.numberOfChildren(); j++) { - Expression m = MultiplicationExplicite::Builder(result.clone(), a.childAtIndex(j).clone()).distributeOnOperandAtIndex(0, reductionContext); + Expression m = MultiplicationExplicit::Builder(result.clone(), a.childAtIndex(j).clone()).distributeOnOperandAtIndex(0, reductionContext); if (newA.type() == ExpressionNode::Type::Addition) { static_cast(newA).addChildAtIndexInPlace(m, newA.numberOfChildren(), newA.numberOfChildren()); } else { @@ -774,7 +774,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex result = newA; } else { // Just distribute result on a - MultiplicationExplicite m = MultiplicationExplicite::Builder(a.clone(), result.clone()); + MultiplicationExplicit m = MultiplicationExplicit::Builder(a.clone(), result.clone()); Expression distributedM = m.distributeOnOperandAtIndex(0, reductionContext); result.replaceWithInPlace(distributedM); result = distributedM; @@ -809,7 +809,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex Power * p0 = new Power::Builder(x0->clone(), new Rational::Builder(i), false); Power * p1 = new Power::Builder(x1->clone(), new Rational::Builder(clippedN-i), false); const Expression * operands[3] = {r, p0, p1}; - MultiplicationExplicite * m = new MultiplicationExplicite::Builder(operands, 3, false); + MultiplicationExplicit * m = new MultiplicationExplicit::Builder(operands, 3, false); p0->shallowReduce(reductionContext); p1->shallowReduce(reductionContext); a->addOperand(m); @@ -890,7 +890,7 @@ Expression Power::denominator(Context * context, Preferences::ComplexFormat comp Expression Power::simplifyPowerPower(ExpressionNode::ReductionContext reductionContext) { // this is p^e = (a^b)^e, we want a^(b*e) Expression p = childAtIndex(0); - MultiplicationExplicite m = MultiplicationExplicite::Builder(p.childAtIndex(1), childAtIndex(1)); + MultiplicationExplicit m = MultiplicationExplicit::Builder(p.childAtIndex(1), childAtIndex(1)); replaceChildAtIndexInPlace(0, p.childAtIndex(0)); replaceChildAtIndexInPlace(1, m); m.shallowReduce(reductionContext); @@ -932,7 +932,7 @@ Expression Power::simplifyRationalRationalPower(ExpressionNode::ReductionContext n = CreateSimplifiedIntegerRationalPower(a.signedIntegerNumerator(), b, false, reductionContext); d = CreateSimplifiedIntegerRationalPower(a.integerDenominator(), b, true, reductionContext); } - MultiplicationExplicite m = MultiplicationExplicite::Builder(n, d); + MultiplicationExplicit m = MultiplicationExplicit::Builder(n, d); replaceWithInPlace(m); return m.shallowReduce(reductionContext); } @@ -975,7 +975,7 @@ Expression Power::CreateSimplifiedIntegerRationalPower(Integer i, Rational r, bo } Integer one(1); Rational r3 = isDenominator ? Rational::Builder(one, r1) : Rational::Builder(r1); - MultiplicationExplicite m = MultiplicationExplicite::Builder(); + MultiplicationExplicit m = MultiplicationExplicit::Builder(); m.addChildAtIndexInPlace(r3, 0, 0); if (!r2.isOne()) { m.addChildAtIndexInPlace(p, 1, 1); @@ -1028,9 +1028,9 @@ Expression Power::removeSquareRootsFromDenominator(ExpressionNode::ReductionCont Power sqrt = Power::Builder(Rational::Builder(pq), Rational::Builder(1, 2)); Integer one(1); if (castedChild1.isHalf()) { - result = MultiplicationExplicite::Builder(Rational::Builder(one, q), sqrt); + result = MultiplicationExplicit::Builder(Rational::Builder(one, q), sqrt); } else { - result = MultiplicationExplicite::Builder(Rational::Builder(one, p), sqrt); // We use here the assertion that p != 0 + result = MultiplicationExplicit::Builder(Rational::Builder(one, p), sqrt); // We use here the assertion that p != 0 } sqrt.shallowReduce(reductionContext); } @@ -1085,11 +1085,11 @@ Expression Power::removeSquareRootsFromDenominator(ExpressionNode::ReductionCont Integer factor1 = Integer::Multiplication( Integer::Multiplication(n1, d1), Integer::Multiplication(Integer::Power(d2, Integer(2)), q2)); - Multiplication m1 = MultiplicationExplicite::Builder(Rational::Builder(factor1), sqrt1); + Multiplication m1 = MultiplicationExplicit::Builder(Rational::Builder(factor1), sqrt1); Integer factor2 = Integer::Multiplication( Integer::Multiplication(n2, d2), Integer::Multiplication(Integer::Power(d1, Integer(2)), q1)); - Multiplication m2 = MultiplicationExplicite::Builder(Rational::Builder(factor2), sqrt2); + Multiplication m2 = MultiplicationExplicit::Builder(Rational::Builder(factor2), sqrt2); Expression numerator; if (denominator.isNegative()) { numerator = Subtraction::Builder(m2, m1); @@ -1102,7 +1102,7 @@ Expression Power::removeSquareRootsFromDenominator(ExpressionNode::ReductionCont } numerator = numerator.deepReduce(reductionContext); Integer one(1); - result = MultiplicationExplicite::Builder(numerator, Rational::Builder(one, denominator)); + result = MultiplicationExplicit::Builder(numerator, Rational::Builder(one, denominator)); } if (!result.isUninitialized()) { @@ -1147,7 +1147,7 @@ bool Power::isNthRootOfUnity() const { if (childAtIndex(0).type() != ExpressionNode::Type::Constant || !childAtIndex(0).convert().isExponential()) { return false; } - if (childAtIndex(1).type() != ExpressionNode::Type::MultiplicationExplicite) { + if (childAtIndex(1).type() != ExpressionNode::Type::MultiplicationExplicit) { return false; } if (childAtIndex(1).numberOfChildren() < 2 || childAtIndex(1).numberOfChildren() > 3) { @@ -1190,7 +1190,7 @@ Expression Power::CreateComplexExponent(const Expression & r, ExpressionNode::Re const Constant exp = Constant::Builder(UCodePointScriptSmallE); Constant iComplex = Constant::Builder(UCodePointMathematicalBoldSmallI); const Constant pi = Constant::Builder(UCodePointGreekSmallLetterPi); - MultiplicationExplicite mExp = MultiplicationExplicite::Builder(iComplex, pi, r.clone()); + MultiplicationExplicit mExp = MultiplicationExplicit::Builder(iComplex, pi, r.clone()); iComplex.shallowReduce(reductionContext); Power p = Power::Builder(exp, mExp); mExp.shallowReduce(reductionContext); @@ -1198,10 +1198,10 @@ Expression Power::CreateComplexExponent(const Expression & r, ExpressionNode::Re #if 0 const Constant iComplex = Constant::Builder(UCodePointMathematicalBoldSmallI); const Constant pi = Constant::Builder(UCodePointGreekSmallLetterPi); - Expression op = MultiplicationExplicite::Builder(pi, r).shallowReduce(context, complexFormat, angleUnit, false); + Expression op = MultiplicationExplicit::Builder(pi, r).shallowReduce(context, complexFormat, angleUnit, false); Cosine cos = Cosine(op).shallowReduce(context, complexFormat, angleUnit, false);; Sine sin = Sine(op).shallowReduce(context, complexFormat, angleUnit, false); - Expression m = MultiplicationExplicite::Builder(iComplex, sin); + Expression m = MultiplicationExplicit::Builder(iComplex, sin); Expression a = Addition::Builder(cos, m); const Expression * multExpOperands[3] = {pi, r->clone()}; #endif @@ -1218,7 +1218,7 @@ bool Power::TermIsARationalSquareRootOrRational(const Expression & e) { { return true; } - if (e.type() == ExpressionNode::Type::MultiplicationExplicite + if (e.type() == ExpressionNode::Type::MultiplicationExplicit && e.numberOfChildren() == 2 && e.childAtIndex(0).type() == ExpressionNode::Type::Rational && e.childAtIndex(1).type() == ExpressionNode::Type::Power @@ -1239,7 +1239,7 @@ const Rational Power::RadicandInExpression(const Expression & e) { assert(e.childAtIndex(0).type() == ExpressionNode::Type::Rational); return e.childAtIndex(0).convert(); } else { - assert(e.type() == ExpressionNode::Type::MultiplicationExplicite); + assert(e.type() == ExpressionNode::Type::MultiplicationExplicit); assert(e.childAtIndex(1).type() == ExpressionNode::Type::Power); assert(e.childAtIndex(1).childAtIndex(0).type() == ExpressionNode::Type::Rational); return e.childAtIndex(1).childAtIndex(0).convert(); @@ -1252,7 +1252,7 @@ const Rational Power::RationalFactorInExpression(const Expression & e) { } else if (e.type() == ExpressionNode::Type::Power) { return Rational::Builder(1); } else { - assert(e.type() == ExpressionNode::Type::MultiplicationExplicite); + assert(e.type() == ExpressionNode::Type::MultiplicationExplicit); assert(e.childAtIndex(0).type() == ExpressionNode::Type::Rational); return e.childAtIndex(0).convert(); } diff --git a/poincare/src/prediction_interval.cpp b/poincare/src/prediction_interval.cpp index 915a468fb..9a4cd51b0 100644 --- a/poincare/src/prediction_interval.cpp +++ b/poincare/src/prediction_interval.cpp @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include #include @@ -89,9 +89,9 @@ Expression PredictionInterval::shallowReduce(ExpressionNode::ReductionContext re } // Compute sqr = sqrt(r0*(1-r0)/r1) Expression sqr = Power::Builder(Division::Builder(numerator, r1), Rational::Builder(1, 2)); - Expression m = MultiplicationExplicite::Builder(Rational::Builder(196, 100), sqr); + Expression m = MultiplicationExplicit::Builder(Rational::Builder(196, 100), sqr); Matrix matrix = Matrix::Builder(); - matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), MultiplicationExplicite::Builder(Rational::Builder(-1), m.clone())), 0, 0); + matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), MultiplicationExplicit::Builder(Rational::Builder(-1), m.clone())), 0, 0); matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), m), 1, 1); matrix.setDimensions(1, 2); replaceWithInPlace(matrix); diff --git a/poincare/src/sign_function.cpp b/poincare/src/sign_function.cpp index f15c11d18..e60ef8b06 100644 --- a/poincare/src/sign_function.cpp +++ b/poincare/src/sign_function.cpp @@ -84,7 +84,7 @@ Expression SignFunction::shallowReduce(ExpressionNode::ReductionContext reductio return *this; } Expression sign = *this; - Multiplication m = MultiplicationExplicite::Builder(Rational::Builder(-1)); + Multiplication m = MultiplicationExplicit::Builder(Rational::Builder(-1)); replaceWithInPlace(m); m.addChildAtIndexInPlace(sign, 1, 1); // sign does not need to be shallowReduced because -x = NAN --> x = NAN return m; // m does not need to be shallowReduced, -1*sign cannot be reduced diff --git a/poincare/src/subtraction.cpp b/poincare/src/subtraction.cpp index c6b3aee67..e25425445 100644 --- a/poincare/src/subtraction.cpp +++ b/poincare/src/subtraction.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include #include @@ -54,7 +54,7 @@ Expression Subtraction::shallowReduce(ExpressionNode::ReductionContext reduction if (e.isUndefined()) { return e; } - Expression m = MultiplicationExplicite::Builder(Rational::Builder(-1), childAtIndex(1)); + Expression m = MultiplicationExplicit::Builder(Rational::Builder(-1), childAtIndex(1)); Addition a = Addition::Builder(childAtIndex(0), m); m = m.shallowReduce(reductionContext); replaceWithInPlace(a); diff --git a/poincare/src/tree_handle.cpp b/poincare/src/tree_handle.cpp index 0ca34a70b..24252d129 100644 --- a/poincare/src/tree_handle.cpp +++ b/poincare/src/tree_handle.cpp @@ -314,8 +314,8 @@ template MatrixIdentity TreeHandle::FixedArityBuilder(TreeHandle*, size_t); template MatrixTrace TreeHandle::FixedArityBuilder(TreeHandle*, size_t); template MatrixTranspose TreeHandle::FixedArityBuilder(TreeHandle*, size_t); -template MultiplicationExplicite TreeHandle::NAryBuilder(TreeHandle*, size_t); -template MultiplicationImplicite TreeHandle::NAryBuilder(TreeHandle*, size_t); +template MultiplicationExplicit TreeHandle::NAryBuilder(TreeHandle*, size_t); +template MultiplicationImplicit TreeHandle::NAryBuilder(TreeHandle*, size_t); template NaperianLogarithm TreeHandle::FixedArityBuilder(TreeHandle*, size_t); template NthRoot TreeHandle::FixedArityBuilder(TreeHandle*, size_t); template Opposite TreeHandle::FixedArityBuilder(TreeHandle*, size_t); diff --git a/poincare/src/trigonometry.cpp b/poincare/src/trigonometry.cpp index d07daf5f6..5cb40f75c 100644 --- a/poincare/src/trigonometry.cpp +++ b/poincare/src/trigonometry.cpp @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include #include #include @@ -82,7 +82,7 @@ bool Trigonometry::AreInverseFunctions(const Expression & directFunction, const bool Trigonometry::ExpressionIsEquivalentToTangent(const Expression & e) { // We look for (cos^-1 * sin) assert(ExpressionNode::Type::Power < ExpressionNode::Type::Sine); - if (e.type() == ExpressionNode::Type::MultiplicationExplicite + if (e.type() == ExpressionNode::Type::MultiplicationExplicit && e.childAtIndex(1).type() == ExpressionNode::Type::Sine && e.childAtIndex(0).type() == ExpressionNode::Type::Power && e.childAtIndex(0).childAtIndex(0).type() == ExpressionNode::Type::Cosine @@ -125,7 +125,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN Power::Builder( Addition::Builder( Rational::Builder(1), - MultiplicationExplicite::Builder( + MultiplicationExplicit::Builder( Rational::Builder(-1), Power::Builder(e.childAtIndex(0).childAtIndex(0), Rational::Builder(2)) ) @@ -166,7 +166,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN // reduce 1+*x^2 res.childAtIndex(0).shallowReduce(reductionContext); if (e.type() == ExpressionNode::Type::Sine) { - res = MultiplicationExplicite::Builder(x, res); + res = MultiplicationExplicit::Builder(x, res); // reduce (1+x^2)^(-1/2) res.childAtIndex(0).shallowReduce(reductionContext); } @@ -184,7 +184,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN return e.shallowReduce(reductionContext); } else { // sin(-a) = -sin(a) or tan(-a) = -tan(a) - MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1)); + MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1)); e.replaceWithInPlace(m); m.addChildAtIndexInPlace(e, 1, 1); e.shallowReduce(reductionContext); @@ -197,7 +197,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN * multiply the cos/sin/tan by -1 if needed. * We know thanks to Step 3 that p/q > 0. */ if ((reductionContext.angleUnit() == Preferences::AngleUnit::Radian - && e.childAtIndex(0).type() == ExpressionNode::Type::MultiplicationExplicite + && e.childAtIndex(0).type() == ExpressionNode::Type::MultiplicationExplicit && e.childAtIndex(0).numberOfChildren() == 2 && e.childAtIndex(0).childAtIndex(1).type() == ExpressionNode::Type::Constant && e.childAtIndex(0).childAtIndex(1).convert().isPi() @@ -250,7 +250,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN unaryCoefficient *= -1; } Expression simplifiedCosine = e.shallowReduce(reductionContext); // recursive - MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(unaryCoefficient)); + MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(unaryCoefficient)); simplifiedCosine.replaceWithInPlace(m); m.addChildAtIndexInPlace(simplifiedCosine, 1, 1); return m.shallowReduce(reductionContext); @@ -303,12 +303,12 @@ Expression Trigonometry::shallowReduceInverseFunction(Expression & e, Expressio * reduced to undef) */ if (reductionContext.target() == ExpressionNode::ReductionTarget::User || x.isNumber()) { Expression sign = SignFunction::Builder(x.clone()); - MultiplicationExplicite m0 = MultiplicationExplicite::Builder(Rational::Builder(1,2), sign, Constant::Builder(UCodePointGreekSmallLetterPi)); + MultiplicationExplicit m0 = MultiplicationExplicit::Builder(Rational::Builder(1,2), sign, Constant::Builder(UCodePointGreekSmallLetterPi)); sign.shallowReduce(reductionContext); e.replaceChildAtIndexInPlace(0, x); Addition a = Addition::Builder(m0); e.replaceWithInPlace(a); - MultiplicationExplicite m1 = MultiplicationExplicite::Builder(Rational::Builder(-1), e); + MultiplicationExplicit m1 = MultiplicationExplicit::Builder(Rational::Builder(-1), e); e.shallowReduce(reductionContext); a.addChildAtIndexInPlace(m1, 1, 1); return a.shallowReduce(reductionContext); @@ -348,7 +348,7 @@ Expression Trigonometry::shallowReduceInverseFunction(Expression & e, Expressio return s.shallowReduce(reductionContext); } else { // asin(-x) = -asin(x) or atan(-x) = -atan(x) - MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1)); + MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1)); e.replaceWithInPlace(m); m.addChildAtIndexInPlace(e, 1, 1); e.shallowReduce(reductionContext); diff --git a/poincare/src/trigonometry_cheat_table.cpp b/poincare/src/trigonometry_cheat_table.cpp index 85e758cc3..1a75a950e 100644 --- a/poincare/src/trigonometry_cheat_table.cpp +++ b/poincare/src/trigonometry_cheat_table.cpp @@ -41,11 +41,11 @@ Expression TrigonometryCheatTable::simplify(const Expression e, ExpressionNode:: && e.type() != ExpressionNode::Type::Rational) || (inputType == Type::AngleInRadians && e.type() != ExpressionNode::Type::Rational - && e.type() != ExpressionNode::Type::MultiplicationExplicite + && e.type() != ExpressionNode::Type::MultiplicationExplicit && e.type() != ExpressionNode::Type::Constant) || (inputType > Type::AngleInRadians && e.type() != ExpressionNode::Type::Rational - && e.type() != ExpressionNode::Type::MultiplicationExplicite + && e.type() != ExpressionNode::Type::MultiplicationExplicit && e.type() != ExpressionNode::Type::Power && e.type() != ExpressionNode::Type::Addition)) { diff --git a/poincare/test/expression_order.cpp b/poincare/test/expression_order.cpp index cc739014e..750283ade 100644 --- a/poincare/test/expression_order.cpp +++ b/poincare/test/expression_order.cpp @@ -35,8 +35,8 @@ QUIZ_CASE(poincare_expression_order_rational) { void assert_multiplication_or_addition_is_ordered_as(Expression e1, Expression e2) { Shared::GlobalContext globalContext; - if (e1.type() == ExpressionNode::Type::MultiplicationExplicite) { - static_cast(e1).sortChildrenInPlace( + if (e1.type() == ExpressionNode::Type::MultiplicationExplicit) { + static_cast(e1).sortChildrenInPlace( [](const ExpressionNode * e1, const ExpressionNode * e2, bool canBeInterrupted) { return ExpressionNode::SimplificationOrder(e1, e2, true, canBeInterrupted); }, &globalContext, true); @@ -53,13 +53,13 @@ void assert_multiplication_or_addition_is_ordered_as(Expression e1, Expression e QUIZ_CASE(poincare_expression_order_addition_multiplication) { { // 2 * 5 -> 2 * 5 - Expression e1 = MultiplicationExplicite::Builder(Rational::Builder(2), Rational::Builder(5)); + Expression e1 = MultiplicationExplicit::Builder(Rational::Builder(2), Rational::Builder(5)); assert_multiplication_or_addition_is_ordered_as(e1, e1); } { // 5 * 2 -> 2 * 5 - Expression e1 = MultiplicationExplicite::Builder(Rational::Builder(5), Rational::Builder(2)); - Expression e2 = MultiplicationExplicite::Builder(Rational::Builder(2), Rational::Builder(5)); + Expression e1 = MultiplicationExplicit::Builder(Rational::Builder(5), Rational::Builder(2)); + Expression e2 = MultiplicationExplicit::Builder(Rational::Builder(2), Rational::Builder(5)); assert_multiplication_or_addition_is_ordered_as(e1, e2); } { @@ -85,8 +85,8 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) { } { // root(3) $ 2 -> 2 * root(3) - Expression e1 = MultiplicationExplicite::Builder(SquareRoot::Builder(Rational::Builder(3)), Rational::Builder(2)); - Expression e2 = MultiplicationExplicite::Builder(Rational::Builder(2), SquareRoot::Builder(Rational::Builder(3))); + Expression e1 = MultiplicationExplicit::Builder(SquareRoot::Builder(Rational::Builder(3)), Rational::Builder(2)); + Expression e2 = MultiplicationExplicit::Builder(Rational::Builder(2), SquareRoot::Builder(Rational::Builder(3))); assert_multiplication_or_addition_is_ordered_as(e1, e2); } { @@ -110,16 +110,16 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) { } { // 3*x^2 + 2*x^3 -> 2*x^3 + 3*x^2 - Expression child1 = MultiplicationExplicite::Builder(Rational::Builder(2), Power::Builder(Symbol::Builder('x'), Rational::Builder(3))); - Expression child2 = MultiplicationExplicite::Builder(Rational::Builder(3), Power::Builder(Symbol::Builder('x'), Rational::Builder(2))); + Expression child1 = MultiplicationExplicit::Builder(Rational::Builder(2), Power::Builder(Symbol::Builder('x'), Rational::Builder(3))); + Expression child2 = MultiplicationExplicit::Builder(Rational::Builder(3), Power::Builder(Symbol::Builder('x'), Rational::Builder(2))); Expression e1 = Addition::Builder(child2.clone(), child1.clone()); Expression e2 = Addition::Builder(child1, child2); assert_multiplication_or_addition_is_ordered_as(e1, e2); } { // 2*x + 3*x -> 3*x + 2*x - Expression child1 = MultiplicationExplicite::Builder(Rational::Builder(3), Symbol::Builder('x')); - Expression child2 = MultiplicationExplicite::Builder(Rational::Builder(2), Symbol::Builder('x')); + Expression child1 = MultiplicationExplicit::Builder(Rational::Builder(3), Symbol::Builder('x')); + Expression child2 = MultiplicationExplicit::Builder(Rational::Builder(2), Symbol::Builder('x')); Expression e1 = Addition::Builder(child2.clone(), child1.clone()); Expression e2 = Addition::Builder(child1, child2); assert_multiplication_or_addition_is_ordered_as(e1, e2); @@ -128,16 +128,16 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) { // pi^b * pi^a -> pi^a * pi^b Expression child1 = Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Symbol::Builder('a')); Expression child2 = Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Symbol::Builder('b')); - Expression e1 = MultiplicationExplicite::Builder(child2.clone(), child1.clone()); - Expression e2 = MultiplicationExplicite::Builder(child1, child2); + Expression e1 = MultiplicationExplicit::Builder(child2.clone(), child1.clone()); + Expression e2 = MultiplicationExplicit::Builder(child1, child2); assert_multiplication_or_addition_is_ordered_as(e1, e2); } { // pi^3 * pi^2 -> pi^2 * pi^3 Expression child1 = Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Rational::Builder(2)); Expression child2 = Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Rational::Builder(3)); - Expression e1 = MultiplicationExplicite::Builder(child2.clone(), child1.clone()); - Expression e2 = MultiplicationExplicite::Builder(child1, child2); + Expression e1 = MultiplicationExplicit::Builder(child2.clone(), child1.clone()); + Expression e2 = MultiplicationExplicit::Builder(child1, child2); assert_multiplication_or_addition_is_ordered_as(e1, e2); } { @@ -146,8 +146,8 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) { Expression child2 = Rational::Builder(2); Expression childMatrix = Matrix::Builder(); static_cast(childMatrix).addChildAtIndexInPlace(Rational::Builder(3), 0, 0); - Expression e1 = MultiplicationExplicite::Builder(child2.clone(), childMatrix.clone(), child1.clone()); - Expression e2 = MultiplicationExplicite::Builder(child1.clone(), child2.clone(), childMatrix.clone()); + Expression e1 = MultiplicationExplicit::Builder(child2.clone(), childMatrix.clone(), child1.clone()); + Expression e2 = MultiplicationExplicit::Builder(child1.clone(), child2.clone(), childMatrix.clone()); assert_multiplication_or_addition_is_ordered_as(e1, e2); } @@ -173,8 +173,8 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) { childMatrix1.clone(), childMatrix2.clone() }; - Expression e1 = MultiplicationExplicite::Builder(children, numberOfChildren); - Expression e2 = MultiplicationExplicite::Builder(childrenSorted, numberOfChildren); + Expression e1 = MultiplicationExplicit::Builder(children, numberOfChildren); + Expression e2 = MultiplicationExplicit::Builder(childrenSorted, numberOfChildren); assert_multiplication_or_addition_is_ordered_as(e1, e2); } diff --git a/poincare/test/expression_properties.cpp b/poincare/test/expression_properties.cpp index 322986d8a..2fb20b418 100644 --- a/poincare/test/expression_properties.cpp +++ b/poincare/test/expression_properties.cpp @@ -108,17 +108,17 @@ QUIZ_CASE(poincare_properties_characteristic_range) { // cos(-x), radian assert_reduced_expression_has_characteristic_range(Cosine::Builder(Opposite::Builder(Symbol::Builder(UCodePointUnknownX))), 2.0f*M_PI, Preferences::AngleUnit::Radian); // sin(9x+10), degree - assert_reduced_expression_has_characteristic_range(Sine::Builder(Addition::Builder(MultiplicationExplicite::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))), 40.0f); + assert_reduced_expression_has_characteristic_range(Sine::Builder(Addition::Builder(MultiplicationExplicit::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))), 40.0f); // sin(9x+10)+cos(x/2), degree - assert_reduced_expression_has_characteristic_range(Addition::Builder(Sine::Builder(Addition::Builder(MultiplicationExplicite::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))),Cosine::Builder(Division::Builder(Symbol::Builder(UCodePointUnknownX),Rational::Builder(2)))), 720.0f); + assert_reduced_expression_has_characteristic_range(Addition::Builder(Sine::Builder(Addition::Builder(MultiplicationExplicit::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))),Cosine::Builder(Division::Builder(Symbol::Builder(UCodePointUnknownX),Rational::Builder(2)))), 720.0f); // sin(9x+10)+cos(x/2), radian - assert_reduced_expression_has_characteristic_range(Addition::Builder(Sine::Builder(Addition::Builder(MultiplicationExplicite::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))),Cosine::Builder(Division::Builder(Symbol::Builder(UCodePointUnknownX),Rational::Builder(2)))), 4.0f*M_PI, Preferences::AngleUnit::Radian); + assert_reduced_expression_has_characteristic_range(Addition::Builder(Sine::Builder(Addition::Builder(MultiplicationExplicit::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))),Cosine::Builder(Division::Builder(Symbol::Builder(UCodePointUnknownX),Rational::Builder(2)))), 4.0f*M_PI, Preferences::AngleUnit::Radian); // x, degree assert_reduced_expression_has_characteristic_range(Symbol::Builder(UCodePointUnknownX), NAN); // cos(3)+2, degree assert_reduced_expression_has_characteristic_range(Addition::Builder(Cosine::Builder(Rational::Builder(3)),Rational::Builder(2)), 0.0f); // log(cos(40x), degree - assert_reduced_expression_has_characteristic_range(CommonLogarithm::Builder(Cosine::Builder(MultiplicationExplicite::Builder(Rational::Builder(40),Symbol::Builder(UCodePointUnknownX)))), 9.0f); + assert_reduced_expression_has_characteristic_range(CommonLogarithm::Builder(Cosine::Builder(MultiplicationExplicit::Builder(Rational::Builder(40),Symbol::Builder(UCodePointUnknownX)))), 9.0f); // cos(cos(x)), degree assert_reduced_expression_has_characteristic_range(Cosine::Builder((Expression)Cosine::Builder(Symbol::Builder(UCodePointUnknownX))), 360.0f); // f(x) with f : x --> cos(x), degree diff --git a/poincare/test/layout_to_expression.cpp b/poincare/test/layout_to_expression.cpp index d15522f58..1792bac52 100644 --- a/poincare/test/layout_to_expression.cpp +++ b/poincare/test/layout_to_expression.cpp @@ -285,9 +285,9 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) { CodePointLayout::Builder('+'), CodePointLayout::Builder('5'))), CodePointLayout::Builder('3')); - e = MultiplicationImplicite::Builder( + e = MultiplicationImplicit::Builder( Rational::Builder(5), - MultiplicationImplicite::Builder( + MultiplicationImplicit::Builder( Division::Builder( Rational::Builder(6), Addition::Builder( @@ -348,6 +348,6 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) { VerticalOffsetLayout::Builder( CodePointLayout::Builder('3'), VerticalOffsetLayoutNode::Position::Superscript)); - e = MultiplicationImplicite::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE), Rational::Builder(3))); + e = MultiplicationImplicit::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE), Rational::Builder(3))); assert_parsed_layout_is(l, e); } diff --git a/poincare/test/parsing.cpp b/poincare/test/parsing.cpp index aad5b2da4..4376967a7 100644 --- a/poincare/test/parsing.cpp +++ b/poincare/test/parsing.cpp @@ -157,16 +157,16 @@ QUIZ_CASE(poincare_parsing_parse) { assert_parsed_expression_is("(1+2)", Parenthesis::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2)))); assert_parsed_expression_is("1+2+3", Addition::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); assert_parsed_expression_is("1+2+(3+4)", Addition::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2)),Parenthesis::Builder(Addition::Builder(Rational::Builder(3),Rational::Builder(4))))); - assert_parsed_expression_is("1×2", MultiplicationExplicite::Builder(Rational::Builder(1),Rational::Builder(2))); - assert_parsed_expression_is("1×2×3", MultiplicationExplicite::Builder(MultiplicationExplicite::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); - assert_parsed_expression_is("1+2×3", Addition::Builder(Rational::Builder(1), MultiplicationExplicite::Builder(Rational::Builder(2), Rational::Builder(3)))); + assert_parsed_expression_is("1×2", MultiplicationExplicit::Builder(Rational::Builder(1),Rational::Builder(2))); + assert_parsed_expression_is("1×2×3", MultiplicationExplicit::Builder(MultiplicationExplicit::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); + assert_parsed_expression_is("1+2×3", Addition::Builder(Rational::Builder(1), MultiplicationExplicit::Builder(Rational::Builder(2), Rational::Builder(3)))); assert_parsed_expression_is("1/2", Division::Builder(Rational::Builder(1),Rational::Builder(2))); assert_parsed_expression_is("(1/2)", Parenthesis::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)))); assert_parsed_expression_is("1/2/3", Division::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); - assert_parsed_expression_is("1/2×3", MultiplicationExplicite::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); - assert_parsed_expression_is("(1/2×3)", Parenthesis::Builder(MultiplicationExplicite::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)))); - assert_parsed_expression_is("1×2/3", MultiplicationExplicite::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3)))); - assert_parsed_expression_is("(1×2/3)", Parenthesis::Builder(MultiplicationExplicite::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3))))); + assert_parsed_expression_is("1/2×3", MultiplicationExplicit::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); + assert_parsed_expression_is("(1/2×3)", Parenthesis::Builder(MultiplicationExplicit::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)))); + assert_parsed_expression_is("1×2/3", MultiplicationExplicit::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3)))); + assert_parsed_expression_is("(1×2/3)", Parenthesis::Builder(MultiplicationExplicit::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3))))); assert_parsed_expression_is("(1/2/3)", Parenthesis::Builder(Division::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)))); assert_parsed_expression_is("1^2", Power::Builder(Rational::Builder(1),Rational::Builder(2))); assert_parsed_expression_is("1^2^3", Power::Builder(Rational::Builder(1),Power::Builder(Rational::Builder(2),Rational::Builder(3)))); @@ -182,24 +182,24 @@ QUIZ_CASE(poincare_parsing_parse) { assert_parsed_expression_is("1+-2", Addition::Builder(Rational::Builder(1),Opposite::Builder(Rational::Builder(2)))); assert_parsed_expression_is("--1", Opposite::Builder((Expression)Opposite::Builder(Rational::Builder(1)))); assert_parsed_expression_is("(1+2)-3", Subtraction::Builder(Parenthesis::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2))),Rational::Builder(3))); - assert_parsed_expression_is("(2×-3)", Parenthesis::Builder(MultiplicationExplicite::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))))); + assert_parsed_expression_is("(2×-3)", Parenthesis::Builder(MultiplicationExplicit::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))))); assert_parsed_expression_is("1^(2)-3", Subtraction::Builder(Power::Builder(Rational::Builder(1),Parenthesis::Builder(Rational::Builder(2))),Rational::Builder(3))); assert_parsed_expression_is("1^2-3", Subtraction::Builder(Power::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))); assert_parsed_expression_is("2^-3", Power::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3)))); assert_parsed_expression_is("2--2+-1", Addition::Builder(Subtraction::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(2))),Opposite::Builder(Rational::Builder(1)))); - assert_parsed_expression_is("2--2×-1", Subtraction::Builder(Rational::Builder(2),Opposite::Builder(MultiplicationExplicite::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(1)))))); + assert_parsed_expression_is("2--2×-1", Subtraction::Builder(Rational::Builder(2),Opposite::Builder(MultiplicationExplicit::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(1)))))); assert_parsed_expression_is("-1^2", Opposite::Builder(Power::Builder(Rational::Builder(1),Rational::Builder(2)))); - assert_parsed_expression_is("2ℯ^(3)", MultiplicationImplicite::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3))))); + assert_parsed_expression_is("2ℯ^(3)", MultiplicationImplicit::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3))))); assert_parsed_expression_is("2/-3/-4", Division::Builder(Division::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))),Opposite::Builder(Rational::Builder(4)))); - assert_parsed_expression_is("1×2-3×4", Subtraction::Builder(MultiplicationExplicite::Builder(Rational::Builder(1),Rational::Builder(2)),MultiplicationExplicite::Builder(Rational::Builder(3),Rational::Builder(4)))); - assert_parsed_expression_is("-1×2", Opposite::Builder(MultiplicationExplicite::Builder(Rational::Builder(1), Rational::Builder(2)))); + assert_parsed_expression_is("1×2-3×4", Subtraction::Builder(MultiplicationExplicit::Builder(Rational::Builder(1),Rational::Builder(2)),MultiplicationExplicit::Builder(Rational::Builder(3),Rational::Builder(4)))); + assert_parsed_expression_is("-1×2", Opposite::Builder(MultiplicationExplicit::Builder(Rational::Builder(1), Rational::Builder(2)))); assert_parsed_expression_is("1!", Factorial::Builder(Rational::Builder(1))); assert_parsed_expression_is("1+2!", Addition::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2)))); assert_parsed_expression_is("1!+2", Addition::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); assert_parsed_expression_is("1!+2!", Addition::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2)))); - assert_parsed_expression_is("1×2!", MultiplicationExplicite::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2)))); - assert_parsed_expression_is("1!×2", MultiplicationExplicite::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); - assert_parsed_expression_is("1!×2!", MultiplicationExplicite::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2)))); + assert_parsed_expression_is("1×2!", MultiplicationExplicit::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2)))); + assert_parsed_expression_is("1!×2", MultiplicationExplicit::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); + assert_parsed_expression_is("1!×2!", MultiplicationExplicit::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2)))); assert_parsed_expression_is("1-2!", Subtraction::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2)))); assert_parsed_expression_is("1!-2", Subtraction::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); assert_parsed_expression_is("1!-2!", Subtraction::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2)))); @@ -399,27 +399,27 @@ QUIZ_CASE(poincare_parsing_parse_store) { QUIZ_CASE(poincare_parsing_implicit_multiplication) { assert_text_not_parsable(".1.2"); assert_text_not_parsable("1 2"); - assert_parsed_expression_is("1x", MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1))); - assert_parsed_expression_is("1ans", MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("ans", 3))); + assert_parsed_expression_is("1x", MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1))); + assert_parsed_expression_is("1ans", MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("ans", 3))); assert_parsed_expression_is("x1", Symbol::Builder("x1", 2)); - assert_parsed_expression_is("1x+2", Addition::Builder(MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2))); - assert_parsed_expression_is("1π", MultiplicationImplicite::Builder(Rational::Builder(1),Constant::Builder(UCodePointGreekSmallLetterPi))); - assert_parsed_expression_is("1x-2", Subtraction::Builder(MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2))); - assert_parsed_expression_is("-1x", Opposite::Builder(MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); - assert_parsed_expression_is("2×1x", MultiplicationExplicite::Builder(Rational::Builder(2),MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); - assert_parsed_expression_is("2^1x", MultiplicationImplicite::Builder(Power::Builder(Rational::Builder(2),Rational::Builder(1)),Symbol::Builder("x", 1))); - assert_parsed_expression_is("1x^2", MultiplicationImplicite::Builder(Rational::Builder(1),Power::Builder(Symbol::Builder("x", 1),Rational::Builder(2)))); - assert_parsed_expression_is("2/1x", Division::Builder(Rational::Builder(2),MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); - assert_parsed_expression_is("1x/2", Division::Builder(MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2))); - assert_parsed_expression_is("(1)2", MultiplicationImplicite::Builder(Parenthesis::Builder(Rational::Builder(1)),Rational::Builder(2))); - assert_parsed_expression_is("1(2)", MultiplicationImplicite::Builder(Rational::Builder(1),Parenthesis::Builder(Rational::Builder(2)))); - assert_parsed_expression_is("sin(1)2", MultiplicationImplicite::Builder(Sine::Builder(Rational::Builder(1)),Rational::Builder(2))); - assert_parsed_expression_is("1cos(2)", MultiplicationImplicite::Builder(Rational::Builder(1),Cosine::Builder(Rational::Builder(2)))); - assert_parsed_expression_is("1!2", MultiplicationImplicite::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); - assert_parsed_expression_is("2ℯ^(3)", MultiplicationImplicite::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3))))); + assert_parsed_expression_is("1x+2", Addition::Builder(MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2))); + assert_parsed_expression_is("1π", MultiplicationImplicit::Builder(Rational::Builder(1),Constant::Builder(UCodePointGreekSmallLetterPi))); + assert_parsed_expression_is("1x-2", Subtraction::Builder(MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2))); + assert_parsed_expression_is("-1x", Opposite::Builder(MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); + assert_parsed_expression_is("2×1x", MultiplicationExplicit::Builder(Rational::Builder(2),MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); + assert_parsed_expression_is("2^1x", MultiplicationImplicit::Builder(Power::Builder(Rational::Builder(2),Rational::Builder(1)),Symbol::Builder("x", 1))); + assert_parsed_expression_is("1x^2", MultiplicationImplicit::Builder(Rational::Builder(1),Power::Builder(Symbol::Builder("x", 1),Rational::Builder(2)))); + assert_parsed_expression_is("2/1x", Division::Builder(Rational::Builder(2),MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)))); + assert_parsed_expression_is("1x/2", Division::Builder(MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2))); + assert_parsed_expression_is("(1)2", MultiplicationImplicit::Builder(Parenthesis::Builder(Rational::Builder(1)),Rational::Builder(2))); + assert_parsed_expression_is("1(2)", MultiplicationImplicit::Builder(Rational::Builder(1),Parenthesis::Builder(Rational::Builder(2)))); + assert_parsed_expression_is("sin(1)2", MultiplicationImplicit::Builder(Sine::Builder(Rational::Builder(1)),Rational::Builder(2))); + assert_parsed_expression_is("1cos(2)", MultiplicationImplicit::Builder(Rational::Builder(1),Cosine::Builder(Rational::Builder(2)))); + assert_parsed_expression_is("1!2", MultiplicationImplicit::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2))); + assert_parsed_expression_is("2ℯ^(3)", MultiplicationImplicit::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3))))); Expression m1[] = {Rational::Builder(1)}; Matrix M1 = BuildMatrix(1,1,m1); Expression m2[] = {Rational::Builder(2)}; Matrix M2 = BuildMatrix(1,1,m2); - assert_parsed_expression_is("[[1]][[2]]", MultiplicationImplicite::Builder(M1,M2)); + assert_parsed_expression_is("[[1]][[2]]", MultiplicationImplicit::Builder(M1,M2)); } QUIZ_CASE(poincare_parsing_adding_missing_parentheses) { @@ -427,9 +427,9 @@ QUIZ_CASE(poincare_parsing_adding_missing_parentheses) { assert_parsed_expression_with_user_parentheses_is("1--2", Subtraction::Builder(Rational::Builder(1),Parenthesis::Builder(Opposite::Builder(Rational::Builder(2))))); assert_parsed_expression_with_user_parentheses_is("1+conj(-2)", Addition::Builder(Rational::Builder(1),Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(2)))))); assert_parsed_expression_with_user_parentheses_is("1-conj(-2)", Subtraction::Builder(Rational::Builder(1),Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(2)))))); - assert_parsed_expression_with_user_parentheses_is("3conj(1+𝐢)", MultiplicationImplicite::Builder(Rational::Builder(3), Parenthesis::Builder(Conjugate::Builder(Addition::Builder(Rational::Builder(1), Constant::Builder(UCodePointMathematicalBoldSmallI)))))); - assert_parsed_expression_with_user_parentheses_is("2×-3", MultiplicationExplicite::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3))))); - assert_parsed_expression_with_user_parentheses_is("2×-3", MultiplicationExplicite::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3))))); + assert_parsed_expression_with_user_parentheses_is("3conj(1+𝐢)", MultiplicationImplicit::Builder(Rational::Builder(3), Parenthesis::Builder(Conjugate::Builder(Addition::Builder(Rational::Builder(1), Constant::Builder(UCodePointMathematicalBoldSmallI)))))); + assert_parsed_expression_with_user_parentheses_is("2×-3", MultiplicationExplicit::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3))))); + assert_parsed_expression_with_user_parentheses_is("2×-3", MultiplicationExplicit::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3))))); assert_parsed_expression_with_user_parentheses_is("--2", Opposite::Builder(Parenthesis::Builder(Opposite::Builder(Rational::Builder(2))))); assert_parsed_expression_with_user_parentheses_is("\u00122/3\u0013^2", Power::Builder(Parenthesis::Builder(Division::Builder(Rational::Builder(2), Rational::Builder(3))), Rational::Builder(2))); }