diff --git a/apps/calculation/calculation.cpp b/apps/calculation/calculation.cpp index b56bdba23..b4a98e653 100644 --- a/apps/calculation/calculation.cpp +++ b/apps/calculation/calculation.cpp @@ -106,7 +106,7 @@ Expression * Calculation::input() { LayoutRef Calculation::createInputLayout() { if (input() != nullptr) { - return input()->createLayout(PrintFloat::Mode::Decimal, PrintFloat::k_numberOfStoredSignificantDigits); + return input()->createLayout(Preferences::PrintFloatMode::Decimal, PrintFloat::k_numberOfStoredSignificantDigits); } return LayoutRef(nullptr); } diff --git a/apps/graph/graph/graph_controller.cpp b/apps/graph/graph/graph_controller.cpp index 38ca4baad..010b17347 100644 --- a/apps/graph/graph/graph_controller.cpp +++ b/apps/graph/graph/graph_controller.cpp @@ -6,7 +6,7 @@ using namespace Poincare; namespace Graph { -GraphController::GraphController(Responder * parentResponder, CartesianFunctionStore * functionStore, Shared::InteractiveCurveViewRange * curveViewRange, CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Expression::AngleUnit * angleUnitVersion, ButtonRowController * header) : +GraphController::GraphController(Responder * parentResponder, CartesianFunctionStore * functionStore, Shared::InteractiveCurveViewRange * curveViewRange, CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Preferences::AngleUnit * angleUnitVersion, ButtonRowController * header) : FunctionGraphController(parentResponder, header, curveViewRange, &m_view, cursor, indexFunctionSelectedByCursor, modelVersion, rangeVersion, angleUnitVersion), m_bannerView(), m_view(functionStore, curveViewRange, m_cursor, &m_bannerView, &m_cursorView), diff --git a/apps/graph/graph/graph_controller.h b/apps/graph/graph/graph_controller.h index 47721bb09..cbffa4d08 100644 --- a/apps/graph/graph/graph_controller.h +++ b/apps/graph/graph/graph_controller.h @@ -15,7 +15,7 @@ namespace Graph { class GraphController : public Shared::FunctionGraphController, public GraphControllerHelper { public: - GraphController(Responder * parentResponder, CartesianFunctionStore * functionStore, Shared::InteractiveCurveViewRange * curveViewRange, Shared::CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Poincare::Expression::AngleUnit * angleUnitVersion, ButtonRowController * header); + GraphController(Responder * parentResponder, CartesianFunctionStore * functionStore, Shared::InteractiveCurveViewRange * curveViewRange, Shared::CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Poincare::Preferences::AngleUnit * angleUnitVersion, ButtonRowController * header); I18n::Message emptyMessage() override; void viewWillAppear() override; bool displayDerivativeInBanner() const; diff --git a/apps/hardware_test/battery_test_controller.cpp b/apps/hardware_test/battery_test_controller.cpp index c086d26af..71da3a269 100644 --- a/apps/hardware_test/battery_test_controller.cpp +++ b/apps/hardware_test/battery_test_controller.cpp @@ -44,7 +44,7 @@ void BatteryTestController::updateBatteryState(float batteryLevel, bool batteryC const char * legend = "Battery level: "; int legendLength = strlen(legend); strlcpy(bufferLevel, legend, legendLength+1); - PrintFloat::convertFloatToText(batteryLevel, bufferLevel+legendLength, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(batteryLevel, bufferLevel+legendLength, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); m_view.batteryLevelTextView()->setText(bufferLevel); char bufferCharging[ContentView::k_maxNumberOfCharacters + PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits)]; diff --git a/apps/probability/calculation_controller.cpp b/apps/probability/calculation_controller.cpp index 51dbac287..130f0c3d5 100644 --- a/apps/probability/calculation_controller.cpp +++ b/apps/probability/calculation_controller.cpp @@ -182,7 +182,7 @@ void CalculationController::willDisplayCellAtLocation(HighlightCell * cell, int return; } char buffer[PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits)]; - PrintFloat::convertFloatToText(m_calculation->parameterAtIndex(i-1), buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(m_calculation->parameterAtIndex(i-1), buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); field->setText(buffer); } } @@ -277,7 +277,7 @@ void CalculationController::updateTitle() { strlcpy(m_titleBuffer+currentChar, " = ", 4); currentChar += 3; char buffer[PrintFloat::bufferSizeForFloatsWithPrecision(Constant::ShortNumberOfSignificantDigits)]; - PrintFloat::convertFloatToText(m_law->parameterValueAtIndex(index), buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::ShortNumberOfSignificantDigits), Constant::ShortNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(m_law->parameterValueAtIndex(index), buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::ShortNumberOfSignificantDigits), Constant::ShortNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); strlcpy(m_titleBuffer+currentChar, buffer, strlen(buffer)+1); currentChar += strlen(buffer); m_titleBuffer[currentChar++] = ' '; diff --git a/apps/regression/graph_controller.cpp b/apps/regression/graph_controller.cpp index 650f67e99..bb444af38 100644 --- a/apps/regression/graph_controller.cpp +++ b/apps/regression/graph_controller.cpp @@ -104,7 +104,7 @@ void GraphController::reloadBannerView() { strlcpy(buffer+numberOfChar, legend, legendLength+1); numberOfChar += legendLength; } else { - numberOfChar += PrintFloat::convertFloatToText(std::round((float)*m_selectedDotIndex+1.0f), buffer+numberOfChar, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::ShortNumberOfSignificantDigits), Constant::ShortNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + numberOfChar += PrintFloat::convertFloatToText(std::round((float)*m_selectedDotIndex+1.0f), buffer+numberOfChar, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::ShortNumberOfSignificantDigits), Constant::ShortNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); } legend = ") "; legendLength = strlen(legend); diff --git a/apps/regression/model/trigonometric_model.cpp b/apps/regression/model/trigonometric_model.cpp index e0c726c86..50c14e6b6 100644 --- a/apps/regression/model/trigonometric_model.cpp +++ b/apps/regression/model/trigonometric_model.cpp @@ -61,7 +61,7 @@ double TrigonometricModel::evaluate(double * modelCoefficients, double x) const double b = modelCoefficients[1]; double c = modelCoefficients[2]; double d = modelCoefficients[3]; - double radianX = Poincare::Preferences::sharedPreferences()->angleUnit() == Poincare::Expression::AngleUnit::Radian ? x : x * M_PI/180.0; + double radianX = Poincare::Preferences::sharedPreferences()->angleUnit() == Poincare::Preferences::AngleUnit::Radian ? x : x * M_PI/180.0; return a*sin(b*radianX+c)+d; } @@ -69,7 +69,7 @@ double TrigonometricModel::partialDerivate(double * modelCoefficients, int deriv double a = modelCoefficients[0]; double b = modelCoefficients[1]; double c = modelCoefficients[2]; - double radianX = Poincare::Preferences::sharedPreferences()->angleUnit() == Poincare::Expression::AngleUnit::Radian ? x : x * M_PI/180.0; + double radianX = Poincare::Preferences::sharedPreferences()->angleUnit() == Poincare::Preferences::AngleUnit::Radian ? x : x * M_PI/180.0; if (derivateCoefficientIndex == 0) { // Derivate: sin(b*x+c) return sin(b*radianX+c); diff --git a/apps/regression/store.cpp b/apps/regression/store.cpp index 1751ead7a..ea23318e7 100644 --- a/apps/regression/store.cpp +++ b/apps/regression/store.cpp @@ -29,7 +29,7 @@ Store::Store() : InteractiveCurveViewRange(nullptr), DoublePairStore(), m_seriesChecksum{0, 0, 0}, - m_angleUnit(Poincare::Expression::AngleUnit::Degree) + m_angleUnit(Poincare::Preferences::AngleUnit::Degree) { for (int i = 0; i < k_numberOfSeries; i++) { m_regressionTypes[i] = Model::Type::Linear; @@ -225,7 +225,7 @@ double * Store::coefficientsForSeries(int series, Poincare::Context * globalCont assert(series >= 0 && series <= k_numberOfSeries); assert(!seriesIsEmpty(series)); uint32_t storeChecksumSeries = storeChecksumForSeries(series); - Poincare::Expression::AngleUnit currentAngleUnit = Poincare::Preferences::sharedPreferences()->angleUnit(); + Poincare::Preferences::AngleUnit currentAngleUnit = Poincare::Preferences::sharedPreferences()->angleUnit(); if (m_angleUnit != currentAngleUnit) { m_angleUnit = currentAngleUnit; for (int i = 0; i < k_numberOfSeries; i++) { diff --git a/apps/regression/store.h b/apps/regression/store.h index a3c7bc447..6b52dede9 100644 --- a/apps/regression/store.h +++ b/apps/regression/store.h @@ -72,7 +72,7 @@ private: Model * m_regressionModels[Model::k_numberOfModels]; double m_regressionCoefficients[k_numberOfSeries][Model::k_maxNumberOfCoefficients]; bool m_regressionChanged[k_numberOfSeries]; - Poincare::Expression::AngleUnit m_angleUnit; + Poincare::Preferences::AngleUnit m_angleUnit; }; typedef double (Store::*ArgCalculPointer)(int, int) const; diff --git a/apps/sequence/graph/curve_view_range.cpp b/apps/sequence/graph/curve_view_range.cpp index 9aeb02ca5..b1f4b001f 100644 --- a/apps/sequence/graph/curve_view_range.cpp +++ b/apps/sequence/graph/curve_view_range.cpp @@ -63,7 +63,7 @@ void CurveViewRange::normalize() { void CurveViewRange::setTrigonometric() { m_xMin = -k_displayLeftMarginRatio*21.0f; m_xMax = 21.0f; - if (Preferences::sharedPreferences()->angleUnit() == Expression::AngleUnit::Degree) { + if (Preferences::sharedPreferences()->angleUnit() == Preferences::AngleUnit::Degree) { m_xMin = -k_displayLeftMarginRatio*1200; m_xMax = 1200; } diff --git a/apps/sequence/graph/graph_controller.cpp b/apps/sequence/graph/graph_controller.cpp index d0ba85018..595c3fc0d 100644 --- a/apps/sequence/graph/graph_controller.cpp +++ b/apps/sequence/graph/graph_controller.cpp @@ -6,7 +6,7 @@ using namespace Poincare; namespace Sequence { -GraphController::GraphController(Responder * parentResponder, SequenceStore * sequenceStore, CurveViewRange * graphRange, CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Expression::AngleUnit * angleUnitVersion, ButtonRowController * header) : +GraphController::GraphController(Responder * parentResponder, SequenceStore * sequenceStore, CurveViewRange * graphRange, CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Preferences::AngleUnit * angleUnitVersion, ButtonRowController * header) : FunctionGraphController(parentResponder, header, graphRange, &m_view, cursor, indexFunctionSelectedByCursor, modelVersion, rangeVersion, angleUnitVersion), m_bannerView(), m_view(sequenceStore, graphRange, m_cursor, &m_bannerView, &m_cursorView), diff --git a/apps/sequence/graph/graph_controller.h b/apps/sequence/graph/graph_controller.h index 4ce0dca25..18de515b6 100644 --- a/apps/sequence/graph/graph_controller.h +++ b/apps/sequence/graph/graph_controller.h @@ -14,7 +14,7 @@ namespace Sequence { class GraphController : public Shared::FunctionGraphController { public: - GraphController(Responder * parentResponder, SequenceStore * sequenceStore, CurveViewRange * graphRange, Shared::CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Poincare::Expression::AngleUnit * angleUnitVersion, ButtonRowController * header); + GraphController(Responder * parentResponder, SequenceStore * sequenceStore, CurveViewRange * graphRange, Shared::CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Poincare::Preferences::AngleUnit * angleUnitVersion, ButtonRowController * header); I18n::Message emptyMessage() override; TermSumController * termSumController(); private: diff --git a/apps/settings/main_controller.cpp b/apps/settings/main_controller.cpp index d036c8787..fd0e05178 100644 --- a/apps/settings/main_controller.cpp +++ b/apps/settings/main_controller.cpp @@ -177,7 +177,7 @@ void MainController::willDisplayCellForIndex(HighlightCell * cell, int index) { delete m_complexFormatLayout; m_complexFormatLayout = nullptr; } - if (Preferences::sharedPreferences()->complexFormat() == Expression::ComplexFormat::Cartesian) { + if (Preferences::sharedPreferences()->complexFormat() == Preferences::ComplexFormat::Cartesian) { m_complexFormatLayout = Helpers::CartesianComplexFormat(KDText::FontSize::Small); } else { m_complexFormatLayout = Helpers::PolarComplexFormat(KDText::FontSize::Small); diff --git a/apps/settings/sub_controller.cpp b/apps/settings/sub_controller.cpp index 30f7aa1de..18c8b577c 100644 --- a/apps/settings/sub_controller.cpp +++ b/apps/settings/sub_controller.cpp @@ -243,16 +243,16 @@ StackViewController * SubController::stackController() const { void SubController::setPreferenceWithValueIndex(I18n::Message message, int valueIndex) { if (message == I18n::Message::AngleUnit) { - Preferences::sharedPreferences()->setAngleUnit((Expression::AngleUnit)valueIndex); + Preferences::sharedPreferences()->setAngleUnit((Preferences::AngleUnit)valueIndex); } if (message == I18n::Message::DisplayMode) { - Preferences::sharedPreferences()->setDisplayMode((PrintFloat::Mode)valueIndex); + Preferences::sharedPreferences()->setDisplayMode((Preferences::PrintFloatMode)valueIndex); } if (message == I18n::Message::EditionMode) { Preferences::sharedPreferences()->setEditionMode((Preferences::EditionMode)valueIndex); } if (message == I18n::Message::ComplexFormat) { - Preferences::sharedPreferences()->setComplexFormat((Expression::ComplexFormat)valueIndex); + Preferences::sharedPreferences()->setComplexFormat((Preferences::ComplexFormat)valueIndex); } } diff --git a/apps/shared/curve_view.cpp b/apps/shared/curve_view.cpp index df2bf5868..c6c04087c 100644 --- a/apps/shared/curve_view.cpp +++ b/apps/shared/curve_view.cpp @@ -138,7 +138,7 @@ void CurveView::computeLabels(Axis axis) { } PrintFloat::convertFloatToText(labelValue, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::ShortNumberOfSignificantDigits), - Constant::ShortNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + Constant::ShortNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); //TODO: check for size of label? strlcpy(label(axis, index), buffer, strlen(buffer)+1); } diff --git a/apps/shared/editable_cell_table_view_controller.cpp b/apps/shared/editable_cell_table_view_controller.cpp index bd9323d19..e6a4a3883 100644 --- a/apps/shared/editable_cell_table_view_controller.cpp +++ b/apps/shared/editable_cell_table_view_controller.cpp @@ -63,7 +63,7 @@ KDCoordinate EditableCellTableViewController::rowHeight(int j) { return k_cellHeight; } -void EditableCellTableViewController::willDisplayCellAtLocationWithDisplayMode(HighlightCell * cell, int i, int j, PrintFloat::Mode floatDisplayMode) { +void EditableCellTableViewController::willDisplayCellAtLocationWithDisplayMode(HighlightCell * cell, int i, int j, Preferences::PrintFloatMode floatDisplayMode) { EvenOddCell * myCell = (EvenOddCell *)cell; /* We set the cell even or odd state only if the cell is not being edited. * Otherwise, the cell background is white whichever it is an odd or even cell diff --git a/apps/shared/editable_cell_table_view_controller.h b/apps/shared/editable_cell_table_view_controller.h index 80c6660a9..bf7d4f5ac 100644 --- a/apps/shared/editable_cell_table_view_controller.h +++ b/apps/shared/editable_cell_table_view_controller.h @@ -16,7 +16,7 @@ public: bool textFieldDidFinishEditing(TextField * textField, const char * text, Ion::Events::Event event) override; int numberOfRows() override; - void willDisplayCellAtLocationWithDisplayMode(HighlightCell * cell, int i, int j, Poincare::PrintFloat::Mode mode); + void willDisplayCellAtLocationWithDisplayMode(HighlightCell * cell, int i, int j, Poincare::Preferences::PrintFloatMode mode); KDCoordinate rowHeight(int j) override; void viewWillAppear() override; void didBecomeFirstResponder() override; diff --git a/apps/shared/float_parameter_controller.cpp b/apps/shared/float_parameter_controller.cpp index 04e26a0f5..a0717a326 100644 --- a/apps/shared/float_parameter_controller.cpp +++ b/apps/shared/float_parameter_controller.cpp @@ -107,7 +107,7 @@ void FloatParameterController::willDisplayCellForIndex(HighlightCell * cell, int return; } char buffer[PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits)]; - PrintFloat::convertFloatToText(parameterAtIndex(index), buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(parameterAtIndex(index), buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); myCell->setAccessoryText(buffer); } diff --git a/apps/shared/function_app.cpp b/apps/shared/function_app.cpp index 0d82d3dcb..0dfc4ec3c 100644 --- a/apps/shared/function_app.cpp +++ b/apps/shared/function_app.cpp @@ -11,7 +11,7 @@ FunctionApp::Snapshot::Snapshot() : m_indexFunctionSelectedByCursor(0), m_modelVersion(0), m_rangeVersion(0), - m_angleUnitVersion(Expression::AngleUnit::Radian) + m_angleUnitVersion(Preferences::AngleUnit::Radian) { m_interval.setStart(0); m_interval.setEnd(10); @@ -30,7 +30,7 @@ uint32_t * FunctionApp::Snapshot::rangeVersion() { return &m_rangeVersion; } -Expression::AngleUnit * FunctionApp::Snapshot::angleUnitVersion() { +Preferences::AngleUnit * FunctionApp::Snapshot::angleUnitVersion() { return &m_angleUnitVersion; } diff --git a/apps/shared/function_app.h b/apps/shared/function_app.h index 8fae050f1..14f2361b4 100644 --- a/apps/shared/function_app.h +++ b/apps/shared/function_app.h @@ -18,7 +18,7 @@ public: CurveViewCursor * cursor(); uint32_t * modelVersion(); uint32_t * rangeVersion(); - Poincare::Expression::AngleUnit * angleUnitVersion(); + Poincare::Preferences::AngleUnit * angleUnitVersion(); Interval * interval(); int * indexFunctionSelectedByCursor(); void reset() override; @@ -29,7 +29,7 @@ public: int m_indexFunctionSelectedByCursor; uint32_t m_modelVersion; uint32_t m_rangeVersion; - Poincare::Expression::AngleUnit m_angleUnitVersion; + Poincare::Preferences::AngleUnit m_angleUnitVersion; }; virtual ~FunctionApp() = default; virtual InputViewController * inputViewController() = 0; diff --git a/apps/shared/function_graph_controller.cpp b/apps/shared/function_graph_controller.cpp index 0f7b4fca9..e2bf8380e 100644 --- a/apps/shared/function_graph_controller.cpp +++ b/apps/shared/function_graph_controller.cpp @@ -8,7 +8,7 @@ using namespace Poincare; namespace Shared { -FunctionGraphController::FunctionGraphController(Responder * parentResponder, ButtonRowController * header, InteractiveCurveViewRange * interactiveRange, CurveView * curveView, CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Expression::AngleUnit * angleUnitVersion) : +FunctionGraphController::FunctionGraphController(Responder * parentResponder, ButtonRowController * header, InteractiveCurveViewRange * interactiveRange, CurveView * curveView, CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Preferences::AngleUnit * angleUnitVersion) : InteractiveCurveViewController(parentResponder, header, interactiveRange, curveView, cursor, modelVersion, rangeVersion), m_initialisationParameterController(this, interactiveRange), m_angleUnitVersion(angleUnitVersion), @@ -36,7 +36,7 @@ void FunctionGraphController::viewWillAppear() { TextFieldDelegateApp * myApp = (TextFieldDelegateApp *)app(); functionGraphView()->setContext(myApp->localContext()); } - Expression::AngleUnit newAngleUnitVersion = Preferences::sharedPreferences()->angleUnit(); + Preferences::AngleUnit newAngleUnitVersion = Preferences::sharedPreferences()->angleUnit(); if (*m_angleUnitVersion != newAngleUnitVersion) { *m_angleUnitVersion = newAngleUnitVersion; initCursorParameters(); diff --git a/apps/shared/function_graph_controller.h b/apps/shared/function_graph_controller.h index db7349e9a..e7dbf91ff 100644 --- a/apps/shared/function_graph_controller.h +++ b/apps/shared/function_graph_controller.h @@ -13,7 +13,7 @@ namespace Shared { class FunctionGraphController : public InteractiveCurveViewController, public FunctionBannerDelegate { public: - FunctionGraphController(Responder * parentResponder, ButtonRowController * header, InteractiveCurveViewRange * interactiveRange, CurveView * curveView, CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Poincare::Expression::AngleUnit * angleUnitVersion); + FunctionGraphController(Responder * parentResponder, ButtonRowController * header, InteractiveCurveViewRange * interactiveRange, CurveView * curveView, CurveViewCursor * cursor, int * indexFunctionSelectedByCursor, uint32_t * modelVersion, uint32_t * rangeVersion, Poincare::Preferences::AngleUnit * angleUnitVersion); bool isEmpty() const override; ViewController * initialisationParameterController() override; void viewWillAppear() override; @@ -52,7 +52,7 @@ private: virtual FunctionStore * functionStore() const = 0; virtual FunctionCurveParameterController * curveParameterController() = 0; InitialisationParameterController m_initialisationParameterController; - Poincare::Expression::AngleUnit * m_angleUnitVersion; + Poincare::Preferences::AngleUnit * m_angleUnitVersion; int * m_indexFunctionSelectedByCursor; }; diff --git a/apps/shared/interactive_curve_view_range.cpp b/apps/shared/interactive_curve_view_range.cpp index 17a504e5c..b3467d0af 100644 --- a/apps/shared/interactive_curve_view_range.cpp +++ b/apps/shared/interactive_curve_view_range.cpp @@ -159,7 +159,7 @@ void InteractiveCurveViewRange::normalize() { void InteractiveCurveViewRange::setTrigonometric() { m_xMax = 10.5f; MemoizedCurveViewRange::setXMin(-10.5f); - if (Preferences::sharedPreferences()->angleUnit() == Expression::AngleUnit::Degree) { + if (Preferences::sharedPreferences()->angleUnit() == Preferences::AngleUnit::Degree) { m_xMax = 600.0f; MemoizedCurveViewRange::setXMin(-600.0f); } diff --git a/apps/shared/store_controller.cpp b/apps/shared/store_controller.cpp index 0480d6c44..8439d87b0 100644 --- a/apps/shared/store_controller.cpp +++ b/apps/shared/store_controller.cpp @@ -175,7 +175,7 @@ void StoreController::willDisplayCellAtLocation(HighlightCell * cell, int i, int if (cellAtLocationIsEditable(i, j)) { static_cast(cell)->setHide(false); } - willDisplayCellAtLocationWithDisplayMode(cell, i, j, PrintFloat::Mode::Decimal); + willDisplayCellAtLocationWithDisplayMode(cell, i, j, Preferences::PrintFloatMode::Decimal); } const char * StoreController::title() { diff --git a/apps/shared/sum_graph_controller.cpp b/apps/shared/sum_graph_controller.cpp index 741e80229..86539897f 100644 --- a/apps/shared/sum_graph_controller.cpp +++ b/apps/shared/sum_graph_controller.cpp @@ -157,7 +157,7 @@ bool SumGraphController::textFieldDidAbortEditing(TextField * textField) { default: assert(false); } - PrintFloat::convertFloatToText(parameter, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::MediumNumberOfSignificantDigits), Constant::MediumNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(parameter, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::MediumNumberOfSignificantDigits), Constant::MediumNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); textField->setText(buffer); return true; } @@ -225,7 +225,7 @@ void SumGraphController::LegendView::setLegendMessage(I18n::Message message, Ste void SumGraphController::LegendView::setEditableZone(double d) { char buffer[PrintFloat::bufferSizeForFloatsWithPrecision(Constant::MediumNumberOfSignificantDigits)]; - PrintFloat::convertFloatToText(d, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::MediumNumberOfSignificantDigits), Constant::MediumNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(d, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::MediumNumberOfSignificantDigits), Constant::MediumNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); m_editableZone.setText(buffer); } @@ -236,7 +236,7 @@ void SumGraphController::LegendView::setSumSymbol(Step step, double start, doubl m_sumLayoutRef = LayoutEngine::createStringLayout(sigma, sizeof(sigma)); } else if (step == Step::SecondParameter) { char buffer[PrintFloat::bufferSizeForFloatsWithPrecision(Constant::MediumNumberOfSignificantDigits)]; - PrintFloat::convertFloatToText(start, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::MediumNumberOfSignificantDigits), Constant::MediumNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(start, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::MediumNumberOfSignificantDigits), Constant::MediumNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); m_sumLayoutRef = LayoutEngine::createStringLayout(sigma, sizeof(sigma));/* TODO new CondensedSumLayout( LayoutEngine::createStringLayout(sigma, sizeof(sigma)), LayoutEngine::createStringLayout(buffer, strlen(buffer), KDText::FontSize::Small), @@ -246,9 +246,9 @@ void SumGraphController::LegendView::setSumSymbol(Step step, double start, doubl m_sumLayoutRef = LayoutEngine::createStringLayout(sigma, sizeof(sigma)); /* TODO char buffer[2+PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits)]; - PrintFloat::convertFloatToText(start, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(start, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); ExpressionLayout * start = LayoutEngine::createStringLayout(buffer, strlen(buffer), KDText::FontSize::Small); - PrintFloat::convertFloatToText(end, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(end, buffer, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits, Preferences::PrintFloatMode::Decimal); ExpressionLayout * end = LayoutEngine::createStringLayout(buffer, strlen(buffer), KDText::FontSize::Small); m_sumLayoutRef = new CondensedSumLayout( LayoutEngine::createStringLayout(sigma, sizeof(sigma)), diff --git a/apps/solver/equation_models_parameter_controller.cpp b/apps/solver/equation_models_parameter_controller.cpp index 045836465..347457e84 100644 --- a/apps/solver/equation_models_parameter_controller.cpp +++ b/apps/solver/equation_models_parameter_controller.cpp @@ -23,7 +23,7 @@ EquationModelsParameterController::EquationModelsParameterController(Responder * m_selectableTableView.setShowsIndicators(false); for (int i = 0; i < k_numberOfExpressionCells; i++) { Poincare::Expression * e = Expression::parse(k_models[i+1]); - m_expressionLayouts[i] = e->createLayout(Poincare::PrintFloat::Mode::Decimal, Constant::ShortNumberOfSignificantDigits); + m_expressionLayouts[i] = e->createLayout(Poincare::Preferences::PrintFloatMode::Decimal, Constant::ShortNumberOfSignificantDigits); delete e; m_modelCells[i].setExpressionLayout(m_expressionLayouts[i]); } diff --git a/apps/solver/equation_store.cpp b/apps/solver/equation_store.cpp index bf6646cfa..c42b2e7ec 100644 --- a/apps/solver/equation_store.cpp +++ b/apps/solver/equation_store.cpp @@ -181,7 +181,7 @@ EquationStore::Error EquationStore::exactSolve(Poincare::Context * context) { } EquationStore::Error EquationStore::resolveLinearSystem(Expression * exactSolutions[k_maxNumberOfExactSolutions], Expression * coefficients[k_maxNumberOfEquations][Expression::k_maxNumberOfVariables], Expression * constants[k_maxNumberOfEquations], Context * context) { - Expression::AngleUnit angleUnit = Preferences::sharedPreferences()->angleUnit(); + Preferences::AngleUnit angleUnit = Preferences::sharedPreferences()->angleUnit(); int n = strlen(m_variables); // n unknown variables int m = numberOfDefinedModels(); // m equations /* Create the matrix (A | b) for the equation Ax=b */ diff --git a/apps/title_bar_view.cpp b/apps/title_bar_view.cpp index 62c4815b4..460e1940f 100644 --- a/apps/title_bar_view.cpp +++ b/apps/title_bar_view.cpp @@ -84,11 +84,11 @@ void TitleBarView::layoutSubviews() { void TitleBarView::refreshPreferences() { char buffer[13]; int numberOfChar = 0; - if (Preferences::sharedPreferences()->displayMode() == PrintFloat::Mode::Scientific) { + if (Preferences::sharedPreferences()->displayMode() == Preferences::PrintFloatMode::Scientific) { strlcpy(buffer, I18n::translate(I18n::Message::Sci), strlen(I18n::translate(I18n::Message::Sci))+1); numberOfChar += strlen(I18n::translate(I18n::Message::Sci)); } - if (Preferences::sharedPreferences()->angleUnit() == Expression::AngleUnit::Radian) { + if (Preferences::sharedPreferences()->angleUnit() == Preferences::AngleUnit::Radian) { strlcpy(buffer+numberOfChar, I18n::translate(I18n::Message::Rad), strlen(I18n::translate(I18n::Message::Rad))+1); numberOfChar += strlen(I18n::translate(I18n::Message::Rad)); } else { diff --git a/apps/variable_box_controller.cpp b/apps/variable_box_controller.cpp index a3df5daf9..4c34e1752 100644 --- a/apps/variable_box_controller.cpp +++ b/apps/variable_box_controller.cpp @@ -154,9 +154,9 @@ void VariableBoxController::ContentViewController::willDisplayCellForIndex(Highl const Matrix * matrixEvaluation = static_cast(evaluation); myCell->setLayoutRef(layoutR); char buffer[2*PrintFloat::bufferSizeForFloatsWithPrecision(2)+1]; - int numberOfChars = PrintFloat::convertFloatToText(matrixEvaluation->numberOfRows(), buffer, PrintFloat::bufferSizeForFloatsWithPrecision(2), 2, PrintFloat::Mode::Decimal); + int numberOfChars = PrintFloat::convertFloatToText(matrixEvaluation->numberOfRows(), buffer, PrintFloat::bufferSizeForFloatsWithPrecision(2), 2, Preferences::PrintFloatMode::Decimal); buffer[numberOfChars++] = 'x'; - PrintFloat::convertFloatToText(matrixEvaluation->numberOfColumns(), buffer+numberOfChars, PrintFloat::bufferSizeForFloatsWithPrecision(2), 2, PrintFloat::Mode::Decimal); + PrintFloat::convertFloatToText(matrixEvaluation->numberOfColumns(), buffer+numberOfChars, PrintFloat::bufferSizeForFloatsWithPrecision(2), 2, Preferences::PrintFloatMode::Decimal); myCell->setSubtitle(buffer); } else { myCell->setLayoutRef(LayoutRef(nullptr)); diff --git a/ion/src/device/bench/command/adc.cpp b/ion/src/device/bench/command/adc.cpp index 1e79afe5f..6bf3d4e60 100644 --- a/ion/src/device/bench/command/adc.cpp +++ b/ion/src/device/bench/command/adc.cpp @@ -17,7 +17,7 @@ void ADC(const char * input) { constexpr int precision = 8; constexpr int bufferSize = Poincare::PrintFloat::bufferSizeForFloatsWithPrecision(precision); char responseBuffer[bufferSize+4] = {'A', 'D', 'C', '='}; // ADC= - Poincare::PrintFloat::convertFloatToText(result, responseBuffer+4, bufferSize, precision, Poincare::PrintFloat::Mode::Decimal); + Poincare::PrintFloat::convertFloatToText(result, responseBuffer+4, bufferSize, precision, Poincare::Preferences::PrintFloatMode::Decimal); reply(responseBuffer); } diff --git a/poincare/include/poincare/absolute_value.h b/poincare/include/poincare/absolute_value.h index 7c612d7e8..3ece7c591 100644 --- a/poincare/include/poincare/absolute_value.h +++ b/poincare/include/poincare/absolute_value.h @@ -14,20 +14,20 @@ public: Expression * clone() const override; Sign sign() const override { return Sign::Positive; } private: - Expression * setSign(Sign s, Context & context, AngleUnit angleUnit) override; + Expression * setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) override; /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "abs"); } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/absolute_value_layout_node.h b/poincare/include/poincare/absolute_value_layout_node.h index bbc9907a2..d7b109458 100644 --- a/poincare/include/poincare/absolute_value_layout_node.h +++ b/poincare/include/poincare/absolute_value_layout_node.h @@ -8,7 +8,7 @@ namespace Poincare { class AbsoluteValueLayoutNode : public BracketPairLayoutNode { public: using BracketPairLayoutNode::BracketPairLayoutNode; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixSerializableRefTextInBuffer(SerializableRef(const_cast(this)), buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "abs"); } // TreeNode diff --git a/poincare/include/poincare/addition.h b/poincare/include/poincare/addition.h index 7947b42b3..da62f5301 100644 --- a/poincare/include/poincare/addition.h +++ b/poincare/include/poincare/addition.h @@ -32,29 +32,29 @@ public: private: /* Layout */ bool needParenthesisWithParent(const Expression * e) const override; - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createInfixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writeInfixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } static const char * name() { return "+"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; - Expression * shallowBeautify(Context & context, AngleUnit angleUnit) override; - Expression * factorizeOnCommonDenominator(Context & context, AngleUnit angleUnit); - void factorizeOperands(Expression * e1, Expression * e2, Context & context, AngleUnit angleUnit); + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; + Expression * shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) override; + Expression * factorizeOnCommonDenominator(Context & context, Preferences::AngleUnit angleUnit); + void factorizeOperands(Expression * e1, Expression * e2, Context & context, Preferences::AngleUnit angleUnit); static const Rational RationalFactor(Expression * e); static bool TermsHaveIdenticalNonRationalFactors(const Expression * e1, const Expression * e2); /* Evaluation */ template static MatrixComplex computeOnMatrixAndComplex(const MatrixComplex m, const std::complex c) { return ApproximationEngine::elementWiseOnMatrixComplexAndComplex(m, c, compute); } - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } }; diff --git a/poincare/include/poincare/allocation_failed_layout_node.h b/poincare/include/poincare/allocation_failed_layout_node.h index 1f4253bfc..c8501d350 100644 --- a/poincare/include/poincare/allocation_failed_layout_node.h +++ b/poincare/include/poincare/allocation_failed_layout_node.h @@ -10,7 +10,7 @@ namespace Poincare { class AllocationFailedLayoutNode : public LayoutNode { public: // LayoutNode - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { assert(false); return 0; } diff --git a/poincare/include/poincare/approximation.h b/poincare/include/poincare/approximation.h index 747457fa2..d46e47fb9 100644 --- a/poincare/include/poincare/approximation.h +++ b/poincare/include/poincare/approximation.h @@ -37,20 +37,20 @@ public: assert(false); return 0; } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { assert(false); return 0; } private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { assert(false); return nullptr; } /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { return new Complex((U)m_complex.real(), (U)m_complex.imag()); } std::complex m_complex; diff --git a/poincare/include/poincare/approximation_engine.h b/poincare/include/poincare/approximation_engine.h index 4224ebfff..d50f819d8 100644 --- a/poincare/include/poincare/approximation_engine.h +++ b/poincare/include/poincare/approximation_engine.h @@ -11,14 +11,14 @@ class ApproximationEngine { public: template static std::complex truncateRealOrImaginaryPartAccordingToArgument(std::complex c); - template using ComplexCompute = std::complex(*)(const std::complex, Expression::AngleUnit angleUnit); - template static Evaluation * map(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexCompute compute); + template using ComplexCompute = std::complex(*)(const std::complex, Preferences::AngleUnit angleUnit); + template static Evaluation * map(const Expression * expression, Context& context, Preferences::AngleUnit angleUnit, ComplexCompute compute); template using ComplexAndComplexReduction = std::complex(*)(const std::complex, const std::complex); template using ComplexAndMatrixReduction = MatrixComplex(*)(const std::complex c, const MatrixComplex m); template using MatrixAndComplexReduction = MatrixComplex(*)(const MatrixComplex m, const std::complex c); template using MatrixAndMatrixReduction = MatrixComplex(*)(const MatrixComplex m, const MatrixComplex n); - template static Evaluation * mapReduce(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexAndComplexReduction computeOnComplexes, ComplexAndMatrixReduction computeOnComplexAndMatrix, MatrixAndComplexReduction computeOnMatrixAndComplex, MatrixAndMatrixReduction computeOnMatrices); + template static Evaluation * mapReduce(const Expression * expression, Context& context, Preferences::AngleUnit angleUnit, ComplexAndComplexReduction computeOnComplexes, ComplexAndMatrixReduction computeOnComplexAndMatrix, MatrixAndComplexReduction computeOnMatrixAndComplex, MatrixAndMatrixReduction computeOnMatrices); template static MatrixComplex elementWiseOnMatrixComplexAndComplex(const MatrixComplex n, const std::complex c, ComplexAndComplexReduction computeOnComplexes); template static MatrixComplex elementWiseOnComplexMatrices(const MatrixComplex m, const MatrixComplex n, ComplexAndComplexReduction computeOnComplexes); diff --git a/poincare/include/poincare/arc_cosine.h b/poincare/include/poincare/arc_cosine.h index 050bd8a91..940dbed26 100644 --- a/poincare/include/poincare/arc_cosine.h +++ b/poincare/include/poincare/arc_cosine.h @@ -15,23 +15,23 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "acos"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/arc_sine.h b/poincare/include/poincare/arc_sine.h index cf5bce0f6..38ee27c8e 100644 --- a/poincare/include/poincare/arc_sine.h +++ b/poincare/include/poincare/arc_sine.h @@ -15,21 +15,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "asin"; } /* Simplification */ - Expression * shallowReduce(Context & context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/arc_tangent.h b/poincare/include/poincare/arc_tangent.h index 911bd0675..c31154c33 100644 --- a/poincare/include/poincare/arc_tangent.h +++ b/poincare/include/poincare/arc_tangent.h @@ -15,21 +15,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "atan"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/binomial_coefficient.h b/poincare/include/poincare/binomial_coefficient.h index c88b2f2b7..0981fd7d2 100644 --- a/poincare/include/poincare/binomial_coefficient.h +++ b/poincare/include/poincare/binomial_coefficient.h @@ -16,16 +16,16 @@ public: private: constexpr static int k_maxNValue = 300; /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "binomial"); } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/binomial_coefficient_layout_node.h b/poincare/include/poincare/binomial_coefficient_layout_node.h index f313d09bc..c9f45bf79 100644 --- a/poincare/include/poincare/binomial_coefficient_layout_node.h +++ b/poincare/include/poincare/binomial_coefficient_layout_node.h @@ -19,7 +19,7 @@ public: void moveCursorDown(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; // SerializableNode - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // TreeNode size_t size() const override { return sizeof(BinomialCoefficientLayoutNode); } diff --git a/poincare/include/poincare/bracket_pair_layout_node.h b/poincare/include/poincare/bracket_pair_layout_node.h index 1c167e088..3fc66ad94 100644 --- a/poincare/include/poincare/bracket_pair_layout_node.h +++ b/poincare/include/poincare/bracket_pair_layout_node.h @@ -20,7 +20,7 @@ public: void moveCursorLeft(LayoutCursor * cursor, bool * shouldRecomputeLayout) override; void moveCursorRight(LayoutCursor * cursor, bool * shouldRecomputeLayout) override; void deleteBeforeCursor(LayoutCursor * cursor) override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; bool shouldCollapseSiblingsOnRight() const override{ return true; } void didCollapseSiblings(LayoutCursor * cursor) override; diff --git a/poincare/include/poincare/ceiling.h b/poincare/include/poincare/ceiling.h index 2e4c66bb5..4ce13cdef 100644 --- a/poincare/include/poincare/ceiling.h +++ b/poincare/include/poincare/ceiling.h @@ -14,19 +14,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "ceil"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/ceiling_layout_node.h b/poincare/include/poincare/ceiling_layout_node.h index ea69cb168..493b8b716 100644 --- a/poincare/include/poincare/ceiling_layout_node.h +++ b/poincare/include/poincare/ceiling_layout_node.h @@ -9,7 +9,7 @@ namespace Poincare { class CeilingLayoutNode : public BracketPairLayoutNode { public: using BracketPairLayoutNode::BracketPairLayoutNode; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixSerializableRefTextInBuffer(SerializableRef(const_cast(this)), buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "ceil"); } // TreeNode diff --git a/poincare/include/poincare/char_layout_node.h b/poincare/include/poincare/char_layout_node.h index f57023d76..447ec2554 100644 --- a/poincare/include/poincare/char_layout_node.h +++ b/poincare/include/poincare/char_layout_node.h @@ -23,7 +23,7 @@ public: // LayoutNode void moveCursorLeft(LayoutCursor * cursor, bool * shouldRecomputeLayout) override; void moveCursorRight(LayoutCursor * cursor, bool * shouldRecomputeLayout) override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; bool isCollapsable(int * numberOfOpenParenthesis, bool goingLeft) const override; // TreeNode diff --git a/poincare/include/poincare/complex_argument.h b/poincare/include/poincare/complex_argument.h index 854747405..6fbb6541d 100644 --- a/poincare/include/poincare/complex_argument.h +++ b/poincare/include/poincare/complex_argument.h @@ -14,21 +14,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "arg"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/condensed_sum_layout_node.h b/poincare/include/poincare/condensed_sum_layout_node.h index 4829ce981..e3565cfa9 100644 --- a/poincare/include/poincare/condensed_sum_layout_node.h +++ b/poincare/include/poincare/condensed_sum_layout_node.h @@ -16,7 +16,7 @@ public: * a view with no cursor. */ void moveCursorLeft(LayoutCursor * cursor, bool * shouldRecomputeLayout) override { assert(false); } void moveCursorRight(LayoutCursor * cursor, bool * shouldRecomputeLayout) override { assert(false); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixSerializableRefTextInBuffer(SerializableRef(const_cast(this)), buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "sum"); } diff --git a/poincare/include/poincare/confidence_interval.h b/poincare/include/poincare/confidence_interval.h index 7182f698d..2eb1899ea 100644 --- a/poincare/include/poincare/confidence_interval.h +++ b/poincare/include/poincare/confidence_interval.h @@ -14,19 +14,19 @@ public: int polynomialDegree(char symbolName) const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } virtual const char * name() const { return "confidence"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(Expression::SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(Expression::DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; class SimplePredictionInterval : public ConfidenceInterval { diff --git a/poincare/include/poincare/conjugate.h b/poincare/include/poincare/conjugate.h index 64a9737ba..5cd8c02bf 100644 --- a/poincare/include/poincare/conjugate.h +++ b/poincare/include/poincare/conjugate.h @@ -14,18 +14,18 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "conj"); } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/conjugate_layout_node.h b/poincare/include/poincare/conjugate_layout_node.h index e14aa1d98..58bd4fdbd 100644 --- a/poincare/include/poincare/conjugate_layout_node.h +++ b/poincare/include/poincare/conjugate_layout_node.h @@ -14,7 +14,7 @@ public: // LayoutNode void moveCursorLeft(LayoutCursor * cursor, bool * shouldRecomputeLayout) override; void moveCursorRight(LayoutCursor * cursor, bool * shouldRecomputeLayout) override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; bool shouldCollapseSiblingsOnRight() const override { return true; } // TreeNode diff --git a/poincare/include/poincare/cosine.h b/poincare/include/poincare/cosine.h index bfceb7455..f1a7ec119 100644 --- a/poincare/include/poincare/cosine.h +++ b/poincare/include/poincare/cosine.h @@ -15,24 +15,24 @@ class Cosine : public StaticHierarchy<1>::StaticHierarchy { public: Type type() const override; Expression * clone() const override; - float characteristicXRange(Context & context, AngleUnit angleUnit) const override; - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit = AngleUnit::Radian); + float characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const override; + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Radian); private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "cos"; } /* Simplication */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/decimal.h b/poincare/include/poincare/decimal.h index 460c29639..08300cba1 100644 --- a/poincare/include/poincare/decimal.h +++ b/poincare/include/poincare/decimal.h @@ -22,7 +22,7 @@ public: // Expression subclassing Type type() const override; Expression * clone() const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; Sign sign() const override { return m_mantissa.isNegative() ? Sign::Negative : Sign::Positive; } private: constexpr static double k_biggestMantissaFromDouble = 999999999999999; @@ -31,16 +31,16 @@ private: int simplificationOrderSameType(const Expression * e, bool canBeInterrupted) const override; /* Layout */ bool needParenthesisWithParent(const Expression * e) const override; - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; - Expression * shallowBeautify(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; + Expression * shallowBeautify(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; - int convertToText(char * buffer, int bufferSize, PrintFloat::Mode mode, int numberOfSignificantDigits) const; + int convertToText(char * buffer, int bufferSize, Preferences::PrintFloatMode mode, int numberOfSignificantDigits) const; // Worst case is -1.2345678901234E-1000 constexpr static int k_maxBufferSize = PrintFloat::k_numberOfStoredSignificantDigits+1+1+1+1+4+1; Integer m_mantissa; diff --git a/poincare/include/poincare/derivative.h b/poincare/include/poincare/derivative.h index dc6c8696f..5254860df 100644 --- a/poincare/include/poincare/derivative.h +++ b/poincare/include/poincare/derivative.h @@ -15,21 +15,21 @@ public: int polynomialDegree(char symbolName) const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "diff"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; - template T growthRateAroundAbscissa(T x, T h, Context & context, AngleUnit angleUnit) const; - template T riddersApproximation(Context & context, AngleUnit angleUnit, T x, T h, T * error) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; + template T growthRateAroundAbscissa(T x, T h, Context & context, Preferences::AngleUnit angleUnit) const; + template T riddersApproximation(Context & context, Preferences::AngleUnit angleUnit, T x, T h, T * error) const; // TODO: Change coefficients? constexpr static double k_maxErrorRateOnApproximation = 0.001; constexpr static double k_minInitialRate = 0.01; diff --git a/poincare/include/poincare/determinant.h b/poincare/include/poincare/determinant.h index 562a7ab32..fac092239 100644 --- a/poincare/include/poincare/determinant.h +++ b/poincare/include/poincare/determinant.h @@ -13,19 +13,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "det"; } /* Simplification */ - Expression * shallowReduce(Context & context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/division.h b/poincare/include/poincare/division.h index 6d93ca801..705099e3a 100644 --- a/poincare/include/poincare/division.h +++ b/poincare/include/poincare/division.h @@ -20,22 +20,22 @@ public: private: /* Layout */ bool needParenthesisWithParent(const Expression * e) const override; - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writeInfixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "/"); } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ template static MatrixComplex computeOnMatrixAndComplex(const MatrixComplex m, const std::complex c) { return ApproximationEngine::elementWiseOnMatrixComplexAndComplex(m, c, compute); } template static MatrixComplex computeOnComplexAndMatrix(const std::complex c, const MatrixComplex n); template static MatrixComplex computeOnMatrices(const MatrixComplex m, const MatrixComplex n); - virtual Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + virtual Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } - virtual Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + virtual Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } }; diff --git a/poincare/include/poincare/division_quotient.h b/poincare/include/poincare/division_quotient.h index 66df8b60a..934f61a4f 100644 --- a/poincare/include/poincare/division_quotient.h +++ b/poincare/include/poincare/division_quotient.h @@ -15,19 +15,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "quo"; } /* Simplification */ - Expression * shallowReduce(Context & context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/division_remainder.h b/poincare/include/poincare/division_remainder.h index 6620c43bb..344840f9c 100644 --- a/poincare/include/poincare/division_remainder.h +++ b/poincare/include/poincare/division_remainder.h @@ -14,19 +14,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "rem"; } /* Simplification */ - Expression * shallowReduce(Context & context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/empty_expression.h b/poincare/include/poincare/empty_expression.h index 02bb43bff..c070cc628 100644 --- a/poincare/include/poincare/empty_expression.h +++ b/poincare/include/poincare/empty_expression.h @@ -14,14 +14,14 @@ public: return Type::EmptyExpression; } Expression * clone() const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/empty_layout_node.h b/poincare/include/poincare/empty_layout_node.h index b0fc1937d..1d18a1e6a 100644 --- a/poincare/include/poincare/empty_layout_node.h +++ b/poincare/include/poincare/empty_layout_node.h @@ -34,7 +34,7 @@ public: void deleteBeforeCursor(LayoutCursor * cursor) override; void moveCursorLeft(LayoutCursor * cursor, bool * shouldRecomputeLayout) override; void moveCursorRight(LayoutCursor * cursor, bool * shouldRecomputeLayout) override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; bool isEmpty() const override { return true; } // TreeNode diff --git a/poincare/include/poincare/equal.h b/poincare/include/poincare/equal.h index b6d3cf907..f591059bb 100644 --- a/poincare/include/poincare/equal.h +++ b/poincare/include/poincare/equal.h @@ -14,19 +14,19 @@ public: Expression * clone() const override; int polynomialDegree(char symbolName) const override; // For the equation A = B, create the reduced expression A-B - Expression * standardEquation(Context & context, AngleUnit angleUnit) const; + Expression * standardEquation(Context & context, Preferences::AngleUnit angleUnit) const; private: /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writeInfixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "="); } /* Evalutation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/evaluation.h b/poincare/include/poincare/evaluation.h index e127f99a1..13af6a966 100644 --- a/poincare/include/poincare/evaluation.h +++ b/poincare/include/poincare/evaluation.h @@ -30,7 +30,7 @@ public: virtual ~Evaluation() {} virtual bool isUndefined() const = 0; virtual T toScalar() const { return NAN; } - virtual Expression * complexToExpression(Expression::ComplexFormat complexFormat) const = 0; + virtual Expression * complexToExpression(Preferences::ComplexFormat complexFormat) const = 0; virtual std::complex createTrace() const = 0; virtual std::complex createDeterminant() const = 0; virtual Evaluation * createInverse() const = 0; @@ -61,7 +61,7 @@ public: return (std::isnan(this->real()) && std::isnan(this->imag())); } T toScalar() const override; - Expression * complexToExpression(Expression::ComplexFormat complexFormat) const override; + Expression * complexToExpression(Preferences::ComplexFormat complexFormat) const override; std::complex createTrace() const override { return *this; } std::complex createDeterminant() const override { return *this; } Complex * createInverse() const override; @@ -100,7 +100,7 @@ public: bool isUndefined() const override { return (numberOfRows() == 1 && numberOfColumns() == 1 && std::isnan(complexOperand(0).real()) && std::isnan(complexOperand(0).imag())); } - Expression * complexToExpression(Expression::ComplexFormat complexFormat) const override; + Expression * complexToExpression(Preferences::ComplexFormat complexFormat) const override; std::complex createTrace() const override; std::complex createDeterminant() const override; MatrixComplex * createInverse() const override; diff --git a/poincare/include/poincare/evaluation_mode.h b/poincare/include/poincare/evaluation_mode.h deleted file mode 100644 index fea357ee5..000000000 --- a/poincare/include/poincare/evaluation_mode.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef POINCARE_EVALUATION_MODE_H -#define POINCARE_EVALUATION_MODE_H - -namespace Poincare { - -enum class ComplexFormat { - Cartesian = 0, - Polar = 1, - Default = 2 -}; - -enum class AngleUnit { - Degree = 0, - Radian = 1, - Default = 2 -}; - -} diff --git a/poincare/include/poincare/expression.h b/poincare/include/poincare/expression.h index 14bded5c0..7f248fd2f 100644 --- a/poincare/include/poincare/expression.h +++ b/poincare/include/poincare/expression.h @@ -149,14 +149,6 @@ public: SimplificationRoot, EmptyExpression }; - enum class ComplexFormat { - Cartesian = 0, - Polar = 1, - }; - enum class AngleUnit { - Degree = 0, - Radian = 1, - }; /* Constructor & Destructor */ static Expression * parse(char const * string); @@ -207,7 +199,7 @@ public: * the return value is NAN. * NB: so far, we consider that the only way of building a periodic function * is to use sin/tan/cos(f(x)) with f a linear function. */ - virtual float characteristicXRange(Context & context, AngleUnit angleUnit) const; + virtual float characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const; static bool IsMatrix(const Expression * e, Context & context); /* polynomialDegree returns: @@ -226,14 +218,14 @@ public: * the variables hold in 'variables'. Otherwise, it fills 'coefficients' with * the coefficients of the variables hold in 'variables' (following the same * order) and 'constant' with the constant of the expression. */ - bool getLinearCoefficients(char * variables, Expression * coefficients[], Expression * constant[], Context & context, AngleUnit angleUnit) const; + bool getLinearCoefficients(char * variables, Expression * coefficients[], Expression * constant[], Context & context, Preferences::AngleUnit angleUnit) const; /* getPolynomialCoefficients fills the table coefficients with the expressions * of the first 3 polynomial coefficients and return polynomialDegree. * coefficients has up to 3 entries. It supposed to be called on Reduced * expression. */ static constexpr int k_maxPolynomialDegree = 2; static constexpr int k_maxNumberOfPolynomialCoefficients = k_maxPolynomialDegree+1; - int getPolynomialCoefficients(char symbolName, Expression * coefficients[], Context & context, AngleUnit angleUnit) const; + int getPolynomialCoefficients(char symbolName, Expression * coefficients[], Context & context, Preferences::AngleUnit angleUnit) const; /* Comparison */ /* isIdenticalTo is the "easy" equality, it returns true if both trees have @@ -244,34 +236,34 @@ public: * order on expresssions. */ return SimplificationOrder(this, e, true) == 0; } - bool isEqualToItsApproximationLayout(Expression * approximation, int bufferSize, AngleUnit angleUnit, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits, Context & context); + bool isEqualToItsApproximationLayout(Expression * approximation, int bufferSize, Preferences::AngleUnit angleUnit, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits, Context & context); /* Layout Engine */ - virtual LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const = 0; - virtual int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits = PrintFloat::k_numberOfStoredSignificantDigits) const = 0; + virtual LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const = 0; + virtual int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits = PrintFloat::k_numberOfStoredSignificantDigits) const = 0; /* Simplification */ - static Expression * ParseAndSimplify(const char * text, Context & context, AngleUnit angleUnit); - static void Simplify(Expression ** expressionAddress, Context & context, AngleUnit angleUnit); - static void Reduce(Expression ** expressionAddress, Context & context, AngleUnit angleUnit, bool recursively = true); + static Expression * ParseAndSimplify(const char * text, Context & context, Preferences::AngleUnit angleUnit); + static void Simplify(Expression ** expressionAddress, Context & context, Preferences::AngleUnit angleUnit); + static void Reduce(Expression ** expressionAddress, Context & context, Preferences::AngleUnit angleUnit, bool recursively = true); /* Evaluation Engine */ /* The function approximate creates a new expression and thus mallocs memory. * Do not forget to delete the new expression to avoid leaking. */ - template Expression * approximate(Context& context, AngleUnit angleUnit, ComplexFormat complexFormat) const; - template T approximateToScalar(Context& context, AngleUnit angleUnit) const; - template static T approximateToScalar(const char * text, Context& context, AngleUnit angleUnit); - template T approximateWithValueForSymbol(char symbol, T x, Context & context, AngleUnit angleUnit) const; + template Expression * approximate(Context& context, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat) const; + template T approximateToScalar(Context& context, Preferences::AngleUnit angleUnit) const; + template static T approximateToScalar(const char * text, Context& context, Preferences::AngleUnit angleUnit); + template T approximateWithValueForSymbol(char symbol, T x, Context & context, Preferences::AngleUnit angleUnit) const; /* Expression roots/extrema solver*/ struct Coordinate2D { double abscissa; double value; }; - Coordinate2D nextMinimum(char symbol, double start, double step, double max, Context & context, AngleUnit angleUnit) const; - Coordinate2D nextMaximum(char symbol, double start, double step, double max, Context & context, AngleUnit angleUnit) const; - double nextRoot(char symbol, double start, double step, double max, Context & context, AngleUnit angleUnit) const; - Coordinate2D nextIntersection(char symbol, double start, double step, double max, Context & context, AngleUnit angleUnit, const Expression * expression) const; + Coordinate2D nextMinimum(char symbol, double start, double step, double max, Context & context, Preferences::AngleUnit angleUnit) const; + Coordinate2D nextMaximum(char symbol, double start, double step, double max, Context & context, Preferences::AngleUnit angleUnit) const; + double nextRoot(char symbol, double start, double step, double max, Context & context, Preferences::AngleUnit angleUnit) const; + Coordinate2D nextIntersection(char symbol, double start, double step, double max, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const; /* Evaluation engine */ template static T epsilon(); @@ -300,7 +292,7 @@ protected: private: virtual Expression * replaceSymbolWithExpression(char symbol, Expression * expression); /* Properties */ - virtual Expression * setSign(Sign s, Context & context, AngleUnit angleUnit) { assert(false); return nullptr; } + virtual Expression * setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) { assert(false); return nullptr; } bool isOfType(Type * types, int length) const; virtual bool needParenthesisWithParent(const Expression * e) const; virtual int privateGetPolynomialCoefficients(char symbolName, Expression * coefficients[]) const; @@ -315,32 +307,32 @@ private: //TODO: What should be the implementation for complex? virtual int simplificationOrderSameType(const Expression * e, bool canBeInterrupted) const { return 0; } /* Simplification */ - Expression * deepBeautify(Context & context, AngleUnit angleUnit); - Expression * deepReduce(Context & context, AngleUnit angleUnit); + Expression * deepBeautify(Context & context, Preferences::AngleUnit angleUnit); + Expression * deepReduce(Context & context, Preferences::AngleUnit angleUnit); // TODO: should be virtual pure - virtual Expression * shallowReduce(Context & context, AngleUnit angleUnit); - virtual Expression * shallowBeautify(Context & context, AngleUnit angleUnit) { return this; }; + virtual Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit); + virtual Expression * shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) { return this; }; // Private methods used in simplification process - virtual Expression * cloneDenominator(Context & context, AngleUnit angleUnit) const { + virtual Expression * cloneDenominator(Context & context, Preferences::AngleUnit angleUnit) const { return nullptr; } /* Evaluation Engine */ - virtual Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const = 0; - virtual Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const = 0; + virtual Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const = 0; + virtual Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const = 0; /* Expression roots/extrema solver*/ constexpr static double k_solverPrecision = 1.0E-5; constexpr static double k_sqrtEps = 1.4901161193847656E-8; // sqrt(DBL_EPSILON) constexpr static double k_goldenRatio = 0.381966011250105151795413165634361882279690820194237137864; // (3-sqrt(5))/2 constexpr static double k_maxFloat = 1e100; - typedef double (*EvaluationAtAbscissa)(char symbol, double abscissa, Context & context, AngleUnit angleUnit, const Expression * expression0, const Expression * expression1); - Coordinate2D nextMinimumOfExpression(char symbol, double start, double step, double max, EvaluationAtAbscissa evaluation, Context & context, AngleUnit angleUnit, const Expression * expression = nullptr, bool lookForRootMinimum = false) const; - void bracketMinimum(char symbol, double start, double step, double max, double result[3], EvaluationAtAbscissa evaluation, Context & context, AngleUnit angleUnit, const Expression * expression = nullptr) const; - Coordinate2D brentMinimum(char symbol, double ax, double bx, EvaluationAtAbscissa evaluation, Context & context, AngleUnit angleUnit, const Expression * expression = nullptr) const; - double nextIntersectionWithExpression(char symbol, double start, double step, double max, EvaluationAtAbscissa evaluation, Context & context, AngleUnit angleUnit, const Expression * expression) const; - void bracketRoot(char symbol, double start, double step, double max, double result[2], EvaluationAtAbscissa evaluation, Context & context, AngleUnit angleUnit, const Expression * expression) const; - double brentRoot(char symbol, double ax, double bx, double precision, EvaluationAtAbscissa evaluation, Context & context, AngleUnit angleUnit, const Expression * expression) const; + typedef double (*EvaluationAtAbscissa)(char symbol, double abscissa, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression0, const Expression * expression1); + Coordinate2D nextMinimumOfExpression(char symbol, double start, double step, double max, EvaluationAtAbscissa evaluation, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression = nullptr, bool lookForRootMinimum = false) const; + void bracketMinimum(char symbol, double start, double step, double max, double result[3], EvaluationAtAbscissa evaluation, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression = nullptr) const; + Coordinate2D brentMinimum(char symbol, double ax, double bx, EvaluationAtAbscissa evaluation, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression = nullptr) const; + double nextIntersectionWithExpression(char symbol, double start, double step, double max, EvaluationAtAbscissa evaluation, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const; + void bracketRoot(char symbol, double start, double step, double max, double result[2], EvaluationAtAbscissa evaluation, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const; + double brentRoot(char symbol, double ax, double bx, double precision, EvaluationAtAbscissa evaluation, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const; Expression * m_parent; }; diff --git a/poincare/include/poincare/factor.h b/poincare/include/poincare/factor.h index c341f2124..153d6284b 100644 --- a/poincare/include/poincare/factor.h +++ b/poincare/include/poincare/factor.h @@ -16,20 +16,20 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "factor"; } /* Simplification */ - Expression * shallowBeautify(Context& context, AngleUnit angleUnit) override; - Expression * createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context & context, AngleUnit angleUnit); + Expression * shallowBeautify(Context& context, Preferences::AngleUnit angleUnit) override; + Expression * createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context & context, Preferences::AngleUnit angleUnit); /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { return operand(0)->privateApproximate(T(), context, angleUnit); } }; diff --git a/poincare/include/poincare/factorial.h b/poincare/include/poincare/factorial.h index d13b67107..28616225f 100644 --- a/poincare/include/poincare/factorial.h +++ b/poincare/include/poincare/factorial.h @@ -15,17 +15,17 @@ private: constexpr static int k_maxOperandValue = 100; /* Layout */ bool needParenthesisWithParent(const Expression * e) const override; - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Simplication */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; - Expression * shallowBeautify(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; + Expression * shallowBeautify(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } diff --git a/poincare/include/poincare/floor.h b/poincare/include/poincare/floor.h index d2b20bcc3..51caa5102 100644 --- a/poincare/include/poincare/floor.h +++ b/poincare/include/poincare/floor.h @@ -14,19 +14,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "floor"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/floor_layout_node.h b/poincare/include/poincare/floor_layout_node.h index c7325b6c7..139fbbbef 100644 --- a/poincare/include/poincare/floor_layout_node.h +++ b/poincare/include/poincare/floor_layout_node.h @@ -9,7 +9,7 @@ namespace Poincare { class FloorLayoutNode : public BracketPairLayoutNode { public: using BracketPairLayoutNode::BracketPairLayoutNode; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixSerializableRefTextInBuffer(SerializableRef(const_cast(this)), buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "floor"); } diff --git a/poincare/include/poincare/frac_part.h b/poincare/include/poincare/frac_part.h index 889fa95cd..5cf00f572 100644 --- a/poincare/include/poincare/frac_part.h +++ b/poincare/include/poincare/frac_part.h @@ -14,21 +14,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "frac"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/fraction_layout_node.h b/poincare/include/poincare/fraction_layout_node.h index f82c6e472..c336141ed 100644 --- a/poincare/include/poincare/fraction_layout_node.h +++ b/poincare/include/poincare/fraction_layout_node.h @@ -17,7 +17,7 @@ public: void moveCursorUp(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void moveCursorDown(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void deleteBeforeCursor(LayoutCursor * cursor) override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; bool shouldCollapseSiblingsOnLeft() const override { return true; } bool shouldCollapseSiblingsOnRight() const override { return true; } int leftCollapsingAbsorbingChildIndex() const override { return 0; } diff --git a/poincare/include/poincare/great_common_divisor.h b/poincare/include/poincare/great_common_divisor.h index 10271f48c..c841b7aec 100644 --- a/poincare/include/poincare/great_common_divisor.h +++ b/poincare/include/poincare/great_common_divisor.h @@ -14,19 +14,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "gcd"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/grid_layout_node.h b/poincare/include/poincare/grid_layout_node.h index b825d4450..5c0c7baae 100644 --- a/poincare/include/poincare/grid_layout_node.h +++ b/poincare/include/poincare/grid_layout_node.h @@ -35,7 +35,7 @@ public: void moveCursorDown(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; // SerializableNode - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { assert(false); return 0; } diff --git a/poincare/include/poincare/horizontal_layout_node.h b/poincare/include/poincare/horizontal_layout_node.h index 0d2106c5e..076e680d7 100644 --- a/poincare/include/poincare/horizontal_layout_node.h +++ b/poincare/include/poincare/horizontal_layout_node.h @@ -23,7 +23,7 @@ public: void moveCursorRight(LayoutCursor * cursor, bool * shouldRecomputeLayout) override; LayoutCursor equivalentCursor(LayoutCursor * cursor) override; void deleteBeforeCursor(LayoutCursor * cursor) override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; bool isHorizontal() const override { return true; } bool isEmpty() const override { return m_numberOfChildren == 1 && const_cast(this)->childAtIndex(0)->isEmpty(); } diff --git a/poincare/include/poincare/hyperbolic_arc_cosine.h b/poincare/include/poincare/hyperbolic_arc_cosine.h index fb5f36741..6b3201e33 100644 --- a/poincare/include/poincare/hyperbolic_arc_cosine.h +++ b/poincare/include/poincare/hyperbolic_arc_cosine.h @@ -14,21 +14,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "acosh"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_arc_sine.h b/poincare/include/poincare/hyperbolic_arc_sine.h index 6069d8a7a..fc3434d40 100644 --- a/poincare/include/poincare/hyperbolic_arc_sine.h +++ b/poincare/include/poincare/hyperbolic_arc_sine.h @@ -14,21 +14,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "asinh"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_arc_tangent.h b/poincare/include/poincare/hyperbolic_arc_tangent.h index ca236f17d..6e58d6a11 100644 --- a/poincare/include/poincare/hyperbolic_arc_tangent.h +++ b/poincare/include/poincare/hyperbolic_arc_tangent.h @@ -14,21 +14,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "atanh"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_cosine.h b/poincare/include/poincare/hyperbolic_cosine.h index 816f7f055..759f392cb 100644 --- a/poincare/include/poincare/hyperbolic_cosine.h +++ b/poincare/include/poincare/hyperbolic_cosine.h @@ -12,23 +12,23 @@ class HyperbolicCosine : public StaticHierarchy<1> { public: Type type() const override; Expression * clone() const override; - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "cosh"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_sine.h b/poincare/include/poincare/hyperbolic_sine.h index 7eaed7770..0085bd80b 100644 --- a/poincare/include/poincare/hyperbolic_sine.h +++ b/poincare/include/poincare/hyperbolic_sine.h @@ -12,23 +12,23 @@ class HyperbolicSine : public StaticHierarchy<1> { public: Type type() const override; Expression * clone() const override; - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "sinh"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/hyperbolic_tangent.h b/poincare/include/poincare/hyperbolic_tangent.h index 4b2cfd70a..c5b608715 100644 --- a/poincare/include/poincare/hyperbolic_tangent.h +++ b/poincare/include/poincare/hyperbolic_tangent.h @@ -12,23 +12,23 @@ class HyperbolicTangent : public StaticHierarchy<1> { public: Type type() const override; Expression * clone() const override; - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "tanh"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/imaginary_part.h b/poincare/include/poincare/imaginary_part.h index 2b0d10dd0..2be675aa7 100644 --- a/poincare/include/poincare/imaginary_part.h +++ b/poincare/include/poincare/imaginary_part.h @@ -14,21 +14,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "im"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/integral.h b/poincare/include/poincare/integral.h index 5a31fb37a..1cd90710a 100644 --- a/poincare/include/poincare/integral.h +++ b/poincare/include/poincare/integral.h @@ -15,16 +15,16 @@ public: int polynomialDegree(char symbolName) const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "int"); } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; template struct DetailedResult { @@ -33,12 +33,12 @@ private: }; constexpr static int k_maxNumberOfIterations = 10; #ifdef LAGRANGE_METHOD - template T lagrangeGaussQuadrature(T a, T b, Context & context, AngleUnit angleUnit) const; + template T lagrangeGaussQuadrature(T a, T b, Context & context, Preferences::AngleUnit angleUnit) const; #else - template DetailedResult kronrodGaussQuadrature(T a, T b, Context & context, AngleUnit angleUnit) const; - template T adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, Context & context, AngleUnit angleUnit) const; + template DetailedResult kronrodGaussQuadrature(T a, T b, Context & context, Preferences::AngleUnit angleUnit) const; + template T adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, Context & context, Preferences::AngleUnit angleUnit) const; #endif - template T functionValueAtAbscissa(T x, Context & xcontext, AngleUnit angleUnit) const; + template T functionValueAtAbscissa(T x, Context & xcontext, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/integral_layout_node.h b/poincare/include/poincare/integral_layout_node.h index d0a577883..9d8634480 100644 --- a/poincare/include/poincare/integral_layout_node.h +++ b/poincare/include/poincare/integral_layout_node.h @@ -21,7 +21,7 @@ public: void moveCursorUp(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void moveCursorDown(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void deleteBeforeCursor(LayoutCursor * cursor) override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; LayoutNode * layoutToPointWhenInserting() override { assert(lowerBoundLayout() != nullptr); return lowerBoundLayout(); diff --git a/poincare/include/poincare/layout_engine.h b/poincare/include/poincare/layout_engine.h index 20a764cb2..95e84660e 100644 --- a/poincare/include/poincare/layout_engine.h +++ b/poincare/include/poincare/layout_engine.h @@ -10,8 +10,8 @@ class LayoutEngine { public: /* Expression to Layout */ - static LayoutRef createInfixLayout(const Expression * expression, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits, const char * operatorName); - static LayoutRef createPrefixLayout(const Expression * expression, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits, const char * operatorName); + static LayoutRef createInfixLayout(const Expression * expression, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits, const char * operatorName); + static LayoutRef createPrefixLayout(const Expression * expression, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits, const char * operatorName); /* Create special layouts */ static LayoutRef createParenthesedLayout(LayoutRef layout, bool cloneLayout); @@ -23,14 +23,14 @@ public: const Expression * expression, char * buffer, int bufferSize, - PrintFloat::Mode floatDisplayMode, + Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName); static int writePrefixExpressionTextInBuffer( const Expression * expression, char * buffer, int bufferSize, - PrintFloat::Mode floatDisplayMode, + Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName); @@ -39,7 +39,7 @@ public: const SerializableRef serializableRef, char * buffer, int bufferSize, - PrintFloat::Mode floatDisplayMode, + Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName, int firstChildIndex = 0, @@ -49,7 +49,7 @@ public: const SerializableRef serializableRef, char * buffer, int bufferSize, - PrintFloat::Mode floatDisplayMode, + Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName, bool writeFirstChild = true); //TODO @@ -60,10 +60,10 @@ public: private: static constexpr char divideChar = '/'; // These two functions return the index of the null-terminating char. - static int writeInfixExpressionOrExpressionLayoutTextInBuffer(const Expression * expression, void * expressionLayout, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfDigits, const char * operatorName, int firstChildIndex, int lastChildIndex); - static int writePrefixExpressionOrExpressionLayoutTextInBuffer(const Expression * expression, void * expressionLayout, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfDigits, const char * operatorName, bool writeFirstChild = true); + static int writeInfixExpressionOrExpressionLayoutTextInBuffer(const Expression * expression, void * expressionLayout, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName, int firstChildIndex, int lastChildIndex); + static int writePrefixExpressionOrExpressionLayoutTextInBuffer(const Expression * expression, void * expressionLayout, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName, bool writeFirstChild = true); - static void writeChildTreeInBuffer(SerializableRef childRef, SerializableRef parentRef, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfDigits, int * numberOfChar); + static void writeChildTreeInBuffer(SerializableRef childRef, SerializableRef parentRef, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, int * numberOfChar); }; } diff --git a/poincare/include/poincare/least_common_multiple.h b/poincare/include/poincare/least_common_multiple.h index 8d24c8d7e..e2a557e8f 100644 --- a/poincare/include/poincare/least_common_multiple.h +++ b/poincare/include/poincare/least_common_multiple.h @@ -14,19 +14,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "lcm"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/left_parenthesis_layout_node.h b/poincare/include/poincare/left_parenthesis_layout_node.h index e3881e692..3eca0a464 100644 --- a/poincare/include/poincare/left_parenthesis_layout_node.h +++ b/poincare/include/poincare/left_parenthesis_layout_node.h @@ -19,7 +19,7 @@ public: bool isLeftParenthesis() const override { return true; } // Serializable Node - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writeOneCharInBuffer(buffer, bufferSize, '('); } diff --git a/poincare/include/poincare/left_square_bracket_layout_node.h b/poincare/include/poincare/left_square_bracket_layout_node.h index 36e616bf7..1f5294a30 100644 --- a/poincare/include/poincare/left_square_bracket_layout_node.h +++ b/poincare/include/poincare/left_square_bracket_layout_node.h @@ -9,7 +9,7 @@ namespace Poincare { class LeftSquareBracketLayoutNode : public SquareBracketLayoutNode { public: using SquareBracketLayoutNode::SquareBracketLayoutNode; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writeOneCharInBuffer(buffer, bufferSize, '['); } bool isLeftBracket() const override { return true; } diff --git a/poincare/include/poincare/logarithm.h b/poincare/include/poincare/logarithm.h index 5b302864b..c59c6a17f 100644 --- a/poincare/include/poincare/logarithm.h +++ b/poincare/include/poincare/logarithm.h @@ -15,21 +15,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "log"); } /* Simplification */ - Expression * shallowReduce(Context & context, AngleUnit angleUnit) override; - Expression * simpleShallowReduce(Context & context, AngleUnit angleUnit); - Expression * shallowBeautify(Context & context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit) override; + Expression * simpleShallowReduce(Context & context, Preferences::AngleUnit angleUnit); + Expression * shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) override; bool parentIsAPowerOfSameBase() const; - Expression * splitInteger(Integer i, bool isDenominator, Context & context, AngleUnit angleUnit); + Expression * splitInteger(Integer i, bool isDenominator, Context & context, Preferences::AngleUnit angleUnit); /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/matrix.h b/poincare/include/poincare/matrix.h index 460442552..64a13abd3 100644 --- a/poincare/include/poincare/matrix.h +++ b/poincare/include/poincare/matrix.h @@ -21,11 +21,11 @@ public: /* Expression */ Type type() const override; Expression * clone() const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; int polynomialDegree(char symbolName) const override; /* Operation on matrix */ - int rank(Context & context, AngleUnit angleUnit, bool inPlace); + int rank(Context & context, Preferences::AngleUnit angleUnit, bool inPlace); // Inverse the array in-place. Array has to be given in the form array[row_index][column_index] template static int ArrayInverse(T * array, int numberOfRows, int numberOfColumns); #if MATRIX_EXACT_REDUCING @@ -34,19 +34,19 @@ public: Matrix * createTranspose() const; static Matrix * createIdentity(int dim); /* createInverse can be called on any matrix reduce or not, approximate or not. */ - Expression * createInverse(Context & context, AngleUnit angleUnit) const; + Expression * createInverse(Context & context, Preferences::AngleUnit angleUnit) const; #endif private: /* rowCanonize turns a matrix in its reduced row echelon form. */ - void rowCanonize(Context & context, AngleUnit angleUnit, Multiplication * m = nullptr); + void rowCanonize(Context & context, Preferences::AngleUnit angleUnit, Multiplication * m = nullptr); // Row canonize the array in place template static void ArrayRowCanonize(T * array, int numberOfRows, int numberOfColumns, T * c = nullptr); /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; int m_numberOfRows; }; diff --git a/poincare/include/poincare/matrix_dimension.h b/poincare/include/poincare/matrix_dimension.h index 21ef9eb38..935698c00 100644 --- a/poincare/include/poincare/matrix_dimension.h +++ b/poincare/include/poincare/matrix_dimension.h @@ -13,19 +13,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "dim"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/matrix_inverse.h b/poincare/include/poincare/matrix_inverse.h index 26489ce24..fbe59a69a 100644 --- a/poincare/include/poincare/matrix_inverse.h +++ b/poincare/include/poincare/matrix_inverse.h @@ -13,19 +13,19 @@ public: Expression * clone() const override; private: /* Evaluation */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "inverse"; } /* Simplification */ - Expression * shallowReduce(Context & context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/matrix_layout_node.h b/poincare/include/poincare/matrix_layout_node.h index 9c02b7146..59e89dc2a 100644 --- a/poincare/include/poincare/matrix_layout_node.h +++ b/poincare/include/poincare/matrix_layout_node.h @@ -23,7 +23,7 @@ public: bool isMatrix() const override { return true; } // SerializableNode - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; // TreeNode size_t size() const override { return sizeof(MatrixLayoutNode); } diff --git a/poincare/include/poincare/matrix_trace.h b/poincare/include/poincare/matrix_trace.h index 1109c1943..75917d79f 100644 --- a/poincare/include/poincare/matrix_trace.h +++ b/poincare/include/poincare/matrix_trace.h @@ -14,19 +14,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "trace"; } /* Simplification */ - Expression * shallowReduce(Context & context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/matrix_transpose.h b/poincare/include/poincare/matrix_transpose.h index 3ea5308e3..52c84c81c 100644 --- a/poincare/include/poincare/matrix_transpose.h +++ b/poincare/include/poincare/matrix_transpose.h @@ -13,19 +13,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "transpose"; } /* Simplification */ - Expression * shallowReduce(Context & context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/multiplication.h b/poincare/include/poincare/multiplication.h index e5d903d90..fa0763220 100644 --- a/poincare/include/poincare/multiplication.h +++ b/poincare/include/poincare/multiplication.h @@ -33,39 +33,39 @@ public: template static MatrixComplex computeOnMatrices(const MatrixComplex m, const MatrixComplex n); private: /* Property */ - Expression * setSign(Sign s, Context & context, AngleUnit angleUnit) override; + Expression * setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) override; /* Layout */ bool needParenthesisWithParent(const Expression * e) const override; - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; - Expression * privateShallowReduce(Context& context, AngleUnit angleUnit, bool expand, bool canBeInterrupted); + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; + Expression * privateShallowReduce(Context& context, Preferences::AngleUnit angleUnit, bool expand, bool canBeInterrupted); void mergeMultiplicationOperands(); - void factorizeBase(Expression * e1, Expression * e2, Context & context, AngleUnit angleUnit); - void factorizeExponent(Expression * e1, Expression * e2, Context & context, AngleUnit angleUnit); - Expression * distributeOnOperandAtIndex(int index, Context & context, AngleUnit angleUnit); - Expression * cloneDenominator(Context & context, AngleUnit angleUnit) const override; - void addMissingFactors(Expression * factor, Context & context, AngleUnit angleUnit); - void factorizeSineAndCosine(Expression * o1, Expression * o2, Context & context, AngleUnit angleUnit); + void factorizeBase(Expression * e1, Expression * e2, Context & context, Preferences::AngleUnit angleUnit); + void factorizeExponent(Expression * e1, Expression * e2, Context & context, Preferences::AngleUnit angleUnit); + Expression * distributeOnOperandAtIndex(int index, Context & context, Preferences::AngleUnit angleUnit); + Expression * cloneDenominator(Context & context, Preferences::AngleUnit angleUnit) const override; + void addMissingFactors(Expression * factor, Context & context, Preferences::AngleUnit angleUnit); + void factorizeSineAndCosine(Expression * o1, Expression * o2, Context & context, Preferences::AngleUnit angleUnit); static bool HaveSameNonRationalFactors(const Expression * e1, const Expression * e2); static bool TermsHaveIdenticalBase(const Expression * e1, const Expression * e2); static bool TermsHaveIdenticalExponent(const Expression * e1, const Expression * e2); static bool TermHasRationalBase(const Expression * e); static bool TermHasRationalExponent(const Expression * e); static const Expression * CreateExponent(Expression * e); - Expression * shallowBeautify(Context & context, AngleUnit angleUnit) override; + Expression * shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) override; // Warning: mergeNegativePower not always returns a multiplication: *(b^-1,c^-1) -> (bc)^-1 - Expression * mergeNegativePower(Context & context, AngleUnit angleUnit); + Expression * mergeNegativePower(Context & context, Preferences::AngleUnit angleUnit); /* Evaluation */ template static MatrixComplex computeOnMatrixAndComplex(const MatrixComplex m, const std::complex c) { return ApproximationEngine::elementWiseOnMatrixComplexAndComplex(m, c, compute); } - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } }; diff --git a/poincare/include/poincare/naperian_logarithm.h b/poincare/include/poincare/naperian_logarithm.h index 8ab82561c..5d6642bc6 100644 --- a/poincare/include/poincare/naperian_logarithm.h +++ b/poincare/include/poincare/naperian_logarithm.h @@ -14,21 +14,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "ln"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/nth_root.h b/poincare/include/poincare/nth_root.h index c078023be..551fdddc0 100644 --- a/poincare/include/poincare/nth_root.h +++ b/poincare/include/poincare/nth_root.h @@ -13,16 +13,16 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "root"); } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; diff --git a/poincare/include/poincare/nth_root_layout_node.h b/poincare/include/poincare/nth_root_layout_node.h index 35e4399fa..372e3b280 100644 --- a/poincare/include/poincare/nth_root_layout_node.h +++ b/poincare/include/poincare/nth_root_layout_node.h @@ -23,7 +23,7 @@ public: void moveCursorUp(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void moveCursorDown(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void deleteBeforeCursor(LayoutCursor * cursor) override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; bool shouldCollapseSiblingsOnRight() const override { return true; } bool hasUpperLeftIndex() const override { return numberOfChildren() > 1; } diff --git a/poincare/include/poincare/opposite.h b/poincare/include/poincare/opposite.h index 17761b365..992f48b28 100644 --- a/poincare/include/poincare/opposite.h +++ b/poincare/include/poincare/opposite.h @@ -14,19 +14,19 @@ public: Type type() const override; int polynomialDegree(char symbolName) const override; Sign sign() const override; - template static std::complex compute(const std::complex c, AngleUnit angleUnit); + template static std::complex compute(const std::complex c, Preferences::AngleUnit angleUnit); private: /* Layout */ bool needParenthesisWithParent(const Expression * e) const override; - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, compute); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, compute); } }; diff --git a/poincare/include/poincare/parenthesis.h b/poincare/include/poincare/parenthesis.h index 201a7c797..49f3ad9a4 100644 --- a/poincare/include/poincare/parenthesis.h +++ b/poincare/include/poincare/parenthesis.h @@ -15,16 +15,16 @@ public: int polynomialDegree(char symbolName) const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, ""); } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; diff --git a/poincare/include/poincare/permute_coefficient.h b/poincare/include/poincare/permute_coefficient.h index acc9bd3bc..07356073f 100644 --- a/poincare/include/poincare/permute_coefficient.h +++ b/poincare/include/poincare/permute_coefficient.h @@ -15,19 +15,19 @@ public: private: constexpr static int k_maxNValue = 100; /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "permute"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/power.h b/poincare/include/poincare/power.h index 7ab869222..48403b194 100644 --- a/poincare/include/poincare/power.h +++ b/poincare/include/poincare/power.h @@ -29,27 +29,27 @@ private: constexpr static int k_maxNumberOfTermsInExpandedMultinome = 25; constexpr static int k_maxExactPowerMatrix = 100; /* Property */ - Expression * setSign(Sign s, Context & context, AngleUnit angleUnit) override; + Expression * setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) override; /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; bool needParenthesisWithParent(const Expression * e) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writeInfixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } static const char * name() { return "^"; } /* Simplify */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; - Expression * shallowBeautify(Context & context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; + Expression * shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) override; int simplificationOrderGreaterType(const Expression * e, bool canBeInterrupted) const override; int simplificationOrderSameType(const Expression * e, bool canBeInterrupted) const override; - Expression * simplifyPowerPower(Power * p, Expression * r, Context & context, AngleUnit angleUnit); - Expression * cloneDenominator(Context & context, AngleUnit angleUnit) const override; - Expression * simplifyPowerMultiplication(Multiplication * m, Expression * r, Context & context, AngleUnit angleUnit); - Expression * simplifyRationalRationalPower(Expression * result, Rational * a, Rational * b, Context & context, AngleUnit angleUnit); - Expression * removeSquareRootsFromDenominator(Context & context, AngleUnit angleUnit); + Expression * simplifyPowerPower(Power * p, Expression * r, Context & context, Preferences::AngleUnit angleUnit); + Expression * cloneDenominator(Context & context, Preferences::AngleUnit angleUnit) const override; + Expression * simplifyPowerMultiplication(Multiplication * m, Expression * r, Context & context, Preferences::AngleUnit angleUnit); + Expression * simplifyRationalRationalPower(Expression * result, Rational * a, Rational * b, Context & context, Preferences::AngleUnit angleUnit); + Expression * removeSquareRootsFromDenominator(Context & context, Preferences::AngleUnit angleUnit); bool parentIsALogarithmOfSameBase() const; bool isNthRootOfUnity() const; - static Expression * CreateSimplifiedIntegerRationalPower(Integer i, Rational * r, bool isDenominator, Context & context, AngleUnit angleUnit); + static Expression * CreateSimplifiedIntegerRationalPower(Integer i, Rational * r, bool isDenominator, Context & context, Preferences::AngleUnit angleUnit); static Expression * CreateNthRootOfUnity(const Rational r); static bool TermIsARationalSquareRootOrRational(const Expression * e); static const Rational * RadicandInExpression(const Expression * e); @@ -60,10 +60,10 @@ private: template static MatrixComplex computeOnComplexAndMatrix(const std::complex c, const MatrixComplex n); template static MatrixComplex computeOnMatrixAndComplex(const MatrixComplex m, const std::complex d); template static MatrixComplex computeOnMatrices(const MatrixComplex m, const MatrixComplex n); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } }; diff --git a/poincare/include/poincare/prediction_interval.h b/poincare/include/poincare/prediction_interval.h index 61c30e509..9436fd59b 100644 --- a/poincare/include/poincare/prediction_interval.h +++ b/poincare/include/poincare/prediction_interval.h @@ -14,19 +14,19 @@ public: int polynomialDegree(char symbolName) const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "prediction95"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(Expression::SinglePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(Expression::DoublePrecision p, Context& context, Expression::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(Expression::SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(Expression::DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/preferences.h b/poincare/include/poincare/preferences.h index 3cc0e86df..98ecff1c7 100644 --- a/poincare/include/poincare/preferences.h +++ b/poincare/include/poincare/preferences.h @@ -1,8 +1,6 @@ #ifndef POINCARE_PREFERENCES_H #define POINCARE_PREFERENCES_H -#include - namespace Poincare { class Preferences { @@ -11,23 +9,42 @@ public: Edition1D, Edition2D }; + /* The 'PrintFlotMode' refers to the way to display float 'scientific' or + * 'auto'. The scientific mode returns float with style -1.2E2 whereas the + * auto mode tries to return 'natural' float like (0.021) and switches to + * scientific mode if the float is too small or too big regarding the number + * of significant digits. */ + enum class PrintFloatMode { + Decimal = 0, + Scientific = 1, + }; + enum class ComplexFormat { + Cartesian = 0, + Polar = 1, + Default = 2 + }; + enum class AngleUnit { + Degree = 0, + Radian = 1, + Default = 2 + }; Preferences(); static Preferences * sharedPreferences(); - Expression::AngleUnit angleUnit() const; - void setAngleUnit(Expression::AngleUnit angleUnit); - PrintFloat::Mode displayMode() const; - void setDisplayMode(PrintFloat::Mode mode); + AngleUnit angleUnit() const; + void setAngleUnit(AngleUnit angleUnit); + PrintFloatMode displayMode() const; + void setDisplayMode(PrintFloatMode mode); EditionMode editionMode() const; void setEditionMode(EditionMode editionMode); - Expression::ComplexFormat complexFormat() const; - void setComplexFormat(Expression::ComplexFormat complexFormat); + ComplexFormat complexFormat() const; + void setComplexFormat(Preferences::ComplexFormat complexFormat); char numberOfSignificantDigits() const; void setNumberOfSignificantDigits(char numberOfSignificantDigits); private: - Expression::AngleUnit m_angleUnit; - PrintFloat::Mode m_displayMode; + AngleUnit m_angleUnit; + PrintFloatMode m_displayMode; EditionMode m_editionMode; - Expression::ComplexFormat m_complexFormat; + ComplexFormat m_complexFormat; char m_numberOfSignificantDigits; }; diff --git a/poincare/include/poincare/print_float.h b/poincare/include/poincare/print_float.h index 5c22cd962..1d42b11b8 100644 --- a/poincare/include/poincare/print_float.h +++ b/poincare/include/poincare/print_float.h @@ -1,21 +1,14 @@ #ifndef POINCARE_PRINT_FLOAT_H #define POINCARE_PRINT_FLOAT_H -#include #include +#include namespace Poincare { +class Integer; + namespace PrintFloat { - /* The 'Mode' refers to the way to display float 'scientific' or 'auto'. The - * scientific mode returns float with style -1.2E2 whereas the auto mode - * tries to return 'natural' float like (0.021) and switches to scientific - * mode if the float is too small or too big regarding the number of - * significant digits. */ - enum class Mode { - Decimal = 0, - Scientific = 1, - }; constexpr static int bufferSizeForFloatsWithPrecision(int numberOfSignificantDigits) { // The wors case is -1.234E-38 return numberOfSignificantDigits + 7; @@ -52,9 +45,9 @@ namespace PrintFloat { * ConvertFloatToText return the number of characters that have been written * in buffer (excluding the last \O character) */ template - int convertFloatToText(T d, char * buffer, int bufferSize, int numberOfSignificantDigits, Mode mode); + int convertFloatToText(T d, char * buffer, int bufferSize, int numberOfSignificantDigits, Preferences::PrintFloatMode mode); template - static int convertFloatToTextPrivate(T f, char * buffer, int numberOfSignificantDigits, Mode mode); + static int convertFloatToTextPrivate(T f, char * buffer, int numberOfSignificantDigits, Preferences::PrintFloatMode mode); } } diff --git a/poincare/include/poincare/product_layout_node.h b/poincare/include/poincare/product_layout_node.h index d5f8f1cb5..23ff237b5 100644 --- a/poincare/include/poincare/product_layout_node.h +++ b/poincare/include/poincare/product_layout_node.h @@ -9,7 +9,7 @@ namespace Poincare { class ProductLayoutNode : public SequenceLayoutNode { public: using SequenceLayoutNode::SequenceLayoutNode; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; protected: void render(KDContext * ctx, KDPoint p, KDColor expressionColor, KDColor backgroundColor) override; private: diff --git a/poincare/include/poincare/randint.h b/poincare/include/poincare/randint.h index 6bdcf7b77..61a8ea7da 100644 --- a/poincare/include/poincare/randint.h +++ b/poincare/include/poincare/randint.h @@ -13,21 +13,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "randint"; } /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templateApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templateApproximate(context, angleUnit); } - template Evaluation * templateApproximate(Context& context, AngleUnit angleUnit) const; + template Evaluation * templateApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/random.h b/poincare/include/poincare/random.h index f7ff59c12..426ee201c 100644 --- a/poincare/include/poincare/random.h +++ b/poincare/include/poincare/random.h @@ -15,20 +15,20 @@ public: Sign sign() const override { return Sign::Positive; } template static T random(); private: - Expression * setSign(Sign s, Context & context, AngleUnit angleUnit) override; + Expression * setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) override; /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "random"; } /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templateApproximate(); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templateApproximate(); } template Evaluation * templateApproximate() const { diff --git a/poincare/include/poincare/rational.h b/poincare/include/poincare/rational.h index c8c4a075b..0d1acda70 100644 --- a/poincare/include/poincare/rational.h +++ b/poincare/include/poincare/rational.h @@ -26,7 +26,7 @@ public: Type type() const override; Expression * clone() const override; Sign sign() const override; - Expression * cloneDenominator(Context & context, AngleUnit angleUnit) const override; + Expression * cloneDenominator(Context & context, Preferences::AngleUnit angleUnit) const override; // Basic test bool isZero() const { return m_numerator.isZero(); } @@ -43,14 +43,14 @@ public: static int NaturalOrder(const Rational & i, const Rational & j); private: bool needParenthesisWithParent(const Expression * e) const override; - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const; - Expression * shallowBeautify(Context & context, AngleUnit angleUnit) override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; + Expression * shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) override; Expression * setSign(Sign s); - Expression * setSign(Sign s, Context & context, AngleUnit angleUnit) override { + Expression * setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) override { return setSign(s); } diff --git a/poincare/include/poincare/real_part.h b/poincare/include/poincare/real_part.h index 65d9f9f53..816410eed 100644 --- a/poincare/include/poincare/real_part.h +++ b/poincare/include/poincare/real_part.h @@ -14,21 +14,21 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "re"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/right_parenthesis_layout_node.h b/poincare/include/poincare/right_parenthesis_layout_node.h index 0e0ac7b40..a527a2d50 100644 --- a/poincare/include/poincare/right_parenthesis_layout_node.h +++ b/poincare/include/poincare/right_parenthesis_layout_node.h @@ -19,7 +19,7 @@ public: bool isRightParenthesis() const override { return true; } // SerializableNode - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writeOneCharInBuffer(buffer, bufferSize, ')'); } diff --git a/poincare/include/poincare/right_square_bracket_layout_node.h b/poincare/include/poincare/right_square_bracket_layout_node.h index 91125e093..3fa900260 100644 --- a/poincare/include/poincare/right_square_bracket_layout_node.h +++ b/poincare/include/poincare/right_square_bracket_layout_node.h @@ -9,7 +9,7 @@ namespace Poincare { class RightSquareBracketLayoutNode : public SquareBracketLayoutNode { public: using SquareBracketLayoutNode::SquareBracketLayoutNode; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writeOneCharInBuffer(buffer, bufferSize, ']'); } bool isRightBracket() const override { return true; } diff --git a/poincare/include/poincare/round.h b/poincare/include/poincare/round.h index 5cc5b7e8c..10e590028 100644 --- a/poincare/include/poincare/round.h +++ b/poincare/include/poincare/round.h @@ -14,19 +14,19 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "round"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Complex */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/sequence.h b/poincare/include/poincare/sequence.h index 87c9eeead..d56f0fdb4 100644 --- a/poincare/include/poincare/sequence.h +++ b/poincare/include/poincare/sequence.h @@ -10,16 +10,16 @@ namespace Poincare { class Sequence : public StaticHierarchy<3> { using StaticHierarchy<3>::StaticHierarchy; private: - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } virtual LayoutRef createSequenceLayout(LayoutRef subscriptLayout, LayoutRef superscriptLayout, LayoutRef argumentLayout) const = 0; virtual const char * name() const = 0; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; virtual int emptySequenceValue() const = 0; virtual Evaluation * evaluateWithNextTerm(SinglePrecision p, Evaluation * a, Evaluation * b) const = 0; virtual Evaluation * evaluateWithNextTerm(DoublePrecision p, Evaluation * a, Evaluation * b) const = 0; diff --git a/poincare/include/poincare/sequence_layout_node.h b/poincare/include/poincare/sequence_layout_node.h index 73700e8d2..384d63e1d 100644 --- a/poincare/include/poincare/sequence_layout_node.h +++ b/poincare/include/poincare/sequence_layout_node.h @@ -48,7 +48,7 @@ protected: void computeBaseline() override; KDPoint positionOfChild(LayoutNode * child) override; - int writeDerivedClassInBuffer(const char * operatorName, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const; + int writeDerivedClassInBuffer(const char * operatorName, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const; LayoutNode * argumentLayout() { assert(numberOfChildren() == 3); return childAtIndex(0); diff --git a/poincare/include/poincare/serializable_node.h b/poincare/include/poincare/serializable_node.h index 622185e8c..1949bf89c 100644 --- a/poincare/include/poincare/serializable_node.h +++ b/poincare/include/poincare/serializable_node.h @@ -2,7 +2,7 @@ #define POINCARE_SERIALIZABLE_NODE_H #include -#include +#include namespace Poincare { @@ -10,7 +10,7 @@ class SerializableNode : public TreeNode { public: using TreeNode::TreeNode; virtual bool needsParenthesisWithParent(SerializableNode * parentNode) { return false; } //TODO - virtual int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode = PrintFloat::Mode::Decimal, int numberOfSignificantDigits = 0) const = 0; + virtual int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode = Preferences::PrintFloatMode::Decimal, int numberOfSignificantDigits = 0) const = 0; }; diff --git a/poincare/include/poincare/serializable_reference.h b/poincare/include/poincare/serializable_reference.h index f402912a1..26d32cf9f 100644 --- a/poincare/include/poincare/serializable_reference.h +++ b/poincare/include/poincare/serializable_reference.h @@ -1,8 +1,9 @@ #ifndef POINCARE_SERIALIZABLE_REFERENCE_H #define POINCARE_SERIALIZABLE_REFERENCE_H -#include +#include #include +#include namespace Poincare { @@ -16,7 +17,7 @@ public: assert(isDefined()); return node()->needsParenthesisWithParent(parentRef.node()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode = PrintFloat::Mode::Decimal, int numberOfSignificantDigits = 0) const { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode = Preferences::PrintFloatMode::Decimal, int numberOfSignificantDigits = 0) const { assert(isDefined()); return node()->writeTextInBuffer(buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits); } diff --git a/poincare/include/poincare/simplification_engine.h b/poincare/include/poincare/simplification_engine.h index 95d22c72d..06cef62c2 100644 --- a/poincare/include/poincare/simplification_engine.h +++ b/poincare/include/poincare/simplification_engine.h @@ -9,7 +9,7 @@ namespace Poincare { class SimplificationEngine { public: - static Expression * map(Expression * e, Context & context, Expression::AngleUnit angleUnit); + static Expression * map(Expression * e, Context & context, Preferences::AngleUnit angleUnit); }; diff --git a/poincare/include/poincare/simplification_root.h b/poincare/include/poincare/simplification_root.h index 5b7416d45..be3afa7fb 100644 --- a/poincare/include/poincare/simplification_root.h +++ b/poincare/include/poincare/simplification_root.h @@ -20,20 +20,20 @@ public: Expression * clone() const override { return nullptr; } int polynomialDegree(char symbolName) const override { return -1; } Type type() const override { return Expression::Type::SimplificationRoot; } - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return nullptr; } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { return 0; } - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return 0; } + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { assert(false); return nullptr; } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { assert(false); return nullptr; } private: - Expression * shallowReduce(Context & context, AngleUnit angleUnit) override { return this; } + Expression * shallowReduce(Context & context, Preferences::AngleUnit angleUnit) override { return this; } }; } diff --git a/poincare/include/poincare/sine.h b/poincare/include/poincare/sine.h index 90ddd95bf..bc15c8760 100644 --- a/poincare/include/poincare/sine.h +++ b/poincare/include/poincare/sine.h @@ -11,27 +11,27 @@ namespace Poincare { class Sine : public StaticHierarchy<1> { using StaticHierarchy<1>::StaticHierarchy; friend class Tangent; - float characteristicXRange(Context & context, AngleUnit angleUnit) const override; + float characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const override; public: Type type() const override; Expression * clone() const override; - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit = AngleUnit::Radian); + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Radian); private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "sin"; } /* Simplication */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/square_root.h b/poincare/include/poincare/square_root.h index fd997a2b6..5f378738d 100644 --- a/poincare/include/poincare/square_root.h +++ b/poincare/include/poincare/square_root.h @@ -14,16 +14,16 @@ public: Expression * clone() const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } diff --git a/poincare/include/poincare/store.h b/poincare/include/poincare/store.h index f82c4f17d..b09c666f7 100644 --- a/poincare/include/poincare/store.h +++ b/poincare/include/poincare/store.h @@ -17,14 +17,14 @@ public: int polynomialDegree(char symbolName) const override; private: /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Evalutation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; const Symbol * symbol() const { return static_cast(operand(1)); } const Expression * value() const { return operand(0); } diff --git a/poincare/include/poincare/subtraction.h b/poincare/include/poincare/subtraction.h index bc08efa4c..bd495792e 100644 --- a/poincare/include/poincare/subtraction.h +++ b/poincare/include/poincare/subtraction.h @@ -17,15 +17,15 @@ public: private: /* Layout */ bool needParenthesisWithParent(const Expression * e) const override; - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createInfixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writeInfixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } static const char * name() { return "-"; } /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ template static MatrixComplex computeOnMatrixAndComplex(const MatrixComplex m, const std::complex c) { return ApproximationEngine::elementWiseOnMatrixComplexAndComplex(m, c, compute); @@ -35,10 +35,10 @@ private: return ApproximationEngine::elementWiseOnComplexMatrices(m, n, compute); } - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::mapReduce(this, context, angleUnit, compute, computeOnComplexAndMatrix, computeOnMatrixAndComplex, computeOnMatrices); } }; diff --git a/poincare/include/poincare/sum_layout_node.h b/poincare/include/poincare/sum_layout_node.h index ce32e4153..e042a14b9 100644 --- a/poincare/include/poincare/sum_layout_node.h +++ b/poincare/include/poincare/sum_layout_node.h @@ -9,7 +9,7 @@ namespace Poincare { class SumLayoutNode : public SequenceLayoutNode { public: using SequenceLayoutNode::SequenceLayoutNode; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; private: void render(KDContext * ctx, KDPoint p, KDColor expressionColor, KDColor backgroundColor) override; }; diff --git a/poincare/include/poincare/symbol.h b/poincare/include/poincare/symbol.h index 51371cbd7..61148a04a 100644 --- a/poincare/include/poincare/symbol.h +++ b/poincare/include/poincare/symbol.h @@ -57,23 +57,23 @@ public: static bool isSeriesSymbol(char c); static bool isRegressionSymbol(char c); bool isApproximate(Context & context) const; - float characteristicXRange(Context & context, AngleUnit angleUnit) const override; + float characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const override; bool hasAnExactRepresentation(Context & context) const; static const char * textForSpecialSymbols(char name); int getVariables(isVariableTest isVariable, char * variables) const override; private: Expression * replaceSymbolWithExpression(char symbol, Expression * expression) override; /* Simplification */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Comparison */ int simplificationOrderSameType(const Expression * e, bool canBeInterrupted) const override; /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Evaluation * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Evaluation * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; const char m_name; }; diff --git a/poincare/include/poincare/tangent.h b/poincare/include/poincare/tangent.h index 6d03b9026..4e666cb2f 100644 --- a/poincare/include/poincare/tangent.h +++ b/poincare/include/poincare/tangent.h @@ -13,24 +13,24 @@ class Tangent : public StaticHierarchy<1> { public: Type type() const override; Expression * clone() const override; - float characteristicXRange(Context & context, AngleUnit angleUnit) const override; + float characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, name()); } - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override { + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, name()); } const char * name() const { return "tan"; } /* Simplication */ - Expression * shallowReduce(Context& context, AngleUnit angleUnit) override; + Expression * shallowReduce(Context& context, Preferences::AngleUnit angleUnit) override; /* Evaluation */ - template static std::complex computeOnComplex(const std::complex c, AngleUnit angleUnit = AngleUnit::Radian); - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { + template static std::complex computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Radian); + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit,computeOnComplex); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } }; diff --git a/poincare/include/poincare/trigonometry.h b/poincare/include/poincare/trigonometry.h index d49511178..9d7c2770b 100644 --- a/poincare/include/poincare/trigonometry.h +++ b/poincare/include/poincare/trigonometry.h @@ -12,14 +12,14 @@ public: Cosine = 0, Sine = 1, }; - static float characteristicXRange(const Expression * e, Context & context, Expression::AngleUnit angleUnit); - static Expression * shallowReduceDirectFunction(Expression * e, Context& context, Expression::AngleUnit angleUnit); - static Expression * shallowReduceInverseFunction(Expression * e, Context& context, Expression::AngleUnit angleUnit); + static float characteristicXRange(const Expression * e, Context & context, Preferences::AngleUnit angleUnit); + static Expression * shallowReduceDirectFunction(Expression * e, Context& context, Preferences::AngleUnit angleUnit); + static Expression * shallowReduceInverseFunction(Expression * e, Context& context, Preferences::AngleUnit angleUnit); static bool ExpressionIsEquivalentToTangent(const Expression * e); constexpr static int k_numberOfEntries = 37; - static Expression * table(const Expression * e, Expression::Type type, Context & context, Expression::AngleUnit angleUnit); // , Function f, bool inverse - template static std::complex ConvertToRadian(const std::complex c, Expression::AngleUnit angleUnit); - template static std::complex ConvertRadianToAngleUnit(const std::complex c, Expression::AngleUnit angleUnit); + static Expression * table(const Expression * e, Expression::Type type, Context & context, Preferences::AngleUnit angleUnit); // , Function f, bool inverse + template static std::complex ConvertToRadian(const std::complex c, Preferences::AngleUnit angleUnit); + template static std::complex ConvertRadianToAngleUnit(const std::complex c, Preferences::AngleUnit angleUnit); template static std::complex RoundToMeaningfulDigits(const std::complex c); private: template static T RoundToMeaningfulDigits(T f); diff --git a/poincare/include/poincare/undefined.h b/poincare/include/poincare/undefined.h index 786472193..21ee58438 100644 --- a/poincare/include/poincare/undefined.h +++ b/poincare/include/poincare/undefined.h @@ -10,15 +10,15 @@ class Undefined : public StaticHierarchy<0> { public: Type type() const override; Expression * clone() const override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; int polynomialDegree(char symbolName) const override; private: /* Layout */ - LayoutRef createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + LayoutRef createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Evaluation */ - Evaluation * privateApproximate(SinglePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - Evaluation * privateApproximate(DoublePrecision p, Context& context, AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } - template Complex * templatedApproximate(Context& context, AngleUnit angleUnit) const; + Evaluation * privateApproximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + Evaluation * privateApproximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } + template Complex * templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const; }; } diff --git a/poincare/include/poincare/vertical_offset_layout_node.h b/poincare/include/poincare/vertical_offset_layout_node.h index 411322ce1..9313641f7 100644 --- a/poincare/include/poincare/vertical_offset_layout_node.h +++ b/poincare/include/poincare/vertical_offset_layout_node.h @@ -29,7 +29,7 @@ public: void moveCursorUp(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void moveCursorDown(LayoutCursor * cursor, bool * shouldRecomputeLayout, bool equivalentPositionVisited = false) override; void deleteBeforeCursor(LayoutCursor * cursor) override; - int writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const override; + int writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; bool mustHaveLeftSibling() const override { return true; } bool isVerticalOffset() const override { return true; } diff --git a/poincare/src/absolute_value.cpp b/poincare/src/absolute_value.cpp index cd2772d1c..25f252b43 100644 --- a/poincare/src/absolute_value.cpp +++ b/poincare/src/absolute_value.cpp @@ -18,16 +18,16 @@ Expression * AbsoluteValue::clone() const { return a; } -Expression * AbsoluteValue::setSign(Sign s, Context & context, AngleUnit angleUnit) { +Expression * AbsoluteValue::setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) { assert(s == Sign::Positive); return this; } -LayoutRef AbsoluteValue::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef AbsoluteValue::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return AbsoluteValueLayoutRef(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits)); } -Expression * AbsoluteValue::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * AbsoluteValue::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -49,7 +49,7 @@ Expression * AbsoluteValue::shallowReduce(Context& context, AngleUnit angleUnit) } template -std::complex AbsoluteValue::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex AbsoluteValue::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { return std::abs(c); } diff --git a/poincare/src/addition.cpp b/poincare/src/addition.cpp index 3b12e9675..048d850c4 100644 --- a/poincare/src/addition.cpp +++ b/poincare/src/addition.cpp @@ -63,7 +63,7 @@ bool Addition::needParenthesisWithParent(const Expression * e) const { /* Simplication */ -Expression * Addition::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Addition::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -180,7 +180,7 @@ Expression * Addition::shallowReduce(Context& context, AngleUnit angleUnit) { return result; } -Expression * Addition::factorizeOnCommonDenominator(Context & context, AngleUnit angleUnit) { +Expression * Addition::factorizeOnCommonDenominator(Context & context, Preferences::AngleUnit angleUnit) { // We want to turn (a/b+c/d+e/b) into (a*d+b*c+e*d)/(b*d) // Step 1: We want to compute the common denominator, b*d @@ -223,7 +223,7 @@ Expression * Addition::factorizeOnCommonDenominator(Context & context, AngleUnit return static_cast(replaceWith(result, true))->privateShallowReduce(context, angleUnit, false, true); } -void Addition::factorizeOperands(Expression * e1, Expression * e2, Context & context, AngleUnit angleUnit) { +void Addition::factorizeOperands(Expression * e1, Expression * e2, Context & context, Preferences::AngleUnit angleUnit) { /* This function factorizes two operands which only differ by a rational * factor. For example, if this is Addition(2*pi, 3*pi), then 2*pi and 3*pi * could be merged, and this turned into Addition(5*pi). */ @@ -302,7 +302,7 @@ bool Addition::TermsHaveIdenticalNonRationalFactors(const Expression * e1, const } } -Expression * Addition::shallowBeautify(Context & context, AngleUnit angleUnit) { +Expression * Addition::shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) { /* Beautifying Addition essentially consists in adding Subtractions if needed. * In practice, we want to turn "a+(-1)*b" into "a-b". Or, more precisely, any * "a+(-r)*b" into "a-r*b" where r is a positive Rational. diff --git a/poincare/src/approximation_engine.cpp b/poincare/src/approximation_engine.cpp index c637c49ad..dc7a9395e 100644 --- a/poincare/src/approximation_engine.cpp +++ b/poincare/src/approximation_engine.cpp @@ -25,7 +25,7 @@ template std::complex ApproximationEngine::truncateRealOrImagina return c; } -template Evaluation * ApproximationEngine::map(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexCompute compute) { +template Evaluation * ApproximationEngine::map(const Expression * expression, Context& context, Preferences::AngleUnit angleUnit, ComplexCompute compute) { assert(expression->numberOfOperands() == 1); Evaluation * input = expression->operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * result = nullptr; @@ -47,7 +47,7 @@ template Evaluation * ApproximationEngine::map(const Expression * return result; } -template Evaluation * ApproximationEngine::mapReduce(const Expression * expression, Context& context, Expression::AngleUnit angleUnit, ComplexAndComplexReduction computeOnComplexes, ComplexAndMatrixReduction computeOnComplexAndMatrix, MatrixAndComplexReduction computeOnMatrixAndComplex, MatrixAndMatrixReduction computeOnMatrices) { +template Evaluation * ApproximationEngine::mapReduce(const Expression * expression, Context& context, Preferences::AngleUnit angleUnit, ComplexAndComplexReduction computeOnComplexes, ComplexAndMatrixReduction computeOnComplexAndMatrix, MatrixAndComplexReduction computeOnMatrixAndComplex, MatrixAndMatrixReduction computeOnMatrices) { Evaluation * result = expression->operand(0)->privateApproximate(T(), context, angleUnit); for (int i = 1; i < expression->numberOfOperands(); i++) { Evaluation * intermediateResult = nullptr; @@ -112,10 +112,10 @@ template MatrixComplex ApproximationEngine::elementWiseOnComplexM template std::complex Poincare::ApproximationEngine::truncateRealOrImaginaryPartAccordingToArgument(std::complex); template std::complex Poincare::ApproximationEngine::truncateRealOrImaginaryPartAccordingToArgument(std::complex); -template Poincare::Evaluation * Poincare::ApproximationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexCompute compute); -template Poincare::Evaluation * Poincare::ApproximationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexCompute compute); -template Poincare::Evaluation * Poincare::ApproximationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexAndComplexReduction computeOnComplexes, Poincare::ApproximationEngine::ComplexAndMatrixReduction computeOnComplexAndMatrix, Poincare::ApproximationEngine::MatrixAndComplexReduction computeOnMatrixAndComplex, Poincare::ApproximationEngine::MatrixAndMatrixReduction computeOnMatrices); -template Poincare::Evaluation * Poincare::ApproximationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Expression::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexAndComplexReduction computeOnComplexes, Poincare::ApproximationEngine::ComplexAndMatrixReduction computeOnComplexAndMatrix, Poincare::ApproximationEngine::MatrixAndComplexReduction computeOnMatrixAndComplex, Poincare::ApproximationEngine::MatrixAndMatrixReduction computeOnMatrices); +template Poincare::Evaluation * Poincare::ApproximationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexCompute compute); +template Poincare::Evaluation * Poincare::ApproximationEngine::map(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexCompute compute); +template Poincare::Evaluation * Poincare::ApproximationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexAndComplexReduction computeOnComplexes, Poincare::ApproximationEngine::ComplexAndMatrixReduction computeOnComplexAndMatrix, Poincare::ApproximationEngine::MatrixAndComplexReduction computeOnMatrixAndComplex, Poincare::ApproximationEngine::MatrixAndMatrixReduction computeOnMatrices); +template Poincare::Evaluation * Poincare::ApproximationEngine::mapReduce(const Poincare::Expression * expression, Poincare::Context& context, Poincare::Preferences::AngleUnit angleUnit, Poincare::ApproximationEngine::ComplexAndComplexReduction computeOnComplexes, Poincare::ApproximationEngine::ComplexAndMatrixReduction computeOnComplexAndMatrix, Poincare::ApproximationEngine::MatrixAndComplexReduction computeOnMatrixAndComplex, Poincare::ApproximationEngine::MatrixAndMatrixReduction computeOnMatrices); template Poincare::MatrixComplex Poincare::ApproximationEngine::elementWiseOnMatrixComplexAndComplex(const Poincare::MatrixComplex, const std::complex, std::complex (*)(std::complex, std::complex)); template Poincare::MatrixComplex Poincare::ApproximationEngine::elementWiseOnMatrixComplexAndComplex(const Poincare::MatrixComplex, std::complex const, std::complex (*)(std::complex, std::complex)); template Poincare::MatrixComplex Poincare::ApproximationEngine::elementWiseOnComplexMatrices(const Poincare::MatrixComplex, const Poincare::MatrixComplex, std::complex (*)(std::complex, std::complex)); diff --git a/poincare/src/arc_cosine.cpp b/poincare/src/arc_cosine.cpp index 914566918..245e5df4b 100644 --- a/poincare/src/arc_cosine.cpp +++ b/poincare/src/arc_cosine.cpp @@ -17,7 +17,7 @@ Expression * ArcCosine::clone() const { return a; } -Expression * ArcCosine::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * ArcCosine::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -31,7 +31,7 @@ Expression * ArcCosine::shallowReduce(Context& context, AngleUnit angleUnit) { } template -std::complex ArcCosine::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex ArcCosine::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex result = std::acos(c); /* acos has a branch cut on ]-inf, -1[U]1, +inf[: it is then multivalued on * this cut. We followed the convention chosen by the lib c++ of llvm on diff --git a/poincare/src/arc_sine.cpp b/poincare/src/arc_sine.cpp index 9be40472f..46dc7b648 100644 --- a/poincare/src/arc_sine.cpp +++ b/poincare/src/arc_sine.cpp @@ -17,7 +17,7 @@ Expression * ArcSine::clone() const { return a; } -Expression * ArcSine::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * ArcSine::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -31,7 +31,7 @@ Expression * ArcSine::shallowReduce(Context& context, AngleUnit angleUnit) { } template -std::complex ArcSine::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex ArcSine::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex result = std::asin(c); /* asin has a branch cut on ]-inf, -1[U]1, +inf[: it is then multivalued on * this cut. We followed the convention chosen by the lib c++ of llvm on diff --git a/poincare/src/arc_tangent.cpp b/poincare/src/arc_tangent.cpp index d420b6837..ea6301ab9 100644 --- a/poincare/src/arc_tangent.cpp +++ b/poincare/src/arc_tangent.cpp @@ -17,7 +17,7 @@ Expression * ArcTangent::clone() const { return a; } -Expression * ArcTangent::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * ArcTangent::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -31,7 +31,7 @@ Expression * ArcTangent::shallowReduce(Context& context, AngleUnit angleUnit) { } template -std::complex ArcTangent::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex ArcTangent::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex result = std::atan(c); /* atan has a branch cut on ]-inf*i, -i[U]i, +inf*i[: it is then multivalued * on this cut. We followed the convention chosen by the lib c++ of llvm on diff --git a/poincare/src/binomial_coefficient.cpp b/poincare/src/binomial_coefficient.cpp index a10f0e317..8b43ca27e 100644 --- a/poincare/src/binomial_coefficient.cpp +++ b/poincare/src/binomial_coefficient.cpp @@ -20,7 +20,7 @@ Expression * BinomialCoefficient::clone() const { return b; } -Expression * BinomialCoefficient::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * BinomialCoefficient::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -71,14 +71,14 @@ Expression * BinomialCoefficient::shallowReduce(Context& context, AngleUnit angl return replaceWith(new Rational(result), true); } -LayoutRef BinomialCoefficient::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef BinomialCoefficient::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return BinomialCoefficientLayoutRef( operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits), operand(1)->createLayout(floatDisplayMode, numberOfSignificantDigits)); } template -Complex * BinomialCoefficient::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Complex * BinomialCoefficient::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * nInput = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * kInput = operand(1)->privateApproximate(T(), context, angleUnit); T n = nInput->toScalar(); diff --git a/poincare/src/binomial_coefficient_layout_node.cpp b/poincare/src/binomial_coefficient_layout_node.cpp index 80e0e451f..6bc9252e6 100644 --- a/poincare/src/binomial_coefficient_layout_node.cpp +++ b/poincare/src/binomial_coefficient_layout_node.cpp @@ -74,7 +74,7 @@ void BinomialCoefficientLayoutNode::moveCursorDown(LayoutCursor * cursor, bool * LayoutNode::moveCursorDown(cursor, shouldRecomputeLayout, equivalentPositionVisited); } -int BinomialCoefficientLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int BinomialCoefficientLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return LayoutEngine::writePrefixSerializableRefTextInBuffer(SerializableRef(const_cast(this)), buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "binomial"); } diff --git a/poincare/src/bracket_pair_layout_node.cpp b/poincare/src/bracket_pair_layout_node.cpp index d22304d87..0f8976c20 100644 --- a/poincare/src/bracket_pair_layout_node.cpp +++ b/poincare/src/bracket_pair_layout_node.cpp @@ -88,7 +88,7 @@ void BracketPairLayoutNode::didCollapseSiblings(LayoutCursor * cursor) { } } -int BracketPairLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int BracketPairLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } diff --git a/poincare/src/ceiling.cpp b/poincare/src/ceiling.cpp index 69177d87c..8623da6c4 100644 --- a/poincare/src/ceiling.cpp +++ b/poincare/src/ceiling.cpp @@ -20,7 +20,7 @@ Expression * Ceiling::clone() const { return c; } -Expression * Ceiling::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Ceiling::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -52,14 +52,14 @@ Expression * Ceiling::shallowReduce(Context& context, AngleUnit angleUnit) { } template -std::complex Ceiling::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex Ceiling::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { if (c.imag() != 0) { return Complex::Undefined(); } return std::ceil(c.real()); } -LayoutRef Ceiling::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Ceiling::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return CeilingLayoutRef(m_operands[0]->createLayout(floatDisplayMode, numberOfSignificantDigits)); } diff --git a/poincare/src/char_layout_node.cpp b/poincare/src/char_layout_node.cpp index 434be4717..d3d1dc23d 100644 --- a/poincare/src/char_layout_node.cpp +++ b/poincare/src/char_layout_node.cpp @@ -27,7 +27,7 @@ void CharLayoutNode::moveCursorRight(LayoutCursor * cursor, bool * shouldRecompu } } -int CharLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int CharLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return LayoutEngine::writeOneCharInBuffer(buffer, bufferSize, m_char); } diff --git a/poincare/src/complex_argument.cpp b/poincare/src/complex_argument.cpp index 3c3eec2f7..89afb8044 100644 --- a/poincare/src/complex_argument.cpp +++ b/poincare/src/complex_argument.cpp @@ -16,7 +16,7 @@ Expression * ComplexArgument::clone() const { return a; } -Expression * ComplexArgument::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * ComplexArgument::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -31,7 +31,7 @@ Expression * ComplexArgument::shallowReduce(Context& context, AngleUnit angleUni } template -std::complex ComplexArgument::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex ComplexArgument::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { return Complex(std::arg(c)); } diff --git a/poincare/src/confidence_interval.cpp b/poincare/src/confidence_interval.cpp index d97afff41..4c4d0156a 100644 --- a/poincare/src/confidence_interval.cpp +++ b/poincare/src/confidence_interval.cpp @@ -24,7 +24,7 @@ int ConfidenceInterval::polynomialDegree(char symbolName) const { return -1; } -Expression * ConfidenceInterval::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * ConfidenceInterval::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -62,7 +62,7 @@ Expression * ConfidenceInterval::shallowReduce(Context& context, AngleUnit angle } template -Evaluation * ConfidenceInterval::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * ConfidenceInterval::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * fInput = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * nInput = operand(1)->privateApproximate(T(), context, angleUnit); T f = static_cast *>(fInput)->toScalar(); diff --git a/poincare/src/conjugate.cpp b/poincare/src/conjugate.cpp index 974151069..30cc6b9e6 100644 --- a/poincare/src/conjugate.cpp +++ b/poincare/src/conjugate.cpp @@ -15,11 +15,11 @@ Expression * Conjugate::clone() const { return a; } -LayoutRef Conjugate::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Conjugate::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return ConjugateLayoutRef(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits)); } -Expression * Conjugate::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Conjugate::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -37,7 +37,7 @@ Expression * Conjugate::shallowReduce(Context& context, AngleUnit angleUnit) { } template -std::complex Conjugate::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex Conjugate::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { return std::conj(c); } diff --git a/poincare/src/conjugate_layout_node.cpp b/poincare/src/conjugate_layout_node.cpp index 147e848c3..613d5b508 100644 --- a/poincare/src/conjugate_layout_node.cpp +++ b/poincare/src/conjugate_layout_node.cpp @@ -53,7 +53,7 @@ void ConjugateLayoutNode::moveCursorRight(LayoutCursor * cursor, bool * shouldRe } } -int ConjugateLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int ConjugateLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return LayoutEngine::writePrefixSerializableRefTextInBuffer(SerializableRef(const_cast(this)), buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "conj"); } diff --git a/poincare/src/cosine.cpp b/poincare/src/cosine.cpp index c9fb03d8a..94a746f02 100644 --- a/poincare/src/cosine.cpp +++ b/poincare/src/cosine.cpp @@ -21,18 +21,18 @@ Expression * Cosine::clone() const { return a; } -float Cosine::characteristicXRange(Context & context, AngleUnit angleUnit) const { +float Cosine::characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const { return Trigonometry::characteristicXRange(this, context, angleUnit); } template -std::complex Cosine::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex Cosine::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex angleInput = Trigonometry::ConvertToRadian(c, angleUnit); std::complex res = std::cos(angleInput); return Trigonometry::RoundToMeaningfulDigits(res); } -Expression * Cosine::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Cosine::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; diff --git a/poincare/src/decimal.cpp b/poincare/src/decimal.cpp index 1f76b89a2..94cd4907d 100644 --- a/poincare/src/decimal.cpp +++ b/poincare/src/decimal.cpp @@ -87,13 +87,13 @@ Expression * Decimal::clone() const { return new Decimal(m_mantissa, m_exponent); } -template Evaluation * Decimal::templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const { +template Evaluation * Decimal::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { T m = m_mantissa.approximate(); int numberOfDigits = Integer::numberOfDigitsWithoutSign(m_mantissa); return new Complex(m*std::pow((T)10.0, (T)(m_exponent-numberOfDigits+1))); } -int Decimal::convertToText(char * buffer, int bufferSize, PrintFloat::Mode mode, int numberOfSignificantDigits) const { +int Decimal::convertToText(char * buffer, int bufferSize, Preferences::PrintFloatMode mode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } @@ -132,7 +132,7 @@ int Decimal::convertToText(char * buffer, int bufferSize, PrintFloat::Mode mode, /* We force scientific mode if the number of digits before the dot is superior * to the number of significant digits (ie with 4 significant digits, * 12345 -> 1.235E4 or 12340 -> 1.234E4). */ - bool forceScientificMode = mode == PrintFloat::Mode::Scientific || exponent >= numberOfSignificantDigits; + bool forceScientificMode = mode == Preferences::PrintFloatMode::Scientific || exponent >= numberOfSignificantDigits; int numberOfRequiredDigits = mantissaLength; if (!forceScientificMode) { numberOfRequiredDigits = mantissaLength > exponent ? mantissaLength : exponent; @@ -203,7 +203,7 @@ int Decimal::convertToText(char * buffer, int bufferSize, PrintFloat::Mode mode, return currentChar; } -int Decimal::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int Decimal::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return convertToText(buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits); } @@ -215,13 +215,13 @@ bool Decimal::needParenthesisWithParent(const Expression * e) const { return e->isOfType(types, 7); } -LayoutRef Decimal::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Decimal::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { char buffer[k_maxBufferSize]; int numberOfChars = convertToText(buffer, k_maxBufferSize, floatDisplayMode, numberOfSignificantDigits); return LayoutEngine::createStringLayout(buffer, numberOfChars); } -Expression * Decimal::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Decimal::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -242,7 +242,7 @@ Expression * Decimal::shallowReduce(Context& context, AngleUnit angleUnit) { return replaceWith(new Rational(numerator, denominator), true); } -Expression * Decimal::shallowBeautify(Context & context, AngleUnit angleUnit) { +Expression * Decimal::shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) { if (m_mantissa.isNegative()) { m_mantissa.setNegative(false); Opposite * o = new Opposite(this, true); diff --git a/poincare/src/derivative.cpp b/poincare/src/derivative.cpp index a22217360..1533acd2c 100644 --- a/poincare/src/derivative.cpp +++ b/poincare/src/derivative.cpp @@ -29,7 +29,7 @@ int Derivative::polynomialDegree(char symbolName) const { return Expression::polynomialDegree(symbolName); } -Expression * Derivative::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Derivative::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -44,7 +44,7 @@ Expression * Derivative::shallowReduce(Context& context, AngleUnit angleUnit) { } template -Complex * Derivative::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Complex * Derivative::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { static T min = sizeof(T) == sizeof(double) ? DBL_MIN : FLT_MIN; static T epsilon = sizeof(T) == sizeof(double) ? DBL_EPSILON : FLT_EPSILON; Evaluation * xInput = operand(1)->privateApproximate(T(), context, angleUnit); @@ -75,14 +75,14 @@ Complex * Derivative::templatedApproximate(Context& context, AngleUnit angleU } template -T Derivative::growthRateAroundAbscissa(T x, T h, Context & context, AngleUnit angleUnit) const { +T Derivative::growthRateAroundAbscissa(T x, T h, Context & context, Preferences::AngleUnit angleUnit) const { T expressionPlus = operand(0)->approximateWithValueForSymbol('x', x+h, context, angleUnit); T expressionMinus = operand(0)->approximateWithValueForSymbol('x', x-h, context, angleUnit); return (expressionPlus - expressionMinus)/(2*h); } template -T Derivative::riddersApproximation(Context & context, AngleUnit angleUnit, T x, T h, T * error) const { +T Derivative::riddersApproximation(Context & context, Preferences::AngleUnit angleUnit, T x, T h, T * error) const { /* Ridders' Algorithm * Blibliography: * - Ridders, C.J.F. 1982, Advances in Engineering Software, vol. 4, no. 2, diff --git a/poincare/src/determinant.cpp b/poincare/src/determinant.cpp index 622565cb5..ce80046ac 100644 --- a/poincare/src/determinant.cpp +++ b/poincare/src/determinant.cpp @@ -16,7 +16,7 @@ Expression * Determinant::clone() const { return a; } -Expression * Determinant::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Determinant::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -34,7 +34,7 @@ Expression * Determinant::shallowReduce(Context& context, AngleUnit angleUnit) { // TODO: handle this exactly in shallowReduce for small dimensions. template -Evaluation * Determinant::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * Determinant::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * input = operand(0)->privateApproximate(T(), context, angleUnit); Complex * result = new Complex(input->createDeterminant()); delete input; diff --git a/poincare/src/division.cpp b/poincare/src/division.cpp index 8163ddefb..673db9427 100644 --- a/poincare/src/division.cpp +++ b/poincare/src/division.cpp @@ -34,7 +34,7 @@ bool Division::needParenthesisWithParent(const Expression * e) const { return e->isOfType(types, 3); } -Expression * Division::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Division::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -52,7 +52,7 @@ std::complex Division::compute(const std::complex c, const std::complex return c/d; } -LayoutRef Division::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Division::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return CharLayoutRef('a'); //TODO /* const Expression * numerator = operand(0)->type() == Type::Parenthesis ? operand(0)->operand(0) : operand(0); diff --git a/poincare/src/division_quotient.cpp b/poincare/src/division_quotient.cpp index b671c2bf1..f4ef0ada5 100644 --- a/poincare/src/division_quotient.cpp +++ b/poincare/src/division_quotient.cpp @@ -18,7 +18,7 @@ Expression * DivisionQuotient::clone() const { return a; } -Expression * DivisionQuotient::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * DivisionQuotient::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -58,7 +58,7 @@ Expression * DivisionQuotient::shallowReduce(Context& context, AngleUnit angleUn } template -Complex * DivisionQuotient::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Complex * DivisionQuotient::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * f1Input = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * f2Input = operand(1)->privateApproximate(T(), context, angleUnit); T f1 = f1Input->toScalar(); diff --git a/poincare/src/division_remainder.cpp b/poincare/src/division_remainder.cpp index 1aec5b1a8..38abb2a39 100644 --- a/poincare/src/division_remainder.cpp +++ b/poincare/src/division_remainder.cpp @@ -18,7 +18,7 @@ Expression * DivisionRemainder::clone() const { return a; } -Expression * DivisionRemainder::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * DivisionRemainder::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -58,7 +58,7 @@ Expression * DivisionRemainder::shallowReduce(Context& context, AngleUnit angleU } template -Complex * DivisionRemainder::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Complex * DivisionRemainder::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * f1Input = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * f2Input = operand(1)->privateApproximate(T(), context, angleUnit); T f1 = f1Input->toScalar(); diff --git a/poincare/src/empty_expression.cpp b/poincare/src/empty_expression.cpp index 8c2b96c3f..5c9fd4b80 100644 --- a/poincare/src/empty_expression.cpp +++ b/poincare/src/empty_expression.cpp @@ -10,15 +10,15 @@ Expression * EmptyExpression::clone() const { return new EmptyExpression(); } -int EmptyExpression::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int EmptyExpression::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return LayoutEngine::writeOneCharInBuffer(buffer, bufferSize, Ion::Charset::Empty); } -LayoutRef EmptyExpression::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef EmptyExpression::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return EmptyLayoutRef(); } -template Complex * EmptyExpression::templatedApproximate(Context& context, AngleUnit angleUnit) const { +template Complex * EmptyExpression::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { return new Complex(Complex::Undefined()); } diff --git a/poincare/src/empty_layout_node.cpp b/poincare/src/empty_layout_node.cpp index 8610ab7f6..a22e569e9 100644 --- a/poincare/src/empty_layout_node.cpp +++ b/poincare/src/empty_layout_node.cpp @@ -33,7 +33,7 @@ void EmptyLayoutNode::moveCursorRight(LayoutCursor * cursor, bool * shouldRecomp } } -int EmptyLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int EmptyLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } diff --git a/poincare/src/equal.cpp b/poincare/src/equal.cpp index 65a5ec014..b4abf61e5 100644 --- a/poincare/src/equal.cpp +++ b/poincare/src/equal.cpp @@ -32,13 +32,13 @@ int Equal::polynomialDegree(char symbolName) const { return -1; } -Expression * Equal::standardEquation(Context & context, AngleUnit angleUnit) const { +Expression * Equal::standardEquation(Context & context, Preferences::AngleUnit angleUnit) const { Expression * sub = new Subtraction(operand(0), operand(1), true); Reduce(&sub, context, angleUnit); return sub; } -Expression * Equal::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Equal::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -49,7 +49,7 @@ Expression * Equal::shallowReduce(Context& context, AngleUnit angleUnit) { return this; } -LayoutRef Equal::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Equal::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { HorizontalLayoutRef result; result.addOrMergeChildAtIndex(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits), 0, false); result.addChildAtIndex(CharLayoutRef('='), result.numberOfChildren(), nullptr); @@ -58,7 +58,7 @@ LayoutRef Equal::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSig } template -Evaluation * Equal::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * Equal::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { return new Complex(Complex::Undefined()); } diff --git a/poincare/src/evaluation.cpp b/poincare/src/evaluation.cpp index da74af9e7..55980bb0b 100644 --- a/poincare/src/evaluation.cpp +++ b/poincare/src/evaluation.cpp @@ -38,13 +38,13 @@ static Expression * CreateDecimal(T f) { } template -Expression * Complex::complexToExpression(Expression::ComplexFormat complexFormat) const { +Expression * Complex::complexToExpression(Preferences::ComplexFormat complexFormat) const { if (std::isnan(this->real()) || std::isnan(this->imag()) || std::isinf(this->real()) || std::isinf(this->imag())) { return new Poincare::Undefined(); } switch (complexFormat) { - case Expression::ComplexFormat::Cartesian: + case Preferences::ComplexFormat::Cartesian: { Expression * real = nullptr; Expression * imag = nullptr; @@ -77,7 +77,7 @@ Expression * Complex::complexToExpression(Expression::ComplexFormat complexFo } default: { - assert(complexFormat == Expression::ComplexFormat::Polar); + assert(complexFormat == Preferences::ComplexFormat::Polar); Expression * norm = nullptr; Expression * exp = nullptr; T r = std::abs(*this); @@ -172,7 +172,7 @@ MatrixComplex::MatrixComplex(std::complex * operands, int numberOfRows, in } template -Expression * MatrixComplex::complexToExpression(Expression::ComplexFormat complexFormat) const { +Expression * MatrixComplex::complexToExpression(Preferences::ComplexFormat complexFormat) const { Expression ** operands = new Expression * [numberOfComplexOperands()]; for (int i = 0; i < numberOfComplexOperands(); i++) { operands[i] = Complex(complexOperand(i)).complexToExpression(complexFormat); diff --git a/poincare/src/expression.cpp b/poincare/src/expression.cpp index 7d6d94bb3..82da8c317 100644 --- a/poincare/src/expression.cpp +++ b/poincare/src/expression.cpp @@ -182,7 +182,7 @@ bool Expression::isApproximate(Context & context) const { }, context); } -float Expression::characteristicXRange(Context & context, AngleUnit angleUnit) const { +float Expression::characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const { /* A expression has a characteristic range if at least one of its operand has * one and the other are x-independant. We keep the biggest interesting range * among the operand interesting ranges. */ @@ -227,7 +227,7 @@ bool dependsOnVariables(const Expression * e, Context & context) { return e->type() == Expression::Type::Symbol && Symbol::isVariableSymbol(static_cast(e)->name()); } -bool Expression::getLinearCoefficients(char * variables, Expression * coefficients[], Expression ** constant, Context & context, AngleUnit angleUnit) const { +bool Expression::getLinearCoefficients(char * variables, Expression * coefficients[], Expression ** constant, Context & context, Preferences::AngleUnit angleUnit) const { char * x = variables; while (*x != 0) { int degree = polynomialDegree(*x); @@ -277,7 +277,7 @@ bool Expression::getLinearCoefficients(char * variables, Expression * coefficien return true; } -int Expression::getPolynomialCoefficients(char symbolName, Expression * coefficients[], Context & context, AngleUnit angleUnit) const { +int Expression::getPolynomialCoefficients(char symbolName, Expression * coefficients[], Context & context, Preferences::AngleUnit angleUnit) const { int degree = privateGetPolynomialCoefficients(symbolName, coefficients); for (int i = 0; i <= degree; i++) { Reduce(&coefficients[i], context, angleUnit); @@ -325,7 +325,7 @@ int Expression::SimplificationOrder(const Expression * e1, const Expression * e2 } } -bool Expression::isEqualToItsApproximationLayout(Expression * approximation, int bufferSize, AngleUnit angleUnit, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits, Context & context) { +bool Expression::isEqualToItsApproximationLayout(Expression * approximation, int bufferSize, Preferences::AngleUnit angleUnit, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits, Context & context) { char buffer[bufferSize]; approximation->writeTextInBuffer(buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits); /* Warning: we cannot use directly the the approximate expression but we have @@ -342,7 +342,7 @@ bool Expression::isEqualToItsApproximationLayout(Expression * approximation, int /* Simplification */ -Expression * Expression::ParseAndSimplify(const char * text, Context & context, AngleUnit angleUnit) { +Expression * Expression::ParseAndSimplify(const char * text, Context & context, Preferences::AngleUnit angleUnit) { Expression * exp = parse(text); if (exp == nullptr) { return new Undefined(); @@ -354,7 +354,7 @@ Expression * Expression::ParseAndSimplify(const char * text, Context & context, return exp; } -void Expression::Simplify(Expression ** expressionAddress, Context & context, AngleUnit angleUnit) { +void Expression::Simplify(Expression ** expressionAddress, Context & context, Preferences::AngleUnit angleUnit) { sSimplificationHasBeenInterrupted = false; #if MATRIX_EXACT_REDUCING #else @@ -374,7 +374,7 @@ void Expression::Simplify(Expression ** expressionAddress, Context & context, An } -void Expression::Reduce(Expression ** expressionAddress, Context & context, AngleUnit angleUnit, bool recursively) { +void Expression::Reduce(Expression ** expressionAddress, Context & context, Preferences::AngleUnit angleUnit, bool recursively) { SimplificationRoot root(*expressionAddress); if (recursively) { root.editableOperand(0)->deepReduce(context, angleUnit); @@ -384,7 +384,7 @@ void Expression::Reduce(Expression ** expressionAddress, Context & context, Angl *expressionAddress = root.editableOperand(0); } -Expression * Expression::deepReduce(Context & context, AngleUnit angleUnit) { +Expression * Expression::deepReduce(Context & context, Preferences::AngleUnit angleUnit) { assert(parent() != nullptr); for (int i = 0; i < numberOfOperands(); i++) { editableOperand(i)->deepReduce(context, angleUnit); @@ -392,7 +392,7 @@ Expression * Expression::deepReduce(Context & context, AngleUnit angleUnit) { return shallowReduce(context, angleUnit); } -Expression * Expression::shallowReduce(Context & context, AngleUnit angleUnit) { +Expression * Expression::shallowReduce(Context & context, Preferences::AngleUnit angleUnit) { for (int i = 0; i < numberOfOperands(); i++) { if (editableOperand(i)->type() == Type::Undefined && this->type() != Type::SimplificationRoot) { return replaceWith(new Undefined(), true); @@ -401,7 +401,7 @@ Expression * Expression::shallowReduce(Context & context, AngleUnit angleUnit) { return this; } -Expression * Expression::deepBeautify(Context & context, AngleUnit angleUnit) { +Expression * Expression::deepBeautify(Context & context, Preferences::AngleUnit angleUnit) { assert(parent() != nullptr); Expression * e = shallowBeautify(context, angleUnit); for (int i = 0; i < e->numberOfOperands(); i++) { @@ -412,14 +412,14 @@ Expression * Expression::deepBeautify(Context & context, AngleUnit angleUnit) { /* Evaluation */ -template Expression * Expression::approximate(Context& context, AngleUnit angleUnit, ComplexFormat complexFormat) const { +template Expression * Expression::approximate(Context& context, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat) const { Evaluation * e = privateApproximate(T(), context, angleUnit); Expression * result = e->complexToExpression(complexFormat); delete e; return result; } -template T Expression::approximateToScalar(Context& context, AngleUnit angleUnit) const { +template T Expression::approximateToScalar(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * evaluation = privateApproximate(T(), context, angleUnit); T result = evaluation->toScalar(); /*if (evaluation->type() == Type::Matrix) { @@ -431,7 +431,7 @@ template T Expression::approximateToScalar(Context& context, AngleUn return result; } -template T Expression::approximateToScalar(const char * text, Context& context, AngleUnit angleUnit) { +template T Expression::approximateToScalar(const char * text, Context& context, Preferences::AngleUnit angleUnit) { Expression * exp = ParseAndSimplify(text, context, angleUnit); T result = exp->approximateToScalar(context, angleUnit); delete exp; @@ -445,27 +445,27 @@ template T Expression::epsilon() { /* Expression roots/extrema solver*/ -Expression::Coordinate2D Expression::nextMinimum(char symbol, double start, double step, double max, Context & context, AngleUnit angleUnit) const { - return nextMinimumOfExpression(symbol, start, step, max, [](char symbol, double x, Context & context, AngleUnit angleUnit, const Expression * expression0, const Expression * expression1 = nullptr) { +Expression::Coordinate2D Expression::nextMinimum(char symbol, double start, double step, double max, Context & context, Preferences::AngleUnit angleUnit) const { + return nextMinimumOfExpression(symbol, start, step, max, [](char symbol, double x, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression0, const Expression * expression1 = nullptr) { return expression0->approximateWithValueForSymbol(symbol, x, context, angleUnit); }, context, angleUnit); } -Expression::Coordinate2D Expression::nextMaximum(char symbol, double start, double step, double max, Context & context, AngleUnit angleUnit) const { - Coordinate2D minimumOfOpposite = nextMinimumOfExpression(symbol, start, step, max, [](char symbol, double x, Context & context, AngleUnit angleUnit, const Expression * expression0, const Expression * expression1 = nullptr) { +Expression::Coordinate2D Expression::nextMaximum(char symbol, double start, double step, double max, Context & context, Preferences::AngleUnit angleUnit) const { + Coordinate2D minimumOfOpposite = nextMinimumOfExpression(symbol, start, step, max, [](char symbol, double x, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression0, const Expression * expression1 = nullptr) { return -expression0->approximateWithValueForSymbol(symbol, x, context, angleUnit); }, context, angleUnit); return {.abscissa = minimumOfOpposite.abscissa, .value = -minimumOfOpposite.value}; } -double Expression::nextRoot(char symbol, double start, double step, double max, Context & context, AngleUnit angleUnit) const { - return nextIntersectionWithExpression(symbol, start, step, max, [](char symbol, double x, Context & context, AngleUnit angleUnit, const Expression * expression0, const Expression * expression1 = nullptr) { +double Expression::nextRoot(char symbol, double start, double step, double max, Context & context, Preferences::AngleUnit angleUnit) const { + return nextIntersectionWithExpression(symbol, start, step, max, [](char symbol, double x, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression0, const Expression * expression1 = nullptr) { return expression0->approximateWithValueForSymbol(symbol, x, context, angleUnit); }, context, angleUnit, nullptr); } -Expression::Coordinate2D Expression::nextIntersection(char symbol, double start, double step, double max, Poincare::Context & context, AngleUnit angleUnit, const Expression * expression) const { - double resultAbscissa = nextIntersectionWithExpression(symbol, start, step, max, [](char symbol, double x, Context & context, AngleUnit angleUnit, const Expression * expression0, const Expression * expression1) { +Expression::Coordinate2D Expression::nextIntersection(char symbol, double start, double step, double max, Poincare::Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const { + double resultAbscissa = nextIntersectionWithExpression(symbol, start, step, max, [](char symbol, double x, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression0, const Expression * expression1) { return expression0->approximateWithValueForSymbol(symbol, x, context, angleUnit)-expression1->approximateWithValueForSymbol(symbol, x, context, angleUnit); }, context, angleUnit, expression); Expression::Coordinate2D result = {.abscissa = resultAbscissa, .value = approximateWithValueForSymbol(symbol, resultAbscissa, context, angleUnit)}; @@ -475,7 +475,7 @@ Expression::Coordinate2D Expression::nextIntersection(char symbol, double start, return result; } -Expression::Coordinate2D Expression::nextMinimumOfExpression(char symbol, double start, double step, double max, EvaluationAtAbscissa evaluate, Context & context, AngleUnit angleUnit, const Expression * expression, bool lookForRootMinimum) const { +Expression::Coordinate2D Expression::nextMinimumOfExpression(char symbol, double start, double step, double max, EvaluationAtAbscissa evaluate, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression, bool lookForRootMinimum) const { Coordinate2D result = {.abscissa = NAN, .value = NAN}; if (start == max || step == 0.0) { return result; @@ -512,7 +512,7 @@ Expression::Coordinate2D Expression::nextMinimumOfExpression(char symbol, double return result; } -void Expression::bracketMinimum(char symbol, double start, double step, double max, double result[3], EvaluationAtAbscissa evaluate, Context & context, AngleUnit angleUnit, const Expression * expression) const { +void Expression::bracketMinimum(char symbol, double start, double step, double max, double result[3], EvaluationAtAbscissa evaluate, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const { Coordinate2D p[3]; p[0] = {.abscissa = start, .value = evaluate(symbol, start, context, angleUnit, this, expression)}; p[1] = {.abscissa = start+step, .value = evaluate(symbol, start+step, context, angleUnit, this, expression)}; @@ -537,7 +537,7 @@ void Expression::bracketMinimum(char symbol, double start, double step, double m result[2] = NAN; } -Expression::Coordinate2D Expression::brentMinimum(char symbol, double ax, double bx, EvaluationAtAbscissa evaluate, Context & context, AngleUnit angleUnit, const Expression * expression) const { +Expression::Coordinate2D Expression::brentMinimum(char symbol, double ax, double bx, EvaluationAtAbscissa evaluate, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const { /* Bibliography: R. P. Brent, Algorithms for finding zeros and extrema of * functions without calculating derivatives */ if (ax > bx) { @@ -631,7 +631,7 @@ Expression::Coordinate2D Expression::brentMinimum(char symbol, double ax, double return result; } -double Expression::nextIntersectionWithExpression(char symbol, double start, double step, double max, EvaluationAtAbscissa evaluation, Context & context, AngleUnit angleUnit, const Expression * expression) const { +double Expression::nextIntersectionWithExpression(char symbol, double start, double step, double max, EvaluationAtAbscissa evaluation, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const { if (start == max || step == 0.0) { return NAN; } @@ -647,14 +647,14 @@ double Expression::nextIntersectionWithExpression(char symbol, double start, dou double extremumMax = std::isnan(result) ? max : result; Coordinate2D resultExtremum[2] = { - nextMinimumOfExpression(symbol, start, step, extremumMax, [](char symbol, double x, Context & context, AngleUnit angleUnit, const Expression * expression0, const Expression * expression1) { + nextMinimumOfExpression(symbol, start, step, extremumMax, [](char symbol, double x, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression0, const Expression * expression1) { if (expression1) { return expression0->approximateWithValueForSymbol(symbol, x, context, angleUnit)-expression1->approximateWithValueForSymbol(symbol, x, context, angleUnit); } else { return expression0->approximateWithValueForSymbol(symbol, x, context, angleUnit); } }, context, angleUnit, expression, true), - nextMinimumOfExpression(symbol, start, step, extremumMax, [](char symbol, double x, Context & context, AngleUnit angleUnit, const Expression * expression0, const Expression * expression1) { + nextMinimumOfExpression(symbol, start, step, extremumMax, [](char symbol, double x, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression0, const Expression * expression1) { if (expression1) { return expression1->approximateWithValueForSymbol(symbol, x, context, angleUnit)-expression0->approximateWithValueForSymbol(symbol, x, context, angleUnit); } else { @@ -672,7 +672,7 @@ double Expression::nextIntersectionWithExpression(char symbol, double start, dou return result; } -void Expression::bracketRoot(char symbol, double start, double step, double max, double result[2], EvaluationAtAbscissa evaluation, Context & context, AngleUnit angleUnit, const Expression * expression) const { +void Expression::bracketRoot(char symbol, double start, double step, double max, double result[2], EvaluationAtAbscissa evaluation, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const { double a = start; double b = start+step; while (step > 0.0 ? b <= max : b >= max) { @@ -691,7 +691,7 @@ void Expression::bracketRoot(char symbol, double start, double step, double max, } -double Expression::brentRoot(char symbol, double ax, double bx, double precision, EvaluationAtAbscissa evaluation, Context & context, AngleUnit angleUnit, const Expression * expression) const { +double Expression::brentRoot(char symbol, double ax, double bx, double precision, EvaluationAtAbscissa evaluation, Context & context, Preferences::AngleUnit angleUnit, const Expression * expression) const { if (ax > bx) { return brentRoot(symbol, bx, ax, precision, evaluation, context, angleUnit, expression); } @@ -765,7 +765,7 @@ double Expression::brentRoot(char symbol, double ax, double bx, double precision } template -T Expression::approximateWithValueForSymbol(char symbol, T x, Context & context, AngleUnit angleUnit) const { +T Expression::approximateWithValueForSymbol(char symbol, T x, Context & context, Preferences::AngleUnit angleUnit) const { VariableContext variableContext = VariableContext(symbol, &context); variableContext.setApproximationForVariable(x); T value = approximateToScalar(variableContext, angleUnit); @@ -774,13 +774,13 @@ T Expression::approximateWithValueForSymbol(char symbol, T x, Context & context, } -template Poincare::Expression * Poincare::Expression::approximate(Context& context, AngleUnit angleUnit, ComplexFormat complexFormat) const; -template Poincare::Expression * Poincare::Expression::approximate(Context& context, AngleUnit angleUnit, ComplexFormat complexFormat) const; -template double Poincare::Expression::approximateToScalar(char const*, Poincare::Context&, Poincare::Expression::AngleUnit); -template float Poincare::Expression::approximateToScalar(char const*, Poincare::Context&, Poincare::Expression::AngleUnit); -template double Poincare::Expression::approximateToScalar(Poincare::Context&, Poincare::Expression::AngleUnit) const; -template float Poincare::Expression::approximateToScalar(Poincare::Context&, Poincare::Expression::AngleUnit) const; +template Poincare::Expression * Poincare::Expression::approximate(Context& context, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat) const; +template Poincare::Expression * Poincare::Expression::approximate(Context& context, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat) const; +template double Poincare::Expression::approximateToScalar(char const*, Poincare::Context&, Poincare::Preferences::AngleUnit); +template float Poincare::Expression::approximateToScalar(char const*, Poincare::Context&, Poincare::Preferences::AngleUnit); +template double Poincare::Expression::approximateToScalar(Poincare::Context&, Poincare::Preferences::AngleUnit) const; +template float Poincare::Expression::approximateToScalar(Poincare::Context&, Poincare::Preferences::AngleUnit) const; template double Poincare::Expression::epsilon(); template float Poincare::Expression::epsilon(); -template double Poincare::Expression::approximateWithValueForSymbol(char, double, Poincare::Context&, AngleUnit) const; -template float Poincare::Expression::approximateWithValueForSymbol(char, float, Poincare::Context&, AngleUnit) const; +template double Poincare::Expression::approximateWithValueForSymbol(char, double, Poincare::Context&, Preferences::AngleUnit) const; +template float Poincare::Expression::approximateWithValueForSymbol(char, float, Poincare::Context&, Preferences::AngleUnit) const; diff --git a/poincare/src/expression_debug.cpp b/poincare/src/expression_debug.cpp index 18ccf7d1e..10c410dbb 100644 --- a/poincare/src/expression_debug.cpp +++ b/poincare/src/expression_debug.cpp @@ -55,7 +55,7 @@ void print_expression(const Expression * e, int indentationLevel) { break; case Expression::Type::Decimal: std::cout << "Decimal("; - std::cout << e->approximateToScalar(context, Expression::AngleUnit::Radian); + std::cout << e->approximateToScalar(context, Preferences::AngleUnit::Radian); std::cout << ")"; break; case Expression::Type::Derivative: diff --git a/poincare/src/factor.cpp b/poincare/src/factor.cpp index cddd92d2e..01503dfd9 100644 --- a/poincare/src/factor.cpp +++ b/poincare/src/factor.cpp @@ -22,7 +22,7 @@ Expression * Factor::clone() const { return b; } -Expression * Factor::shallowBeautify(Context& context, AngleUnit angleUnit) { +Expression * Factor::shallowBeautify(Context& context, Preferences::AngleUnit angleUnit) { Expression * op = editableOperand(0); if (op->type() != Type::Rational) { return new Undefined(); @@ -58,7 +58,7 @@ Expression * Factor::shallowBeautify(Context& context, AngleUnit angleUnit) { return result; } -Expression * Factor::createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context & context, AngleUnit angleUnit) { +Expression * Factor::createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context & context, Preferences::AngleUnit angleUnit) { assert(!i.isZero()); i.setNegative(false); Multiplication * m = new Multiplication(); diff --git a/poincare/src/factorial.cpp b/poincare/src/factorial.cpp index 00688e261..b3f222a20 100644 --- a/poincare/src/factorial.cpp +++ b/poincare/src/factorial.cpp @@ -36,7 +36,7 @@ bool Factorial::needParenthesisWithParent(const Expression * e) const { /* Simplification */ -Expression * Factorial::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Factorial::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -66,7 +66,7 @@ Expression * Factorial::shallowReduce(Context& context, AngleUnit angleUnit) { return this; } -Expression * Factorial::shallowBeautify(Context& context, AngleUnit angleUnit) { +Expression * Factorial::shallowBeautify(Context& context, Preferences::AngleUnit angleUnit) { // +(a,b)! ->(+(a,b))! if (operand(0)->type() == Type::Addition || operand(0)->type() == Type::Multiplication || operand(0)->type() == Type::Power) { const Expression * o[1] = {operand(0)}; @@ -77,7 +77,7 @@ Expression * Factorial::shallowBeautify(Context& context, AngleUnit angleUnit) { } template -std::complex Factorial::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex Factorial::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { T n = c.real(); if (c.imag() != 0 || std::isnan(n) || n != (int)n || n < 0) { return Complex::Undefined(); @@ -92,14 +92,14 @@ std::complex Factorial::computeOnComplex(const std::complex c, AngleUnit a return Complex(std::round(result)); } -LayoutRef Factorial::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Factorial::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { HorizontalLayoutRef result; result.addOrMergeChildAtIndex(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits), 0, false); result.addChildAtIndex(CharLayoutRef('!'), result.numberOfChildren(), nullptr); return result; } -int Factorial::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int Factorial::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } diff --git a/poincare/src/floor.cpp b/poincare/src/floor.cpp index 0edf216e4..f498edf18 100644 --- a/poincare/src/floor.cpp +++ b/poincare/src/floor.cpp @@ -20,7 +20,7 @@ Expression * Floor::clone() const { return c; } -Expression * Floor::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Floor::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -49,14 +49,14 @@ Expression * Floor::shallowReduce(Context& context, AngleUnit angleUnit) { } template -std::complex Floor::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex Floor::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { if (c.imag() != 0) { return Complex::Undefined(); } return Complex(std::floor(c.real())); } -LayoutRef Floor::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Floor::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return FloorLayoutRef(m_operands[0]->createLayout(floatDisplayMode, numberOfSignificantDigits)); } diff --git a/poincare/src/frac_part.cpp b/poincare/src/frac_part.cpp index c6313e195..219a2756a 100644 --- a/poincare/src/frac_part.cpp +++ b/poincare/src/frac_part.cpp @@ -17,7 +17,7 @@ Expression * FracPart::clone() const { return c; } -Expression * FracPart::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * FracPart::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -37,7 +37,7 @@ Expression * FracPart::shallowReduce(Context& context, AngleUnit angleUnit) { } template -std::complex FracPart::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex FracPart::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { if (c.imag() != 0) { return Complex::Undefined(); } diff --git a/poincare/src/fraction_layout_node.cpp b/poincare/src/fraction_layout_node.cpp index b1bf7a3ad..e23415863 100644 --- a/poincare/src/fraction_layout_node.cpp +++ b/poincare/src/fraction_layout_node.cpp @@ -121,7 +121,7 @@ void FractionLayoutNode::deleteBeforeCursor(LayoutCursor * cursor) { LayoutNode::deleteBeforeCursor(cursor); } -int FractionLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int FractionLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } diff --git a/poincare/src/global_context.cpp b/poincare/src/global_context.cpp index 8e1a658be..0042604c8 100644 --- a/poincare/src/global_context.cpp +++ b/poincare/src/global_context.cpp @@ -89,7 +89,7 @@ LayoutRef GlobalContext::layoutForSymbol(const Symbol * symbol, int numberOfSign if (symbol->isMatrixSymbol()) { int index = symbolIndex(symbol); if (!m_matrixLayouts[index].isDefined() && m_matrixExpressions[index] != nullptr) { - m_matrixLayouts[index] = m_matrixExpressions[index]->createLayout(PrintFloat::Mode::Decimal, numberOfSignificantDigits); + m_matrixLayouts[index] = m_matrixExpressions[index]->createLayout(Preferences::PrintFloatMode::Decimal, numberOfSignificantDigits); } return m_matrixLayouts[index]; } diff --git a/poincare/src/great_common_divisor.cpp b/poincare/src/great_common_divisor.cpp index 99865c8b4..7ed8ce783 100644 --- a/poincare/src/great_common_divisor.cpp +++ b/poincare/src/great_common_divisor.cpp @@ -19,7 +19,7 @@ Expression * GreatCommonDivisor::clone() const { return a; } -Expression * GreatCommonDivisor::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * GreatCommonDivisor::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -56,7 +56,7 @@ Expression * GreatCommonDivisor::shallowReduce(Context& context, AngleUnit angle } template -Complex * GreatCommonDivisor::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Complex * GreatCommonDivisor::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * f1Input = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * f2Input = operand(1)->privateApproximate(T(), context, angleUnit); T f1 = f1Input->toScalar(); diff --git a/poincare/src/horizontal_layout_node.cpp b/poincare/src/horizontal_layout_node.cpp index 38d783669..429dd1cf9 100644 --- a/poincare/src/horizontal_layout_node.cpp +++ b/poincare/src/horizontal_layout_node.cpp @@ -164,7 +164,7 @@ void HorizontalLayoutNode::deleteBeforeCursor(LayoutCursor * cursor) { LayoutNode::deleteBeforeCursor(cursor); } -int HorizontalLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int HorizontalLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (numberOfChildren() == 0) { if (bufferSize == 0) { return -1; diff --git a/poincare/src/hyperbolic_arc_cosine.cpp b/poincare/src/hyperbolic_arc_cosine.cpp index 72b309764..ded66656c 100644 --- a/poincare/src/hyperbolic_arc_cosine.cpp +++ b/poincare/src/hyperbolic_arc_cosine.cpp @@ -17,7 +17,7 @@ Expression * HyperbolicArcCosine::clone() const { return a; } -Expression * HyperbolicArcCosine::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * HyperbolicArcCosine::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -32,7 +32,7 @@ Expression * HyperbolicArcCosine::shallowReduce(Context& context, AngleUnit angl } template -std::complex HyperbolicArcCosine::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex HyperbolicArcCosine::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex result = std::acosh(c); /* asinh has a branch cut on ]-inf, 1]: it is then multivalued * on this cut. We followed the convention chosen by the lib c++ of llvm on diff --git a/poincare/src/hyperbolic_arc_sine.cpp b/poincare/src/hyperbolic_arc_sine.cpp index f15b89cff..5e78c5f7b 100644 --- a/poincare/src/hyperbolic_arc_sine.cpp +++ b/poincare/src/hyperbolic_arc_sine.cpp @@ -17,7 +17,7 @@ Expression * HyperbolicArcSine::clone() const { return a; } -Expression * HyperbolicArcSine::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * HyperbolicArcSine::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -32,7 +32,7 @@ Expression * HyperbolicArcSine::shallowReduce(Context& context, AngleUnit angleU } template -std::complex HyperbolicArcSine::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex HyperbolicArcSine::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex result = std::asinh(c); /* asinh has a branch cut on ]-inf*i, -i[U]i, +inf*i[: it is then multivalued * on this cut. We followed the convention chosen by the lib c++ of llvm on diff --git a/poincare/src/hyperbolic_arc_tangent.cpp b/poincare/src/hyperbolic_arc_tangent.cpp index 4648a5f7f..e1d136ef6 100644 --- a/poincare/src/hyperbolic_arc_tangent.cpp +++ b/poincare/src/hyperbolic_arc_tangent.cpp @@ -17,7 +17,7 @@ Expression * HyperbolicArcTangent::clone() const { return a; } -Expression * HyperbolicArcTangent::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * HyperbolicArcTangent::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -32,7 +32,7 @@ Expression * HyperbolicArcTangent::shallowReduce(Context& context, AngleUnit ang } template -std::complex HyperbolicArcTangent::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex HyperbolicArcTangent::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex result = std::atanh(c); /* atanh has a branch cut on ]-inf, -1[U]1, +inf[: it is then multivalued on * this cut. We followed the convention chosen by the lib c++ of llvm on diff --git a/poincare/src/hyperbolic_cosine.cpp b/poincare/src/hyperbolic_cosine.cpp index d59987e40..d9d94d760 100644 --- a/poincare/src/hyperbolic_cosine.cpp +++ b/poincare/src/hyperbolic_cosine.cpp @@ -21,7 +21,7 @@ Expression * HyperbolicCosine::clone() const { return a; } -Expression * HyperbolicCosine::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * HyperbolicCosine::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -36,7 +36,7 @@ Expression * HyperbolicCosine::shallowReduce(Context& context, AngleUnit angleUn } template -std::complex HyperbolicCosine::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex HyperbolicCosine::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { return Trigonometry::RoundToMeaningfulDigits(std::cosh(c)); } diff --git a/poincare/src/hyperbolic_sine.cpp b/poincare/src/hyperbolic_sine.cpp index 4507740ea..2e88eba62 100644 --- a/poincare/src/hyperbolic_sine.cpp +++ b/poincare/src/hyperbolic_sine.cpp @@ -21,7 +21,7 @@ Expression * HyperbolicSine::clone() const { return a; } -Expression * HyperbolicSine::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * HyperbolicSine::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -36,7 +36,7 @@ Expression * HyperbolicSine::shallowReduce(Context& context, AngleUnit angleUnit } template -std::complex HyperbolicSine::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex HyperbolicSine::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { return Trigonometry::RoundToMeaningfulDigits(std::sinh(c)); } diff --git a/poincare/src/hyperbolic_tangent.cpp b/poincare/src/hyperbolic_tangent.cpp index a35b4820a..115d1cee8 100644 --- a/poincare/src/hyperbolic_tangent.cpp +++ b/poincare/src/hyperbolic_tangent.cpp @@ -20,7 +20,7 @@ Expression * HyperbolicTangent::clone() const { return a; } -Expression * HyperbolicTangent::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * HyperbolicTangent::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -35,7 +35,7 @@ Expression * HyperbolicTangent::shallowReduce(Context& context, AngleUnit angleU } template -std::complex HyperbolicTangent::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex HyperbolicTangent::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { return Trigonometry::RoundToMeaningfulDigits(std::tanh(c)); } diff --git a/poincare/src/imaginary_part.cpp b/poincare/src/imaginary_part.cpp index 216fd20ac..be4f6503e 100644 --- a/poincare/src/imaginary_part.cpp +++ b/poincare/src/imaginary_part.cpp @@ -18,7 +18,7 @@ Expression * ImaginaryPart::clone() const { } -Expression * ImaginaryPart::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * ImaginaryPart::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -36,7 +36,7 @@ Expression * ImaginaryPart::shallowReduce(Context& context, AngleUnit angleUnit) } template -std::complex ImaginaryPart::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex ImaginaryPart::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { return std::imag(c); } diff --git a/poincare/src/integral.cpp b/poincare/src/integral.cpp index adfebcfbf..f258dd783 100644 --- a/poincare/src/integral.cpp +++ b/poincare/src/integral.cpp @@ -31,7 +31,7 @@ int Integral::polynomialDegree(char symbolName) const { return Expression::polynomialDegree(symbolName); } -Expression * Integral::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Integral::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -45,7 +45,7 @@ Expression * Integral::shallowReduce(Context& context, AngleUnit angleUnit) { } template -Complex * Integral::templatedApproximate(Context & context, AngleUnit angleUnit) const { +Complex * Integral::templatedApproximate(Context & context, Preferences::AngleUnit angleUnit) const { Evaluation * aInput = operand(1)->privateApproximate(T(), context, angleUnit); T a = aInput->toScalar(); delete aInput; @@ -63,7 +63,7 @@ Complex * Integral::templatedApproximate(Context & context, AngleUnit angleUn return new Complex(result); } -LayoutRef Integral::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Integral::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return IntegralLayoutRef( operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits), operand(1)->createLayout(floatDisplayMode, numberOfSignificantDigits), @@ -71,14 +71,14 @@ LayoutRef Integral::createLayout(PrintFloat::Mode floatDisplayMode, int numberOf } template -T Integral::functionValueAtAbscissa(T x, Context & context, AngleUnit angleUnit) const { +T Integral::functionValueAtAbscissa(T x, Context & context, Preferences::AngleUnit angleUnit) const { return operand(0)->approximateWithValueForSymbol('x', x, context, angleUnit); } #ifdef LAGRANGE_METHOD template -T Integral::lagrangeGaussQuadrature(T a, T b, Context & context, AngleUnit angleUnit) const { +T Integral::lagrangeGaussQuadrature(T a, T b, Context & context, Preferences::AngleUnit angleUnit) const { /* We here use Gauss-Legendre quadrature with n = 5 * Gauss-Legendre abscissae and weights can be found in * C/C++ library source code. */ @@ -109,7 +109,7 @@ T Integral::lagrangeGaussQuadrature(T a, T b, Context & context, AngleUnit angle #else template -Integral::DetailedResult Integral::kronrodGaussQuadrature(T a, T b, Context & context, AngleUnit angleUnit) const { +Integral::DetailedResult Integral::kronrodGaussQuadrature(T a, T b, Context & context, Preferences::AngleUnit angleUnit) const { static T epsilon = sizeof(T) == sizeof(double) ? DBL_EPSILON : FLT_EPSILON; static T max = sizeof(T) == sizeof(double) ? DBL_MAX : FLT_MAX; /* We here use Kronrod-Legendre quadrature with n = 21 @@ -184,7 +184,7 @@ Integral::DetailedResult Integral::kronrodGaussQuadrature(T a, T b, Context & } template -T Integral::adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, Context & context, AngleUnit angleUnit) const { +T Integral::adaptiveQuadrature(T a, T b, T eps, int numberOfIterations, Context & context, Preferences::AngleUnit angleUnit) const { if (shouldStopProcessing()) { return NAN; } diff --git a/poincare/src/integral_layout_node.cpp b/poincare/src/integral_layout_node.cpp index 3519e7d00..2339cfdaa 100644 --- a/poincare/src/integral_layout_node.cpp +++ b/poincare/src/integral_layout_node.cpp @@ -139,7 +139,7 @@ void IntegralLayoutNode::deleteBeforeCursor(LayoutCursor * cursor) { LayoutNode::deleteBeforeCursor(cursor); } -int IntegralLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int IntegralLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } diff --git a/poincare/src/layout_engine.cpp b/poincare/src/layout_engine.cpp index d8889e5ca..01c04a1db 100644 --- a/poincare/src/layout_engine.cpp +++ b/poincare/src/layout_engine.cpp @@ -8,7 +8,7 @@ namespace Poincare { -LayoutRef LayoutEngine::createInfixLayout(const Expression * expression, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits, const char * operatorName) { +LayoutRef LayoutEngine::createInfixLayout(const Expression * expression, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits, const char * operatorName) { int numberOfOperands = expression->numberOfOperands(); assert(numberOfOperands > 1); HorizontalLayoutRef result; @@ -23,7 +23,7 @@ LayoutRef LayoutEngine::createInfixLayout(const Expression * expression, PrintFl return result; } -LayoutRef LayoutEngine::createPrefixLayout(const Expression * expression, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits, const char * operatorName) { +LayoutRef LayoutEngine::createPrefixLayout(const Expression * expression, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits, const char * operatorName) { HorizontalLayoutRef result; // Add the operator name. result.addOrMergeChildAtIndex(createStringLayout(operatorName, strlen(operatorName)), 0, true); @@ -70,15 +70,15 @@ LayoutRef LayoutEngine::createLogLayout(LayoutRef argument, LayoutRef index) { return resultLayout; } -int LayoutEngine::writeInfixExpressionTextInBuffer(const Expression * expression, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfDigits, const char * operatorName) { +int LayoutEngine::writeInfixExpressionTextInBuffer(const Expression * expression, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName) { return writeInfixExpressionOrExpressionLayoutTextInBuffer(expression, nullptr, buffer, bufferSize,floatDisplayMode, numberOfDigits, operatorName, 0, -1); } -int LayoutEngine::writePrefixExpressionTextInBuffer(const Expression * expression, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfDigits, const char * operatorName) { +int LayoutEngine::writePrefixExpressionTextInBuffer(const Expression * expression, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName) { return writePrefixExpressionOrExpressionLayoutTextInBuffer(expression, nullptr, buffer, bufferSize, floatDisplayMode, numberOfDigits, operatorName); } -int LayoutEngine::writeInfixExpressionOrExpressionLayoutTextInBuffer(const Expression * expression, void * expressionLayout, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfDigits, const char * operatorName, int firstChildIndex, int lastChildIndex) { +int LayoutEngine::writeInfixExpressionOrExpressionLayoutTextInBuffer(const Expression * expression, void * expressionLayout, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName, int firstChildIndex, int lastChildIndex) { assert(expression != nullptr && expressionLayout == nullptr); if (bufferSize == 0) { return -1; @@ -124,7 +124,7 @@ int LayoutEngine::writeInfixExpressionOrExpressionLayoutTextInBuffer(const Expre return numberOfChar; } -int LayoutEngine::writePrefixExpressionOrExpressionLayoutTextInBuffer(const Expression * expression, void * expressionLayout, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfDigits, const char * operatorName, bool writeFirstChild) { +int LayoutEngine::writePrefixExpressionOrExpressionLayoutTextInBuffer(const Expression * expression, void * expressionLayout, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName, bool writeFirstChild) { assert(expression != nullptr && expressionLayout == nullptr); if (bufferSize == 0) { return -1; @@ -165,7 +165,7 @@ int LayoutEngine::writeInfixSerializableRefTextInBuffer( const SerializableRef serializableRef, char * buffer, int bufferSize, - PrintFloat::Mode floatDisplayMode, + Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName, int firstChildIndex, @@ -217,7 +217,7 @@ int LayoutEngine::writePrefixSerializableRefTextInBuffer( const SerializableRef serializableRef, char * buffer, int bufferSize, - PrintFloat::Mode floatDisplayMode, + Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, const char * operatorName, bool writeFirstChild) @@ -277,7 +277,7 @@ int LayoutEngine::writePrefixSerializableRefTextInBuffer( return numberOfChar; } -void LayoutEngine::writeChildTreeInBuffer(SerializableRef childRef, SerializableRef parentRef, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfDigits, int * numberOfChar) { +void LayoutEngine::writeChildTreeInBuffer(SerializableRef childRef, SerializableRef parentRef, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfDigits, int * numberOfChar) { // Write the child with parentheses if needed bool addParentheses = childRef.needsParenthesisWithParent(parentRef); if (addParentheses) { diff --git a/poincare/src/least_common_multiple.cpp b/poincare/src/least_common_multiple.cpp index fe2d82702..acd805e98 100644 --- a/poincare/src/least_common_multiple.cpp +++ b/poincare/src/least_common_multiple.cpp @@ -19,7 +19,7 @@ Expression * LeastCommonMultiple::clone() const { return a; } -Expression * LeastCommonMultiple::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * LeastCommonMultiple::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -56,7 +56,7 @@ Expression * LeastCommonMultiple::shallowReduce(Context& context, AngleUnit angl } template -Complex * LeastCommonMultiple::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Complex * LeastCommonMultiple::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * f1Input = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * f2Input = operand(1)->privateApproximate(T(), context, angleUnit); T f1 = f1Input->toScalar(); diff --git a/poincare/src/logarithm.cpp b/poincare/src/logarithm.cpp index 9e937d8ce..a1fbb763e 100644 --- a/poincare/src/logarithm.cpp +++ b/poincare/src/logarithm.cpp @@ -28,14 +28,14 @@ Expression * Logarithm::clone() const { } template -std::complex Logarithm::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex Logarithm::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { /* log has a branch cut on ]-inf, 0]: it is then multivalued on this cut. We * followed the convention chosen by the lib c++ of llvm on ]-inf+0i, 0+0i] * (warning: log takes the other side of the cut values on ]-inf-0i, 0-0i]). */ return std::log10(c); } -Expression * Logarithm::simpleShallowReduce(Context & context, AngleUnit angleUnit) { +Expression * Logarithm::simpleShallowReduce(Context & context, Preferences::AngleUnit angleUnit) { Expression * op = editableOperand(0); // log(x,x)->1 if (numberOfOperands() == 2 && op->isIdenticalTo(operand(1))) { @@ -59,7 +59,7 @@ Expression * Logarithm::simpleShallowReduce(Context & context, AngleUnit angleUn return this; } -Expression * Logarithm::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Logarithm::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -158,7 +158,7 @@ bool Logarithm::parentIsAPowerOfSameBase() const { return false; } -Expression * Logarithm::splitInteger(Integer i, bool isDenominator, Context & context, AngleUnit angleUnit) { +Expression * Logarithm::splitInteger(Integer i, bool isDenominator, Context & context, Preferences::AngleUnit angleUnit) { assert(!i.isZero()); assert(!i.isNegative()); if (i.isOne()) { @@ -196,7 +196,7 @@ Expression * Logarithm::splitInteger(Integer i, bool isDenominator, Context & co return a; } -Expression * Logarithm::shallowBeautify(Context & context, AngleUnit angleUnit) { +Expression * Logarithm::shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) { Symbol e = Symbol(Ion::Charset::Exponential); const Expression * op = operand(0); Rational one(1); @@ -209,7 +209,7 @@ Expression * Logarithm::shallowBeautify(Context & context, AngleUnit angleUnit) } template -Evaluation * Logarithm::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * Logarithm::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { if (numberOfOperands() == 1) { return ApproximationEngine::map(this, context, angleUnit, computeOnComplex); } @@ -226,7 +226,7 @@ Evaluation * Logarithm::templatedApproximate(Context& context, AngleUnit angl return new Complex(result); } -LayoutRef Logarithm::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Logarithm::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (numberOfOperands() == 1) { return LayoutEngine::createPrefixLayout(this, floatDisplayMode, numberOfSignificantDigits, "log"); } diff --git a/poincare/src/matrix.cpp b/poincare/src/matrix.cpp index 674149bc9..8607697b5 100644 --- a/poincare/src/matrix.cpp +++ b/poincare/src/matrix.cpp @@ -51,7 +51,7 @@ Expression * Matrix::clone() const { return new Matrix(m_operands, numberOfRows(), numberOfColumns(), true); } -int Matrix::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int Matrix::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } @@ -101,7 +101,7 @@ int Matrix::polynomialDegree(char symbolName) const { return -1; } -void Matrix::rowCanonize(Context & context, AngleUnit angleUnit, Multiplication * determinant) { +void Matrix::rowCanonize(Context & context, Preferences::AngleUnit angleUnit, Multiplication * determinant) { // The matrix has to be reduced to be able to spot 0 inside it for (int i = 0; i < numberOfOperands(); i++) { editableOperand(i)->deepReduce(context, angleUnit); @@ -215,7 +215,7 @@ void Matrix::ArrayRowCanonize(T * array, int numberOfRows, int numberOfColumns, } } -LayoutRef Matrix::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Matrix::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { MatrixLayoutRef layout; LayoutRef castedLayout(layout.node()); for (int i = 0; i < numberOfOperands(); i++) { @@ -226,7 +226,7 @@ LayoutRef Matrix::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSi return layout; } -int Matrix::rank(Context & context, AngleUnit angleUnit, bool inPlace) { +int Matrix::rank(Context & context, Preferences::AngleUnit angleUnit, bool inPlace) { Matrix * m = inPlace ? this : static_cast(clone()); m->rowCanonize(context, angleUnit); int rank = m->numberOfRows(); @@ -312,7 +312,7 @@ Matrix * Matrix::createIdentity(int dim) { return matrix; } -Expression * Matrix::createInverse(Context & context, AngleUnit angleUnit) const { +Expression * Matrix::createInverse(Context & context, Preferences::AngleUnit angleUnit) const { if (numberOfRows() != numberOfColumns()) { return new Undefined(); } @@ -353,7 +353,7 @@ Expression * Matrix::createInverse(Context & context, AngleUnit angleUnit) const #endif template -Evaluation * Matrix::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * Matrix::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { std::complex * operands = new std::complex [numberOfOperands()]; for (int i = 0; i < numberOfOperands(); i++) { Evaluation * operandEvaluation = operand(i)->privateApproximate(T(), context, angleUnit); diff --git a/poincare/src/matrix_dimension.cpp b/poincare/src/matrix_dimension.cpp index f431f4b9a..e059bd738 100644 --- a/poincare/src/matrix_dimension.cpp +++ b/poincare/src/matrix_dimension.cpp @@ -16,7 +16,7 @@ Expression * MatrixDimension::clone() const { return a; } -Expression * MatrixDimension::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * MatrixDimension::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -40,7 +40,7 @@ Expression * MatrixDimension::shallowReduce(Context& context, AngleUnit angleUni } template -Evaluation * MatrixDimension::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * MatrixDimension::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * input = operand(0)->privateApproximate(T(), context, angleUnit); std::complex operands[2]; if (input->type() == Evaluation::Type::MatrixComplex) { diff --git a/poincare/src/matrix_inverse.cpp b/poincare/src/matrix_inverse.cpp index 3dc4468f3..f02469f8c 100644 --- a/poincare/src/matrix_inverse.cpp +++ b/poincare/src/matrix_inverse.cpp @@ -19,7 +19,7 @@ Expression * MatrixInverse::clone() const { return a; } -Expression * MatrixInverse::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * MatrixInverse::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -45,7 +45,7 @@ Expression * MatrixInverse::shallowReduce(Context& context, AngleUnit angleUnit) // TODO: handle this exactly in shallowReduce for small dimensions. template -Evaluation * MatrixInverse::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * MatrixInverse::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * input = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * inverse = input->createInverse(); if (inverse == nullptr) { diff --git a/poincare/src/matrix_layout_node.cpp b/poincare/src/matrix_layout_node.cpp index 967771298..0c5582e9d 100644 --- a/poincare/src/matrix_layout_node.cpp +++ b/poincare/src/matrix_layout_node.cpp @@ -92,7 +92,7 @@ void MatrixLayoutNode::willAddSiblingToEmptyChildAtIndex(int childIndex) { // SerializableNode -int MatrixLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int MatrixLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } diff --git a/poincare/src/matrix_trace.cpp b/poincare/src/matrix_trace.cpp index 8af363820..23e75eac2 100644 --- a/poincare/src/matrix_trace.cpp +++ b/poincare/src/matrix_trace.cpp @@ -18,7 +18,7 @@ Expression * MatrixTrace::clone() const { return a; } -Expression * MatrixTrace::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * MatrixTrace::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -49,7 +49,7 @@ Expression * MatrixTrace::shallowReduce(Context& context, AngleUnit angleUnit) { } template -Complex * MatrixTrace::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Complex * MatrixTrace::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * input = operand(0)->privateApproximate(T(), context, angleUnit); Complex * result = new Complex(input->createTrace()); delete input; diff --git a/poincare/src/matrix_transpose.cpp b/poincare/src/matrix_transpose.cpp index 3e548333c..5d0f8faa6 100644 --- a/poincare/src/matrix_transpose.cpp +++ b/poincare/src/matrix_transpose.cpp @@ -17,7 +17,7 @@ Expression * MatrixTranspose::clone() const { return a; } -Expression * MatrixTranspose::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * MatrixTranspose::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -38,7 +38,7 @@ Expression * MatrixTranspose::shallowReduce(Context& context, AngleUnit angleUni } template -Evaluation * MatrixTranspose::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * MatrixTranspose::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * input = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * transpose = input->createTranspose(); assert(transpose != nullptr); diff --git a/poincare/src/multiplication.cpp b/poincare/src/multiplication.cpp index 5e0a5e4b4..eda3e7b08 100644 --- a/poincare/src/multiplication.cpp +++ b/poincare/src/multiplication.cpp @@ -85,12 +85,12 @@ bool Multiplication::needParenthesisWithParent(const Expression * e) const { return e->isOfType(types, 3); } -LayoutRef Multiplication::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Multiplication::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { const char middleDotString[] = {Ion::Charset::MiddleDot, 0}; return LayoutEngine::createInfixLayout(this, floatDisplayMode, numberOfSignificantDigits, middleDotString); } -int Multiplication::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int Multiplication::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { const char multiplicationString[] = {Ion::Charset::MultiplicationSign, 0}; return LayoutEngine::writeInfixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, multiplicationString); } @@ -103,7 +103,7 @@ Expression::Sign Multiplication::sign() const { return (Sign)sign; } -Expression * Multiplication::setSign(Sign s, Context & context, AngleUnit angleUnit) { +Expression * Multiplication::setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) { assert(s == Sign::Positive); for (int i = 0; i < numberOfOperands(); i++) { if (operand(i)->sign() == Sign::Negative) { @@ -174,11 +174,11 @@ static inline const Expression * Base(const Expression * e) { return e; } -Expression * Multiplication::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Multiplication::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { return privateShallowReduce(context, angleUnit, true, true); } -Expression * Multiplication::privateShallowReduce(Context & context, AngleUnit angleUnit, bool shouldExpand, bool canBeInterrupted) { +Expression * Multiplication::privateShallowReduce(Context & context, Preferences::AngleUnit angleUnit, bool shouldExpand, bool canBeInterrupted) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -392,7 +392,7 @@ void Multiplication::mergeMultiplicationOperands() { } } -void Multiplication::factorizeSineAndCosine(Expression * o1, Expression * o2, Context & context, AngleUnit angleUnit) { +void Multiplication::factorizeSineAndCosine(Expression * o1, Expression * o2, Context & context, Preferences::AngleUnit angleUnit) { assert(o1->parent() == this && o2->parent() == this); /* This function turn sin(x)^p * cos(x)^q into either: * - tan(x)^p*cos(x)^(p+q) if |p|<|q| @@ -447,7 +447,7 @@ void Multiplication::factorizeSineAndCosine(Expression * o1, Expression * o2, Co } } -void Multiplication::factorizeBase(Expression * e1, Expression * e2, Context & context, AngleUnit angleUnit) { +void Multiplication::factorizeBase(Expression * e1, Expression * e2, Context & context, Preferences::AngleUnit angleUnit) { /* This function factorizes two operands which have a common base. For example * if this is Multiplication(pi^2, pi^3), then pi^2 and pi^3 could be merged * and this turned into Multiplication(pi^5). */ @@ -482,7 +482,7 @@ void Multiplication::factorizeBase(Expression * e1, Expression * e2, Context & c } } -void Multiplication::factorizeExponent(Expression * e1, Expression * e2, Context & context, AngleUnit angleUnit) { +void Multiplication::factorizeExponent(Expression * e1, Expression * e2, Context & context, Preferences::AngleUnit angleUnit) { /* This function factorizes operands which share a common exponent. For * example, it turns Multiplication(2^x,3^x) into Multiplication(6^x). */ assert(e1->parent() == this && e2->parent() == this); @@ -504,7 +504,7 @@ void Multiplication::factorizeExponent(Expression * e1, Expression * e2, Context } } -Expression * Multiplication::distributeOnOperandAtIndex(int i, Context & context, AngleUnit angleUnit) { +Expression * Multiplication::distributeOnOperandAtIndex(int i, Context & context, Preferences::AngleUnit angleUnit) { // This function turns a*(b+c) into a*b + a*c // We avoid deleting and creating a new addition Addition * a = static_cast(editableOperand(i)); @@ -548,7 +548,7 @@ bool Multiplication::TermHasRationalExponent(const Expression * e) { return false; } -Expression * Multiplication::shallowBeautify(Context & context, AngleUnit angleUnit) { +Expression * Multiplication::shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) { /* 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) @@ -612,7 +612,7 @@ Expression * Multiplication::shallowBeautify(Context & context, AngleUnit angleU return this; } -Expression * Multiplication::cloneDenominator(Context & context, AngleUnit angleUnit) const { +Expression * Multiplication::cloneDenominator(Context & context, 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. SimplificationRoot root(clone()); @@ -636,7 +636,7 @@ Expression * Multiplication::cloneDenominator(Context & context, AngleUnit angle return result; } -Expression * Multiplication::mergeNegativePower(Context & context, AngleUnit angleUnit) { +Expression * Multiplication::mergeNegativePower(Context & context, Preferences::AngleUnit angleUnit) { Multiplication * m = new Multiplication(); // Special case for rational p/q: if q != 1, q should be at denominator if (operand(0)->type() == Type::Rational && !static_cast(operand(0))->denominator().isOne()) { @@ -672,7 +672,7 @@ Expression * Multiplication::mergeNegativePower(Context & context, AngleUnit ang return squashUnaryHierarchy(); } -void Multiplication::addMissingFactors(Expression * factor, Context & context, AngleUnit angleUnit) { +void Multiplication::addMissingFactors(Expression * factor, Context & context, Preferences::AngleUnit angleUnit) { if (factor->type() == Type::Multiplication) { for (int j = 0; j < factor->numberOfOperands(); j++) { addMissingFactors(factor->editableOperand(j), context, angleUnit); diff --git a/poincare/src/naperian_logarithm.cpp b/poincare/src/naperian_logarithm.cpp index 5326d98f9..ad02b8b03 100644 --- a/poincare/src/naperian_logarithm.cpp +++ b/poincare/src/naperian_logarithm.cpp @@ -20,7 +20,7 @@ Expression * NaperianLogarithm::clone() const { return a; } -Expression * NaperianLogarithm::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * NaperianLogarithm::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -37,7 +37,7 @@ Expression * NaperianLogarithm::shallowReduce(Context& context, AngleUnit angleU } template -std::complex NaperianLogarithm::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex NaperianLogarithm::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { /* ln has a branch cut on ]-inf, 0]: it is then multivalued on this cut. We * followed the convention chosen by the lib c++ of llvm on ]-inf+0i, 0+0i] * (warning: ln takes the other side of the cut values on ]-inf-0i, 0-0i]). */ diff --git a/poincare/src/nth_root.cpp b/poincare/src/nth_root.cpp index 63e0c48c1..27e68832a 100644 --- a/poincare/src/nth_root.cpp +++ b/poincare/src/nth_root.cpp @@ -19,7 +19,7 @@ Expression * NthRoot::clone() const { NthRoot * a = new NthRoot(m_operands, true); return a; } -Expression * NthRoot::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * NthRoot::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -37,12 +37,12 @@ Expression * NthRoot::shallowReduce(Context& context, AngleUnit angleUnit) { return p->shallowReduce(context, angleUnit); } -LayoutRef NthRoot::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef NthRoot::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return NthRootLayoutRef(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits), operand(1)->createLayout(floatDisplayMode, numberOfSignificantDigits)); } template -Evaluation * NthRoot::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * NthRoot::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * base = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * index = operand(1)->privateApproximate(T(), context, angleUnit); Complex result = Complex::Undefined(); diff --git a/poincare/src/nth_root_layout_node.cpp b/poincare/src/nth_root_layout_node.cpp index 18f78f4a0..6dd4f3dd8 100644 --- a/poincare/src/nth_root_layout_node.cpp +++ b/poincare/src/nth_root_layout_node.cpp @@ -147,7 +147,7 @@ void NthRootLayoutNode::deleteBeforeCursor(LayoutCursor * cursor) { } static_assert('\x91' == Ion::Charset::Root, "Unicode error"); -int NthRootLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int NthRootLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { // Case: root(x,n) if (numberOfChildren() == 2 && (const_cast(this))->indexLayout() diff --git a/poincare/src/opposite.cpp b/poincare/src/opposite.cpp index 2e45a07da..cbd4863ce 100644 --- a/poincare/src/opposite.cpp +++ b/poincare/src/opposite.cpp @@ -44,11 +44,11 @@ bool Opposite::needParenthesisWithParent(const Expression * e) const { } template -std::complex Opposite::compute(const std::complex c, AngleUnit angleUnit) { +std::complex Opposite::compute(const std::complex c, Preferences::AngleUnit angleUnit) { return -c; } -Expression * Opposite::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Opposite::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -65,7 +65,7 @@ Expression * Opposite::shallowReduce(Context& context, AngleUnit angleUnit) { return m->shallowReduce(context, angleUnit); } -LayoutRef Opposite::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Opposite::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { HorizontalLayoutRef result = HorizontalLayoutRef(CharLayoutRef('-')); if (operand(0)->type() == Type::Opposite) { result.addOrMergeChildAtIndex(LayoutEngine::createParenthesedLayout(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits), false), 1, false); @@ -75,7 +75,7 @@ LayoutRef Opposite::createLayout(PrintFloat::Mode floatDisplayMode, int numberOf return result; } -int Opposite::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int Opposite::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } @@ -90,5 +90,5 @@ int Opposite::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode } -template std::complex Poincare::Opposite::compute(const std::complex, AngleUnit angleUnit); -template std::complex Poincare::Opposite::compute(const std::complex, AngleUnit angleUnit); +template std::complex Poincare::Opposite::compute(const std::complex, Preferences::AngleUnit angleUnit); +template std::complex Poincare::Opposite::compute(const std::complex, Preferences::AngleUnit angleUnit); diff --git a/poincare/src/parenthesis.cpp b/poincare/src/parenthesis.cpp index d1fce9ffa..2d0c04a45 100644 --- a/poincare/src/parenthesis.cpp +++ b/poincare/src/parenthesis.cpp @@ -20,11 +20,11 @@ int Parenthesis::polynomialDegree(char symbolName) const { return operand(0)->polynomialDegree(symbolName); } -LayoutRef Parenthesis::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Parenthesis::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return LayoutEngine::createParenthesedLayout(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits), false); } -Expression * Parenthesis::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Parenthesis::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -33,7 +33,7 @@ Expression * Parenthesis::shallowReduce(Context& context, AngleUnit angleUnit) { } template -Evaluation * Parenthesis::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * Parenthesis::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { return operand(0)->privateApproximate(T(), context, angleUnit); } diff --git a/poincare/src/permute_coefficient.cpp b/poincare/src/permute_coefficient.cpp index bba8cd97b..1baacc45b 100644 --- a/poincare/src/permute_coefficient.cpp +++ b/poincare/src/permute_coefficient.cpp @@ -18,7 +18,7 @@ Expression * PermuteCoefficient::clone() const { return b; } -Expression * PermuteCoefficient::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * PermuteCoefficient::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -68,7 +68,7 @@ Expression * PermuteCoefficient::shallowReduce(Context& context, AngleUnit angle } template -Complex * PermuteCoefficient::templatedApproximate(Context& context, AngleUnit angleUnit) const { Evaluation * nInput = operand(0)->privateApproximate(T(), context, angleUnit); +Complex * PermuteCoefficient::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * nInput = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * kInput = operand(1)->privateApproximate(T(), context, angleUnit); T n = nInput->toScalar(); T k = kInput->toScalar(); diff --git a/poincare/src/power.cpp b/poincare/src/power.cpp index 94e84f95f..528c73733 100644 --- a/poincare/src/power.cpp +++ b/poincare/src/power.cpp @@ -110,7 +110,7 @@ int Power::privateGetPolynomialCoefficients(char symbolName, Expression * coeffi return -1; } -Expression * Power::setSign(Sign s, Context & context, AngleUnit angleUnit) { +Expression * Power::setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) { assert(s == Sign::Positive); assert(operand(0)->sign() == Sign::Negative); editableOperand(0)->setSign(Sign::Positive, context, angleUnit); @@ -171,7 +171,7 @@ bool Power::needParenthesisWithParent(const Expression * e) const { return e->isOfType(types, 2); } -LayoutRef Power::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Power::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { const Expression * indiceOperand = m_operands[1]; // Delete eventual parentheses of the indice in the pretty print if (m_operands[1]->type() == Type::Parenthesis) { @@ -204,7 +204,7 @@ int Power::simplificationOrderGreaterType(const Expression * e, bool canBeInterr return SimplificationOrder(operand(1), &one, canBeInterrupted); } -Expression * Power::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Power::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -346,7 +346,7 @@ Expression * Power::shallowReduce(Context& context, AngleUnit angleUnit) { detachOperand(m); Expression * i = m->editableOperand(m->numberOfOperands()-1); static_cast(m)->removeOperand(i, false); - if (angleUnit == AngleUnit::Degree) { + if (angleUnit == Preferences::AngleUnit::Degree) { const Expression * pi = m->operand(m->numberOfOperands()-1); m->replaceOperand(pi, new Rational(180), true); } @@ -548,7 +548,7 @@ bool Power::parentIsALogarithmOfSameBase() const { return false; } -Expression * Power::simplifyPowerPower(Power * p, Expression * e, Context& context, AngleUnit angleUnit) { +Expression * Power::simplifyPowerPower(Power * p, Expression * e, Context& context, Preferences::AngleUnit angleUnit) { Expression * p0 = p->editableOperand(0); Expression * p1 = p->editableOperand(1); p->detachOperands(); @@ -559,7 +559,7 @@ Expression * Power::simplifyPowerPower(Power * p, Expression * e, Context& conte return shallowReduce(context, angleUnit); } -Expression * Power::simplifyPowerMultiplication(Multiplication * m, Expression * r, Context& context, AngleUnit angleUnit) { +Expression * Power::simplifyPowerMultiplication(Multiplication * m, Expression * r, Context& context, Preferences::AngleUnit angleUnit) { for (int index = 0; index < m->numberOfOperands(); index++) { Expression * factor = m->editableOperand(index); Power * p = new Power(factor, r, true); // We copy r and factor to avoid inheritance issues @@ -570,7 +570,7 @@ Expression * Power::simplifyPowerMultiplication(Multiplication * m, Expression * return replaceWith(m, true)->shallowReduce(context, angleUnit); // delete r } -Expression * Power::simplifyRationalRationalPower(Expression * result, Rational * a, Rational * b, Context& context, AngleUnit angleUnit) { +Expression * Power::simplifyRationalRationalPower(Expression * result, Rational * a, Rational * b, Context& context, Preferences::AngleUnit angleUnit) { if (b->denominator().isOne()) { Rational r = Rational::Power(*a, b->numerator()); return result->replaceWith(new Rational(r),true); @@ -590,7 +590,7 @@ Expression * Power::simplifyRationalRationalPower(Expression * result, Rational return m->shallowReduce(context, angleUnit); } -Expression * Power::CreateSimplifiedIntegerRationalPower(Integer i, Rational * r, bool isDenominator, Context & context, AngleUnit angleUnit) { +Expression * Power::CreateSimplifiedIntegerRationalPower(Integer i, Rational * r, bool isDenominator, Context & context, Preferences::AngleUnit angleUnit) { assert(!i.isZero()); assert(r->sign() == Sign::Positive); if (i.isOne()) { @@ -664,7 +664,7 @@ Expression * Power::CreateNthRootOfUnity(const Rational r) { #endif } -Expression * Power::shallowBeautify(Context& context, AngleUnit angleUnit) { +Expression * Power::shallowBeautify(Context& context, Preferences::AngleUnit angleUnit) { // X^-y -> 1/(X->shallowBeautify)^y if (operand(1)->sign() == Sign::Negative) { Expression * p = cloneDenominator(context, angleUnit); @@ -693,7 +693,7 @@ Expression * Power::shallowBeautify(Context& context, AngleUnit angleUnit) { return this; } -Expression * Power::cloneDenominator(Context & context, AngleUnit angleUnit) const { +Expression * Power::cloneDenominator(Context & context, Preferences::AngleUnit angleUnit) const { if (operand(1)->sign() == Sign::Negative) { Expression * denominator = clone(); Expression * newExponent = denominator->editableOperand(1)->setSign(Sign::Positive, context, angleUnit); @@ -746,7 +746,7 @@ const Rational * Power::RationalFactorInExpression(const Expression * e) { } } -Expression * Power::removeSquareRootsFromDenominator(Context & context, AngleUnit angleUnit) { +Expression * Power::removeSquareRootsFromDenominator(Context & context, Preferences::AngleUnit angleUnit) { Expression * result = nullptr; if (operand(0)->type() == Type::Rational && operand(1)->type() == Type::Rational && (static_cast(operand(1))->isHalf() || static_cast(operand(1))->isMinusHalf())) { diff --git a/poincare/src/prediction_interval.cpp b/poincare/src/prediction_interval.cpp index 88116abfb..78a3624a4 100644 --- a/poincare/src/prediction_interval.cpp +++ b/poincare/src/prediction_interval.cpp @@ -25,7 +25,7 @@ int PredictionInterval::polynomialDegree(char symbolName) const { return -1; } -Expression * PredictionInterval::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * PredictionInterval::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -71,7 +71,7 @@ Expression * PredictionInterval::shallowReduce(Context& context, AngleUnit angle } template -Evaluation * PredictionInterval::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * PredictionInterval::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * pInput = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * nInput = operand(1)->privateApproximate(T(), context, angleUnit); T p = static_cast *>(pInput)->toScalar(); diff --git a/poincare/src/preferences.cpp b/poincare/src/preferences.cpp index c43eae780..7d02ce7a5 100644 --- a/poincare/src/preferences.cpp +++ b/poincare/src/preferences.cpp @@ -1,12 +1,13 @@ #include +#include namespace Poincare { Preferences::Preferences() : - m_angleUnit(Expression::AngleUnit::Degree), - m_displayMode(PrintFloat::Mode::Decimal), + m_angleUnit(AngleUnit::Degree), + m_displayMode(Preferences::PrintFloatMode::Decimal), m_editionMode(EditionMode::Edition2D), - m_complexFormat(Expression::ComplexFormat::Cartesian), + m_complexFormat(Preferences::ComplexFormat::Cartesian), m_numberOfSignificantDigits(PrintFloat::k_numberOfPrintedSignificantDigits) { } @@ -16,19 +17,19 @@ Preferences * Preferences::sharedPreferences() { return &preferences; } -Expression::AngleUnit Preferences::angleUnit() const { +Preferences::AngleUnit Preferences::angleUnit() const { return m_angleUnit; } -void Preferences::setAngleUnit(Expression::AngleUnit angleUnit) { +void Preferences::setAngleUnit(AngleUnit angleUnit) { m_angleUnit = angleUnit; } -PrintFloat::Mode Preferences::displayMode() const { +Preferences::PrintFloatMode Preferences::displayMode() const { return m_displayMode; } -void Preferences::setDisplayMode(PrintFloat::Mode mode) { +void Preferences::setDisplayMode(Preferences::PrintFloatMode mode) { m_displayMode = mode; } @@ -40,11 +41,11 @@ void Preferences::setEditionMode(Preferences::EditionMode editionMode) { m_editionMode = editionMode; } -Expression::ComplexFormat Preferences::complexFormat() const { +Preferences::ComplexFormat Preferences::complexFormat() const { return m_complexFormat; } -void Preferences::setComplexFormat(Expression::ComplexFormat complexFormat) { +void Preferences::setComplexFormat(ComplexFormat complexFormat) { m_complexFormat = complexFormat; } diff --git a/poincare/src/print_float.cpp b/poincare/src/print_float.cpp index fcad20a73..ece53bed0 100644 --- a/poincare/src/print_float.cpp +++ b/poincare/src/print_float.cpp @@ -1,6 +1,7 @@ #include #include #include +#include extern "C" { #include #include @@ -39,7 +40,7 @@ void PrintFloat::printBase10IntegerWithDecimalMarker(char * buffer, int bufferLe template int PrintFloat::convertFloatToText(T f, char * buffer, int bufferSize, - int numberOfSignificantDigits, Mode mode) { + int numberOfSignificantDigits, Preferences::PrintFloatMode mode) { assert(numberOfSignificantDigits > 0); char tempBuffer[PrintFloat::k_maxFloatBufferLength]; int requiredLength = convertFloatToTextPrivate(f, tempBuffer, numberOfSignificantDigits, mode); @@ -48,13 +49,13 @@ int PrintFloat::convertFloatToText(T f, char * buffer, int bufferSize, * fit the buffer size. If the buffer size is still to small, we only write * the beginning of the float and truncate it (which can result in a non sense * text) */ - if (mode == Mode::Decimal && requiredLength >= bufferSize) { - requiredLength = convertFloatToTextPrivate(f, tempBuffer, numberOfSignificantDigits, Mode::Scientific); + if (mode == Preferences::PrintFloatMode::Decimal && requiredLength >= bufferSize) { + requiredLength = convertFloatToTextPrivate(f, tempBuffer, numberOfSignificantDigits, Preferences::PrintFloatMode::Scientific); } if (requiredLength >= bufferSize) { int adjustedNumberOfSignificantDigits = numberOfSignificantDigits - requiredLength + bufferSize - 1; adjustedNumberOfSignificantDigits = adjustedNumberOfSignificantDigits < 1 ? 1 : adjustedNumberOfSignificantDigits; - requiredLength = convertFloatToTextPrivate(f, tempBuffer, adjustedNumberOfSignificantDigits, Mode::Scientific); + requiredLength = convertFloatToTextPrivate(f, tempBuffer, adjustedNumberOfSignificantDigits, Preferences::PrintFloatMode::Scientific); } requiredLength = requiredLength < bufferSize ? requiredLength : bufferSize-1; strlcpy(buffer, tempBuffer, bufferSize); @@ -62,7 +63,7 @@ int PrintFloat::convertFloatToText(T f, char * buffer, int bufferSize, } template -int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int numberOfSignificantDigits, Mode mode) { +int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int numberOfSignificantDigits, Preferences::PrintFloatMode mode) { assert(numberOfSignificantDigits > 0); /*if (std::isinf(f)) { int currentChar = 0; @@ -89,9 +90,9 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int numberOfSignif int exponentInBase10 = IEEE754::exponentBase10(f); - Mode displayMode = mode; - if ((exponentInBase10 >= numberOfSignificantDigits || exponentInBase10 <= -numberOfSignificantDigits) && mode == Mode::Decimal) { - displayMode = Mode::Scientific; + Preferences::PrintFloatMode displayMode = mode; + if ((exponentInBase10 >= numberOfSignificantDigits || exponentInBase10 <= -numberOfSignificantDigits) && mode == Preferences::PrintFloatMode::Decimal) { + displayMode = Preferences::PrintFloatMode::Scientific; } // Number of char available for the mantissa @@ -104,7 +105,7 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int numberOfSignif * that we stay beyond this threshold during computation. */ assert(availableCharsForMantissaWithoutSign - 1 < std::log10(std::pow(2.0f, 63.0f))); - int numberOfDigitBeforeDecimal = exponentInBase10 >= 0 || displayMode == Mode::Scientific ? + int numberOfDigitBeforeDecimal = exponentInBase10 >= 0 || displayMode == Preferences::PrintFloatMode::Scientific ? exponentInBase10 + 1 : 1; T unroundedMantissa = f * std::pow((T)10.0, (T)(availableCharsForMantissaWithoutSign - 1 - numberOfDigitBeforeDecimal)); @@ -128,16 +129,16 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int numberOfSignif } // Update the display mode if the exponent changed - if ((exponentInBase10 >= numberOfSignificantDigits || exponentInBase10 <= -numberOfSignificantDigits) && mode == Mode::Decimal) { - displayMode = Mode::Scientific; + if ((exponentInBase10 >= numberOfSignificantDigits || exponentInBase10 <= -numberOfSignificantDigits) && mode == Preferences::PrintFloatMode::Decimal) { + displayMode = Preferences::PrintFloatMode::Scientific; } - int decimalMarkerPosition = exponentInBase10 < 0 || displayMode == Mode::Scientific ? + int decimalMarkerPosition = exponentInBase10 < 0 || displayMode == Preferences::PrintFloatMode::Scientific ? 1 : exponentInBase10+1; decimalMarkerPosition = f < 0 ? decimalMarkerPosition+1 : decimalMarkerPosition; // Correct the number of digits in mantissa after rounding - int mantissaExponentInBase10 = exponentInBase10 > 0 || displayMode == Mode::Scientific ? availableCharsForMantissaWithoutSign - 1 : availableCharsForMantissaWithoutSign + exponentInBase10; + int mantissaExponentInBase10 = exponentInBase10 > 0 || displayMode == Preferences::PrintFloatMode::Scientific ? availableCharsForMantissaWithoutSign - 1 : availableCharsForMantissaWithoutSign + exponentInBase10; if (IEEE754::exponentBase10(mantissa) >= mantissaExponentInBase10) { mantissa = mantissa/10; } @@ -154,7 +155,7 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int numberOfSignif Integer digit = Integer::Subtraction(dividend, Integer::Multiplication(quotient, Integer(10))); int minimumNumberOfCharsInMantissa = 1; while (digit.isZero() && availableCharsForMantissaWithoutSign > minimumNumberOfCharsInMantissa && - (availableCharsForMantissaWithoutSign > exponentInBase10+2 || displayMode == Mode::Scientific)) { + (availableCharsForMantissaWithoutSign > exponentInBase10+2 || displayMode == Preferences::PrintFloatMode::Scientific)) { mantissa = mantissa/10; availableCharsForMantissaWithoutSign--; availableCharsForMantissaWithSign--; @@ -164,15 +165,15 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int numberOfSignif } // Suppress the decimal marker if no fractional part - if ((displayMode == Mode::Decimal && availableCharsForMantissaWithoutSign == exponentInBase10+2) - || (displayMode == Mode::Scientific && availableCharsForMantissaWithoutSign == 2)) { + if ((displayMode == Preferences::PrintFloatMode::Decimal && availableCharsForMantissaWithoutSign == exponentInBase10+2) + || (displayMode == Preferences::PrintFloatMode::Scientific && availableCharsForMantissaWithoutSign == 2)) { availableCharsForMantissaWithSign--; } // Print mantissa assert(availableCharsForMantissaWithSign < PrintFloat::k_maxFloatBufferLength); PrintFloat::printBase10IntegerWithDecimalMarker(buffer, availableCharsForMantissaWithSign, Integer((int64_t)mantissa), decimalMarkerPosition); - if (displayMode == Mode::Decimal || exponentInBase10 == 0) { + if (displayMode == Preferences::PrintFloatMode::Decimal || exponentInBase10 == 0) { buffer[availableCharsForMantissaWithSign] = 0; return availableCharsForMantissaWithSign; } @@ -185,8 +186,8 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int numberOfSignif return (availableCharsForMantissaWithSign+1+numberOfCharExponent); } -template int PrintFloat::convertFloatToText(float, char*, int, int, PrintFloat::Mode); -template int PrintFloat::convertFloatToText(double, char*, int, int, PrintFloat::Mode); +template int PrintFloat::convertFloatToText(float, char*, int, int, Preferences::Preferences::PrintFloatMode); +template int PrintFloat::convertFloatToText(double, char*, int, int, Preferences::Preferences::PrintFloatMode); } diff --git a/poincare/src/product_layout_node.cpp b/poincare/src/product_layout_node.cpp index 2821ae6c0..1b003e2f8 100644 --- a/poincare/src/product_layout_node.cpp +++ b/poincare/src/product_layout_node.cpp @@ -6,7 +6,7 @@ namespace Poincare { static inline KDCoordinate max(KDCoordinate x, KDCoordinate y) { return x > y ? x : y; } -int ProductLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int ProductLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return SequenceLayoutNode::writeDerivedClassInBuffer("product", buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits); } diff --git a/poincare/src/randint.cpp b/poincare/src/randint.cpp index b94bb0636..498882fa6 100644 --- a/poincare/src/randint.cpp +++ b/poincare/src/randint.cpp @@ -18,7 +18,7 @@ Expression * Randint::clone() const { return a; } -template Evaluation * Randint::templateApproximate(Context & context, AngleUnit angleUnit) const { +template Evaluation * Randint::templateApproximate(Context & context, Preferences::AngleUnit angleUnit) const { Evaluation * aInput = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * bInput = operand(1)->privateApproximate(T(), context, angleUnit); T a = aInput->toScalar(); diff --git a/poincare/src/random.cpp b/poincare/src/random.cpp index 65beba281..09969225c 100644 --- a/poincare/src/random.cpp +++ b/poincare/src/random.cpp @@ -17,7 +17,7 @@ Expression * Random::clone() const { return a; } -Expression * Random::setSign(Sign s, Context & context, AngleUnit angleUnit) { +Expression * Random::setSign(Sign s, Context & context, Preferences::AngleUnit angleUnit) { assert(s == Sign::Positive); return this; } diff --git a/poincare/src/rational.cpp b/poincare/src/rational.cpp index fba2b4430..1e15b438b 100644 --- a/poincare/src/rational.cpp +++ b/poincare/src/rational.cpp @@ -82,7 +82,7 @@ Expression * Rational::setSign(Sign s) { return this; } -Expression * Rational::shallowBeautify(Context & context, AngleUnit angleUnit) { +Expression * Rational::shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) { if (m_numerator.isNegative()) { m_numerator.setNegative(false); Opposite * o = new Opposite(this, true); @@ -91,7 +91,7 @@ Expression * Rational::shallowBeautify(Context & context, AngleUnit angleUnit) { return this; } -Expression * Rational::cloneDenominator(Context & context, AngleUnit angleUnit) const { +Expression * Rational::cloneDenominator(Context & context, Preferences::AngleUnit angleUnit) const { if (m_denominator.isOne()) { return nullptr; } @@ -137,7 +137,7 @@ int Rational::simplificationOrderSameType(const Expression * e, bool canBeInterr return NaturalOrder(*this, *other); } -template Complex * Rational::templatedApproximate(Context& context, Expression::AngleUnit angleUnit) const { +template Complex * Rational::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { T n = m_numerator.approximate(); T d = m_denominator.approximate(); return new Complex(n/d); @@ -151,7 +151,7 @@ bool Rational::needParenthesisWithParent(const Expression * e) const { return e->isOfType(types, 3); } -LayoutRef Rational::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Rational::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { LayoutRef numeratorLayout = m_numerator.createLayout(); if (m_denominator.isOne()) { return numeratorLayout; @@ -160,7 +160,7 @@ LayoutRef Rational::createLayout(PrintFloat::Mode floatDisplayMode, int numberOf return FractionLayoutRef(numeratorLayout, denominatorLayout); } -int Rational::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int Rational::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { buffer[bufferSize-1] = 0; int numberOfChar = m_numerator.writeTextInBuffer(buffer, bufferSize); if (m_denominator.isOne()) { diff --git a/poincare/src/real_part.cpp b/poincare/src/real_part.cpp index a600cd737..d780845c0 100644 --- a/poincare/src/real_part.cpp +++ b/poincare/src/real_part.cpp @@ -16,7 +16,7 @@ Expression * RealPart::clone() const { return a; } -Expression * RealPart::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * RealPart::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -34,7 +34,7 @@ Expression * RealPart::shallowReduce(Context& context, AngleUnit angleUnit) { } template -std::complex RealPart::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex RealPart::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { return std::real(c); } diff --git a/poincare/src/round.cpp b/poincare/src/round.cpp index 7a04f667e..cbfdd5209 100644 --- a/poincare/src/round.cpp +++ b/poincare/src/round.cpp @@ -19,7 +19,7 @@ Expression * Round::clone() const { return c; } -Expression * Round::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Round::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -53,7 +53,7 @@ Expression * Round::shallowReduce(Context& context, AngleUnit angleUnit) { } template -Complex * Round::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Complex * Round::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * f1Input = operand(0)->privateApproximate(T(), context, angleUnit); Evaluation * f2Input = operand(1)->privateApproximate(T(), context, angleUnit); T f1 = f1Input->toScalar(); diff --git a/poincare/src/sequence.cpp b/poincare/src/sequence.cpp index 4bef32308..b65b2be8e 100644 --- a/poincare/src/sequence.cpp +++ b/poincare/src/sequence.cpp @@ -11,12 +11,12 @@ extern "C" { namespace Poincare { -LayoutRef Sequence::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Sequence::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return createSequenceLayout(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits), operand(1)->createLayout(floatDisplayMode, numberOfSignificantDigits), operand(2)->createLayout(floatDisplayMode, numberOfSignificantDigits)); } template -Evaluation * Sequence::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * Sequence::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { Evaluation * aInput = operand(1)->privateApproximate(T(), context, angleUnit); Evaluation * bInput = operand(2)->privateApproximate(T(), context, angleUnit); T start = aInput->toScalar(); diff --git a/poincare/src/sequence_layout_node.cpp b/poincare/src/sequence_layout_node.cpp index 2553bfc04..281c54408 100644 --- a/poincare/src/sequence_layout_node.cpp +++ b/poincare/src/sequence_layout_node.cpp @@ -171,7 +171,7 @@ KDPoint SequenceLayoutNode::positionOfChild(LayoutNode * l) { return KDPoint(x,y); } -int SequenceLayoutNode::writeDerivedClassInBuffer(const char * operatorName, char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int SequenceLayoutNode::writeDerivedClassInBuffer(const char * operatorName, char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { assert(operatorName != nullptr); if (bufferSize == 0) { return -1; diff --git a/poincare/src/simplification_engine.cpp b/poincare/src/simplification_engine.cpp index b4e33d4d5..07d7e18dc 100644 --- a/poincare/src/simplification_engine.cpp +++ b/poincare/src/simplification_engine.cpp @@ -4,7 +4,7 @@ namespace Poincare { -Expression * SimplificationEngine::map(Expression * e, Context & context, Expression::AngleUnit angleUnit) { +Expression * SimplificationEngine::map(Expression * e, Context & context, Preferences::AngleUnit angleUnit) { assert(e->numberOfOperands() == 1 && e->operand(0)->type() == Expression::Type::Matrix); Expression * op = e->editableOperand(0); for (int i = 0; i < op->numberOfOperands(); i++) { diff --git a/poincare/src/sine.cpp b/poincare/src/sine.cpp index d4dfbc08d..92cb34036 100644 --- a/poincare/src/sine.cpp +++ b/poincare/src/sine.cpp @@ -21,18 +21,18 @@ Expression * Sine::clone() const { return a; } -float Sine::characteristicXRange(Context & context, AngleUnit angleUnit) const { +float Sine::characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const { return Trigonometry::characteristicXRange(this, context, angleUnit); } template -std::complex Sine::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex Sine::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex angleInput = Trigonometry::ConvertToRadian(c, angleUnit); std::complex res = std::sin(angleInput); return Trigonometry::RoundToMeaningfulDigits(res); } -Expression * Sine::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Sine::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; diff --git a/poincare/src/square_root.cpp b/poincare/src/square_root.cpp index d14fe38bd..7839a84b6 100644 --- a/poincare/src/square_root.cpp +++ b/poincare/src/square_root.cpp @@ -20,12 +20,12 @@ Expression * SquareRoot::clone() const { } static_assert('\x91' == Ion::Charset::Root, "Unicode error"); -int SquareRoot::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int SquareRoot::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return LayoutEngine::writePrefixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "\x91"); } template -std::complex SquareRoot::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex SquareRoot::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex result = std::sqrt(c); /* Openbsd trigonometric functions are numerical implementation and thus are * approximative. @@ -36,7 +36,7 @@ std::complex SquareRoot::computeOnComplex(const std::complex c, AngleUnit return ApproximationEngine::truncateRealOrImaginaryPartAccordingToArgument(result); } -Expression * SquareRoot::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * SquareRoot::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; @@ -52,7 +52,7 @@ Expression * SquareRoot::shallowReduce(Context& context, AngleUnit angleUnit) { return p->shallowReduce(context, angleUnit); } -LayoutRef SquareRoot::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef SquareRoot::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return NthRootLayoutRef(operand(0)->createLayout(floatDisplayMode, numberOfSignificantDigits)); } diff --git a/poincare/src/store.cpp b/poincare/src/store.cpp index d6e7fe2a5..091e4162d 100644 --- a/poincare/src/store.cpp +++ b/poincare/src/store.cpp @@ -24,16 +24,16 @@ int Store::polynomialDegree(char symbolName) const { return -1; } -int Store::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int Store::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return LayoutEngine::writeInfixExpressionTextInBuffer(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "\x90"); } -Expression * Store::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Store::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { context.setExpressionForSymbolName(value(), symbol(), context); return replaceWith(editableOperand(1), true)->shallowReduce(context, angleUnit); } -LayoutRef Store::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Store::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { HorizontalLayoutRef result = HorizontalLayoutRef(); result.addOrMergeChildAtIndex(value()->createLayout(floatDisplayMode, numberOfSignificantDigits), 0, false); result.addChildAtIndex(CharLayoutRef(Ion::Charset::Sto), result.numberOfChildren(), nullptr); @@ -42,7 +42,7 @@ LayoutRef Store::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSig } template -Evaluation * Store::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * Store::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { context.setExpressionForSymbolName(value(), symbol(), context); if (context.expressionForSymbol(symbol()) != nullptr) { return context.expressionForSymbol(symbol())->privateApproximate(T(), context, angleUnit); diff --git a/poincare/src/subtraction.cpp b/poincare/src/subtraction.cpp index 077fb1fff..e633edb2c 100644 --- a/poincare/src/subtraction.cpp +++ b/poincare/src/subtraction.cpp @@ -54,7 +54,7 @@ template MatrixComplex Subtraction::computeOnComplexAndMatrix(con return result; } -Expression * Subtraction::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Subtraction::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; diff --git a/poincare/src/sum_layout_node.cpp b/poincare/src/sum_layout_node.cpp index 84ea878e4..3216dc1a4 100644 --- a/poincare/src/sum_layout_node.cpp +++ b/poincare/src/sum_layout_node.cpp @@ -25,7 +25,7 @@ const uint8_t symbolPixel[SumLayoutNode::k_symbolHeight][SumLayoutNode::k_symbol }; -int SumLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int SumLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { return SequenceLayoutNode::writeDerivedClassInBuffer("sum", buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits); } diff --git a/poincare/src/symbol.cpp b/poincare/src/symbol.cpp index 8357ce4e1..4fbe306d3 100644 --- a/poincare/src/symbol.cpp +++ b/poincare/src/symbol.cpp @@ -199,7 +199,7 @@ bool Symbol::isApproximate(Context & context) const { return false; } -float Symbol::characteristicXRange(Context & context, AngleUnit angleUnit) const { +float Symbol::characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const { if (m_name == 'x') { return NAN; } @@ -211,7 +211,7 @@ bool Symbol::hasAnExactRepresentation(Context & context) const { return false; } -Expression * Symbol::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Symbol::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { // Do not replace symbols in expression of type: 3->A if (parent()->type() == Type::Store && parent()->operand(1) == this) { return this; @@ -225,7 +225,7 @@ Expression * Symbol::shallowReduce(Context& context, AngleUnit angleUnit) { } template -Evaluation * Symbol::templatedApproximate(Context& context, AngleUnit angleUnit) const { +Evaluation * Symbol::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { if (m_name == Ion::Charset::IComplex) { return new Complex(0.0, 1.0); } @@ -243,7 +243,7 @@ char Symbol::name() const { return m_name; } -LayoutRef Symbol::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Symbol::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (m_name == SpecialSymbols::Ans) { return LayoutEngine::createStringLayout("ans", 3); } @@ -281,7 +281,7 @@ LayoutRef Symbol::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSi return LayoutEngine::createStringLayout(&m_name, 1); } -int Symbol::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int Symbol::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } diff --git a/poincare/src/tangent.cpp b/poincare/src/tangent.cpp index bffcefe0f..60cc04af2 100644 --- a/poincare/src/tangent.cpp +++ b/poincare/src/tangent.cpp @@ -22,18 +22,18 @@ Expression * Tangent::clone() const { return a; } -float Tangent::characteristicXRange(Context & context, AngleUnit angleUnit) const { +float Tangent::characteristicXRange(Context & context, Preferences::AngleUnit angleUnit) const { return Trigonometry::characteristicXRange(this, context, angleUnit); } template -std::complex Tangent::computeOnComplex(const std::complex c, AngleUnit angleUnit) { +std::complex Tangent::computeOnComplex(const std::complex c, Preferences::AngleUnit angleUnit) { std::complex angleInput = Trigonometry::ConvertToRadian(c, angleUnit); std::complex res = std::tan(angleInput); return Trigonometry::RoundToMeaningfulDigits(res); } -Expression * Tangent::shallowReduce(Context& context, AngleUnit angleUnit) { +Expression * Tangent::shallowReduce(Context& context, Preferences::AngleUnit angleUnit) { Expression * e = Expression::shallowReduce(context, angleUnit); if (e != this) { return e; diff --git a/poincare/src/trigonometry.cpp b/poincare/src/trigonometry.cpp index 733fed6ff..7443a6eaa 100644 --- a/poincare/src/trigonometry.cpp +++ b/poincare/src/trigonometry.cpp @@ -17,7 +17,7 @@ extern "C" { namespace Poincare { -float Trigonometry::characteristicXRange(const Expression * e, Context & context, Expression::AngleUnit angleUnit) { +float Trigonometry::characteristicXRange(const Expression * e, Context & context, Preferences::AngleUnit angleUnit) { assert(e->numberOfOperands() == 1); const Expression * op = e->operand(0); int d = op->polynomialDegree('x'); @@ -37,11 +37,11 @@ float Trigonometry::characteristicXRange(const Expression * e, Context & context const Poincare::Expression * args[2] = {op, &x}; Poincare::Derivative derivative(args, true); float a = derivative.approximateToScalar(context, angleUnit); - float pi = angleUnit == Expression::AngleUnit::Radian ? M_PI : 180.0f; + float pi = angleUnit == Preferences::AngleUnit::Radian ? M_PI : 180.0f; return 2.0f*pi/std::fabs(a); } -Expression * Trigonometry::shallowReduceDirectFunction(Expression * e, Context& context, Expression::AngleUnit angleUnit) { +Expression * Trigonometry::shallowReduceDirectFunction(Expression * e, Context& context, Preferences::AngleUnit angleUnit) { assert(e->type() == Expression::Type::Sine || e->type() == Expression::Type::Cosine || e->type() == Expression::Type::Tangent); Expression * lookup = Trigonometry::table(e->operand(0), e->type(), context, angleUnit); if (lookup != nullptr) { @@ -63,16 +63,16 @@ Expression * Trigonometry::shallowReduceDirectFunction(Expression * e, Context& return e->replaceWith(m, true)->shallowReduce(context, angleUnit); } } - if ((angleUnit == Expression::AngleUnit::Radian && e->operand(0)->type() == Expression::Type::Multiplication && e->operand(0)->numberOfOperands() == 2 && e->operand(0)->operand(1)->type() == Expression::Type::Symbol && static_cast(e->operand(0)->operand(1))->name() == Ion::Charset::SmallPi && e->operand(0)->operand(0)->type() == Expression::Type::Rational) || (angleUnit == Expression::AngleUnit::Degree && e->operand(0)->type() == Expression::Type::Rational)) { - Rational * r = angleUnit == Expression::AngleUnit::Radian ? static_cast(e->editableOperand(0)->editableOperand(0)) : static_cast(e->editableOperand(0)); + if ((angleUnit == Preferences::AngleUnit::Radian && e->operand(0)->type() == Expression::Type::Multiplication && e->operand(0)->numberOfOperands() == 2 && e->operand(0)->operand(1)->type() == Expression::Type::Symbol && static_cast(e->operand(0)->operand(1))->name() == Ion::Charset::SmallPi && e->operand(0)->operand(0)->type() == Expression::Type::Rational) || (angleUnit == Preferences::AngleUnit::Degree && e->operand(0)->type() == Expression::Type::Rational)) { + Rational * r = angleUnit == Preferences::AngleUnit::Radian ? static_cast(e->editableOperand(0)->editableOperand(0)) : static_cast(e->editableOperand(0)); int unaryCoefficient = 1; // store 1 or -1 // Replace argument in [0, Pi/2[ or [0, 90[ - Integer divisor = angleUnit == Expression::AngleUnit::Radian ? r->denominator() : Integer::Multiplication(r->denominator(), Integer(90)); - Integer dividand = angleUnit == Expression::AngleUnit::Radian ? Integer::Addition(r->numerator(), r->numerator()) : r->numerator(); + Integer divisor = angleUnit == Preferences::AngleUnit::Radian ? r->denominator() : Integer::Multiplication(r->denominator(), Integer(90)); + Integer dividand = angleUnit == Preferences::AngleUnit::Radian ? Integer::Addition(r->numerator(), r->numerator()) : r->numerator(); if (divisor.isLowerThan(dividand)) { - Integer piDivisor = angleUnit == Expression::AngleUnit::Radian ? r->denominator() : Integer::Multiplication(r->denominator(), Integer(180)); + Integer piDivisor = angleUnit == Preferences::AngleUnit::Radian ? r->denominator() : Integer::Multiplication(r->denominator(), Integer(180)); IntegerDivision div = Integer::Division(r->numerator(), piDivisor); - dividand = angleUnit == Expression::AngleUnit::Radian ? Integer::Addition(div.remainder, div.remainder) : div.remainder; + dividand = angleUnit == Preferences::AngleUnit::Radian ? Integer::Addition(div.remainder, div.remainder) : div.remainder; if (divisor.isLowerThan(dividand)) { div.remainder = Integer::Subtraction(piDivisor, div.remainder); if (e->type() == Expression::Type::Cosine || e->type() == Expression::Type::Tangent) { @@ -80,7 +80,7 @@ Expression * Trigonometry::shallowReduceDirectFunction(Expression * e, Context& } } Rational * newR = new Rational(div.remainder, r->denominator()); - Expression * rationalParent = angleUnit == Expression::AngleUnit::Radian ? e->editableOperand(0) : e; + Expression * rationalParent = angleUnit == Preferences::AngleUnit::Radian ? e->editableOperand(0) : e; rationalParent->replaceOperand(r, newR, true); e->editableOperand(0)->shallowReduce(context, angleUnit); if (Integer::Division(div.quotient, Integer(2)).remainder.isOne() && e->type() != Expression::Type::Tangent) { @@ -104,10 +104,10 @@ bool Trigonometry::ExpressionIsEquivalentToTangent(const Expression * e) { return false; } -Expression * Trigonometry::shallowReduceInverseFunction(Expression * e, Context& context, Expression::AngleUnit angleUnit) { +Expression * Trigonometry::shallowReduceInverseFunction(Expression * e, Context& context, Preferences::AngleUnit angleUnit) { assert(e->type() == Expression::Type::ArcCosine || e->type() == Expression::Type::ArcSine || e->type() == Expression::Type::ArcTangent); Expression::Type correspondingType = e->type() == Expression::Type::ArcCosine ? Expression::Type::Cosine : (e->type() == Expression::Type::ArcSine ? Expression::Type::Sine : Expression::Type::Tangent); - float pi = angleUnit == Expression::AngleUnit::Radian ? M_PI : 180; + float pi = angleUnit == Preferences::AngleUnit::Radian ? M_PI : 180; if (e->operand(0)->type() == correspondingType) { float trigoOp = e->operand(0)->operand(0)->approximateToScalar(context, angleUnit); if ((e->type() == Expression::Type::ArcCosine && trigoOp >= 0.0f && trigoOp <= pi) || @@ -138,7 +138,7 @@ Expression * Trigonometry::shallowReduceInverseFunction(Expression * e, Context& op->shallowReduce(context, angleUnit); } if (e->type() == Expression::Type::ArcCosine) { - Expression * pi = angleUnit == Expression::AngleUnit::Radian ? static_cast(new Symbol(Ion::Charset::SmallPi)) : static_cast(new Rational(180)); + Expression * pi = angleUnit == Preferences::AngleUnit::Radian ? static_cast(new Symbol(Ion::Charset::SmallPi)) : static_cast(new Rational(180)); Subtraction * s = new Subtraction(pi, e->clone(), false); s->editableOperand(1)->shallowReduce(context, angleUnit); return e->replaceWith(s, true)->shallowReduce(context, angleUnit); @@ -192,9 +192,9 @@ constexpr const char * cheatTable[Trigonometry::k_numberOfEntries][5] = {"165", "\x8A*11*12^(-1)", "(-1)*6^(1/2)*4^(-1)-2^(1/2)*4^(-1)", "", ""}, {"180", "\x8A", "-1", "0", "0"}}; -Expression * Trigonometry::table(const Expression * e, Expression::Type type, Context & context, Expression::AngleUnit angleUnit) { +Expression * Trigonometry::table(const Expression * e, Expression::Type type, Context & context, Preferences::AngleUnit angleUnit) { assert(type == Expression::Type::Sine || type == Expression::Type::Cosine || type == Expression::Type::Tangent || type == Expression::Type::ArcCosine || type == Expression::Type::ArcSine || type == Expression::Type::ArcTangent); - int angleUnitIndex = angleUnit == Expression::AngleUnit::Radian ? 1 : 0; + int angleUnitIndex = angleUnit == Preferences::AngleUnit::Radian ? 1 : 0; int trigonometricFunctionIndex = type == Expression::Type::Cosine || type == Expression::Type::ArcCosine ? 2 : (type == Expression::Type::Sine || type == Expression::Type::ArcSine ? 3 : 4); int inputIndex = type == Expression::Type::ArcCosine || type == Expression::Type::ArcSine || type == Expression::Type::ArcTangent ? trigonometricFunctionIndex : angleUnitIndex; int outputIndex = type == Expression::Type::ArcCosine || type == Expression::Type::ArcSine || type == Expression::Type::ArcTangent ? angleUnitIndex : trigonometricFunctionIndex; @@ -231,16 +231,16 @@ Expression * Trigonometry::table(const Expression * e, Expression::Type type, Co template -std::complex Trigonometry::ConvertToRadian(const std::complex c, Expression::AngleUnit angleUnit) { - if (angleUnit == Expression::AngleUnit::Degree) { +std::complex Trigonometry::ConvertToRadian(const std::complex c, Preferences::AngleUnit angleUnit) { + if (angleUnit == Preferences::AngleUnit::Degree) { return c*std::complex(M_PI/180.0); } return c; } template -std::complex Trigonometry::ConvertRadianToAngleUnit(const std::complex c, Expression::AngleUnit angleUnit) { - if (angleUnit == Expression::AngleUnit::Degree) { +std::complex Trigonometry::ConvertRadianToAngleUnit(const std::complex c, Preferences::AngleUnit angleUnit) { + if (angleUnit == Preferences::AngleUnit::Degree) { return c*std::complex(180/M_PI); } return c; @@ -264,10 +264,10 @@ std::complex Trigonometry::RoundToMeaningfulDigits(const std::complex c) { return std::complex(RoundToMeaningfulDigits(c.real()), RoundToMeaningfulDigits(c.imag())); } -template std::complex Trigonometry::ConvertToRadian(std::complex, Expression::AngleUnit); -template std::complex Trigonometry::ConvertToRadian(std::complex, Expression::AngleUnit); -template std::complex Trigonometry::ConvertRadianToAngleUnit(std::complex, Expression::AngleUnit); -template std::complex Trigonometry::ConvertRadianToAngleUnit(std::complex, Expression::AngleUnit); +template std::complex Trigonometry::ConvertToRadian(std::complex, Preferences::AngleUnit); +template std::complex Trigonometry::ConvertToRadian(std::complex, Preferences::AngleUnit); +template std::complex Trigonometry::ConvertRadianToAngleUnit(std::complex, Preferences::AngleUnit); +template std::complex Trigonometry::ConvertRadianToAngleUnit(std::complex, Preferences::AngleUnit); template std::complex Trigonometry::RoundToMeaningfulDigits(std::complex); template std::complex Trigonometry::RoundToMeaningfulDigits(std::complex); diff --git a/poincare/src/undefined.cpp b/poincare/src/undefined.cpp index 8b420eb78..79c59ccea 100644 --- a/poincare/src/undefined.cpp +++ b/poincare/src/undefined.cpp @@ -20,17 +20,17 @@ int Undefined::polynomialDegree(char symbolName) const { return -1; } -template Complex * Undefined::templatedApproximate(Context& context, AngleUnit angleUnit) const { +template Complex * Undefined::templatedApproximate(Context& context, Preferences::AngleUnit angleUnit) const { return new Complex(Complex::Undefined()); } -LayoutRef Undefined::createLayout(PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +LayoutRef Undefined::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { char buffer[16]; int numberOfChars = PrintFloat::convertFloatToText(NAN, buffer, 16, 1, floatDisplayMode); return LayoutEngine::createStringLayout(buffer, numberOfChars); } -int Undefined::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int Undefined::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (bufferSize == 0) { return -1; } diff --git a/poincare/src/vertical_offset_layout_node.cpp b/poincare/src/vertical_offset_layout_node.cpp index 48261e9a3..370e6b74c 100644 --- a/poincare/src/vertical_offset_layout_node.cpp +++ b/poincare/src/vertical_offset_layout_node.cpp @@ -158,7 +158,7 @@ void VerticalOffsetLayoutNode::deleteBeforeCursor(LayoutCursor * cursor) { LayoutNode::deleteBeforeCursor(cursor); } -int VerticalOffsetLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, PrintFloat::Mode floatDisplayMode, int numberOfSignificantDigits) const { +int VerticalOffsetLayoutNode::writeTextInBuffer(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { if (m_type == Type::Subscript) { if (bufferSize == 0) { return -1; diff --git a/poincare/test/convert_expression_to_text.cpp b/poincare/test/convert_expression_to_text.cpp index fbdc0a079..81b35195c 100644 --- a/poincare/test/convert_expression_to_text.cpp +++ b/poincare/test/convert_expression_to_text.cpp @@ -10,7 +10,7 @@ using namespace Poincare; template -void assert_float_prints_to(T a, const char * result, PrintFloat::Mode mode = ScientificMode, int significantDigits = 7, int bufferSize = 250) { +void assert_float_prints_to(T a, const char * result, Preferences::PrintFloatMode mode = ScientificMode, int significantDigits = 7, int bufferSize = 250) { quiz_print(result); int tagSize = 8; @@ -34,7 +34,7 @@ void assert_float_prints_to(T a, const char * result, PrintFloat::Mode mode = Sc delete[] taggedBuffer; } -void assert_expression_prints_to(Expression * e, const char * result, PrintFloat::Mode mode = ScientificMode, int numberOfSignificantDigits = 7, int bufferSize = 250) { +void assert_expression_prints_to(Expression * e, const char * result, Preferences::PrintFloatMode mode = ScientificMode, int numberOfSignificantDigits = 7, int bufferSize = 250) { quiz_print(result); int tagSize = 8; @@ -59,7 +59,7 @@ void assert_expression_prints_to(Expression * e, const char * result, PrintFloat } template -void assert_approximation_prints_to(Approximation * e, const char * result, Expression::ComplexFormat complexFormat = Cartesian) { +void assert_approximation_prints_to(Approximation * e, const char * result, Preferences::ComplexFormat complexFormat = Cartesian) { GlobalContext globalContext; Expression * approximation = e->template approximate(globalContext, Radian, complexFormat); assert_expression_prints_to(approximation, result, DecimalMode, (sizeof(T) == sizeof(float) ? 7 : 14)); diff --git a/poincare/test/helper.cpp b/poincare/test/helper.cpp index 1c03fa3f5..20be709e6 100644 --- a/poincare/test/helper.cpp +++ b/poincare/test/helper.cpp @@ -67,9 +67,9 @@ void assert_parsed_expression_polynomial_degree(const char * expression, int deg delete e; } -typedef Expression * (*ProcessExpression)(Expression *, Context & context, Expression::AngleUnit angleUnit, Expression::ComplexFormat complexFormat); +typedef Expression * (*ProcessExpression)(Expression *, Context & context, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat); -void assert_parsed_expression_process_to(const char * expression, const char * result, Expression::AngleUnit angleUnit, Expression::ComplexFormat complexFormat, ProcessExpression process, int numberOfSignifiantDigits = PrintFloat::k_numberOfStoredSignificantDigits) { +void assert_parsed_expression_process_to(const char * expression, const char * result, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat, ProcessExpression process, int numberOfSignifiantDigits = PrintFloat::k_numberOfStoredSignificantDigits) { GlobalContext globalContext; Expression * e = parse_expression(expression); #if POINCARE_TESTS_PRINT_EXPRESSIONS @@ -93,22 +93,22 @@ void assert_parsed_expression_process_to(const char * expression, const char * r } template -void assert_parsed_expression_evaluates_to(const char * expression, const char * approximation, Expression::AngleUnit angleUnit, Expression::ComplexFormat complexFormat, int numberOfSignificantDigits) { +void assert_parsed_expression_evaluates_to(const char * expression, const char * approximation, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat, int numberOfSignificantDigits) { #if POINCARE_TESTS_PRINT_EXPRESSIONS cout << "--------- Approximation ---------" << endl; #endif int numberOfDigits = sizeof(T) == sizeof(double) ? PrintFloat::k_numberOfStoredSignificantDigits : PrintFloat::k_numberOfPrintedSignificantDigits; numberOfDigits = numberOfSignificantDigits > 0 ? numberOfSignificantDigits : numberOfDigits; - assert_parsed_expression_process_to(expression, approximation, angleUnit, complexFormat, [](Expression * e, Context & context, Expression::AngleUnit angleUnit, Expression::ComplexFormat complexFormat) { + assert_parsed_expression_process_to(expression, approximation, angleUnit, complexFormat, [](Expression * e, Context & context, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat) { return e->approximate(context, angleUnit, complexFormat); }, numberOfDigits); } -void assert_parsed_expression_simplify_to(const char * expression, const char * simplifiedExpression, Expression::AngleUnit angleUnit) { +void assert_parsed_expression_simplify_to(const char * expression, const char * simplifiedExpression, Preferences::AngleUnit angleUnit) { #if POINCARE_TESTS_PRINT_EXPRESSIONS cout << "--------- Simplification ---------" << endl; #endif - assert_parsed_expression_process_to(expression, simplifiedExpression, angleUnit, Expression::ComplexFormat::Cartesian, [](Expression * e, Context & context, Expression::AngleUnit angleUnit, Expression::ComplexFormat complexFormat) { return e; }); + assert_parsed_expression_process_to(expression, simplifiedExpression, angleUnit, Preferences::ComplexFormat::Cartesian, [](Expression * e, Context & context, Preferences::AngleUnit angleUnit, Preferences::ComplexFormat complexFormat) { return e; }); } void assert_parsed_expression_layout_serialize_to_self(const char * expressionLayout) { @@ -140,5 +140,5 @@ void assert_expression_layout_serialize_to(Poincare::ExpressionLayout * layout, assert(strcmp(serialization, buffer) == 0); } -template void assert_parsed_expression_evaluates_to(char const*, char const *, Poincare::Expression::AngleUnit, Poincare::Expression::ComplexFormat, int); -template void assert_parsed_expression_evaluates_to(char const*, char const *, Poincare::Expression::AngleUnit, Poincare::Expression::ComplexFormat, int); +template void assert_parsed_expression_evaluates_to(char const*, char const *, Poincare::Preferences::AngleUnit, Poincare::Preferences::ComplexFormat, int); +template void assert_parsed_expression_evaluates_to(char const*, char const *, Poincare::Preferences::AngleUnit, Poincare::Preferences::ComplexFormat, int); diff --git a/poincare/test/helper.h b/poincare/test/helper.h index 90b1e158c..b654641fb 100644 --- a/poincare/test/helper.h +++ b/poincare/test/helper.h @@ -2,12 +2,12 @@ // Expressions -constexpr Poincare::Expression::AngleUnit Degree = Poincare::Expression::AngleUnit::Degree; -constexpr Poincare::Expression::AngleUnit Radian = Poincare::Expression::AngleUnit::Radian; -constexpr Poincare::Expression::ComplexFormat Cartesian = Poincare::Expression::ComplexFormat::Cartesian; -constexpr Poincare::Expression::ComplexFormat Polar = Poincare::Expression::ComplexFormat::Polar; -constexpr Poincare::PrintFloat::Mode DecimalMode = Poincare::PrintFloat::Mode::Decimal; -constexpr Poincare::PrintFloat::Mode ScientificMode = Poincare::PrintFloat::Mode::Scientific; +constexpr Poincare::Preferences::AngleUnit Degree = Poincare::Preferences::AngleUnit::Degree; +constexpr Poincare::Preferences::AngleUnit Radian = Poincare::Preferences::AngleUnit::Radian; +constexpr Poincare::Preferences::ComplexFormat Cartesian = Poincare::Preferences::ComplexFormat::Cartesian; +constexpr Poincare::Preferences::ComplexFormat Polar = Poincare::Preferences::ComplexFormat::Polar; +constexpr Poincare::Preferences::PrintFloatMode DecimalMode = Poincare::Preferences::PrintFloatMode::Decimal; +constexpr Poincare::Preferences::PrintFloatMode ScientificMode = Poincare::Preferences::PrintFloatMode::Scientific; void translate_in_special_chars(char * expression); void translate_in_ASCII_chars(char * expression); @@ -15,8 +15,8 @@ Poincare::Expression * parse_expression(const char * expression); void assert_parsed_expression_type(const char * expression, Poincare::Expression::Type type); void assert_parsed_expression_polynomial_degree(const char * expression, int degree, char symbolName = 'x'); template -void assert_parsed_expression_evaluates_to(const char * expression, const char * approximation, Poincare::Expression::AngleUnit angleUnit = Degree, Poincare::Expression::ComplexFormat complexFormat = Cartesian, int numberOfSignificantDigits = -1); -void assert_parsed_expression_simplify_to(const char * expression, const char * simplifiedExpression, Poincare::Expression::AngleUnit angleUnit = Poincare::Expression::AngleUnit::Radian); +void assert_parsed_expression_evaluates_to(const char * expression, const char * approximation, Poincare::Preferences::AngleUnit angleUnit = Degree, Poincare::Preferences::ComplexFormat complexFormat = Cartesian, int numberOfSignificantDigits = -1); +void assert_parsed_expression_simplify_to(const char * expression, const char * simplifiedExpression, Poincare::Preferences::AngleUnit angleUnit = Poincare::Preferences::AngleUnit::Radian); // Layouts void assert_parsed_expression_layout_serialize_to_self(const char * expressionLayout); diff --git a/poincare/test/properties.cpp b/poincare/test/properties.cpp index cd6913cbe..8f424d298 100644 --- a/poincare/test/properties.cpp +++ b/poincare/test/properties.cpp @@ -52,7 +52,7 @@ QUIZ_CASE(poincare_polynomial_degree) { assert_parsed_expression_polynomial_degree("P*x", 1); } -void assert_parsed_expression_has_characteristic_range(const char * expression, float range, Expression::AngleUnit angleUnit = Expression::AngleUnit::Degree) { +void assert_parsed_expression_has_characteristic_range(const char * expression, float range, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Degree) { GlobalContext globalContext; Expression * e = parse_expression(expression); Expression::Simplify(&e, globalContext, angleUnit); @@ -67,11 +67,11 @@ void assert_parsed_expression_has_characteristic_range(const char * expression, QUIZ_CASE(poincare_characteristic_range) { assert_parsed_expression_has_characteristic_range("cos(x)", 360.0f); assert_parsed_expression_has_characteristic_range("cos(-x)", 360.0f); - assert_parsed_expression_has_characteristic_range("cos(x)", 2.0f*M_PI, Expression::AngleUnit::Radian); - assert_parsed_expression_has_characteristic_range("cos(-x)", 2.0f*M_PI, Expression::AngleUnit::Radian); + assert_parsed_expression_has_characteristic_range("cos(x)", 2.0f*M_PI, Preferences::AngleUnit::Radian); + assert_parsed_expression_has_characteristic_range("cos(-x)", 2.0f*M_PI, Preferences::AngleUnit::Radian); assert_parsed_expression_has_characteristic_range("sin(9*x+10)", 40.0f); assert_parsed_expression_has_characteristic_range("sin(9*x+10)+cos(x/2)", 720.0f); - assert_parsed_expression_has_characteristic_range("sin(9*x+10)+cos(x/2)", 4.0f*M_PI, Expression::AngleUnit::Radian); + assert_parsed_expression_has_characteristic_range("sin(9*x+10)+cos(x/2)", 4.0f*M_PI, Preferences::AngleUnit::Radian); assert_parsed_expression_has_characteristic_range("x", NAN); assert_parsed_expression_has_characteristic_range("cos(3)+2", 0.0f); assert_parsed_expression_has_characteristic_range("log(cos(40*x))", 9.0f); @@ -103,7 +103,7 @@ QUIZ_CASE(poincare_get_variables) { assert_parsed_expression_has_variables("x^2+2*y+k!*A+w", "xykw"); } -void assert_parsed_expression_has_polynomial_coefficient(const char * expression, char symbolName, const char ** coefficients, Expression::AngleUnit angleUnit = Expression::AngleUnit::Degree) { +void assert_parsed_expression_has_polynomial_coefficient(const char * expression, char symbolName, const char ** coefficients, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Degree) { GlobalContext globalContext; Expression * e = parse_expression(expression); Expression::Reduce(&e, globalContext, angleUnit); diff --git a/poincare/test/trigo.cpp b/poincare/test/trigo.cpp index b321fcca3..72171e933 100644 --- a/poincare/test/trigo.cpp +++ b/poincare/test/trigo.cpp @@ -363,23 +363,23 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("cos(-P/3)", "1/2"); assert_parsed_expression_simplify_to("cos(41P/5)", "(1+R(5))/4"); assert_parsed_expression_simplify_to("cos(7P/10)", "-(R(2)*R(5-R(5)))/4"); - assert_parsed_expression_simplify_to("cos(0)", "1", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(180)", "-1", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(720/7)", "-cos(540/7)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(6300/29)", "-cos(1080/29)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(-6300/29)", "-cos(1080/29)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(61200000)", "1", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(-61200180)", "-1", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(-180*R(2))", "cos(180*R(2))", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(39330)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(15)", "(R(2)+R(6))/4", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(-15)", "(R(2)+R(6))/4", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(-765/2)", "R(2+R(2))/2", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(7380/6)", "-R(3)/2", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(180045)", "R(2)/2", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(-60)", "1/2", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(7380/5)", "(1+R(5))/4", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(112.5)", "-R(2-R(2))/2", Expression::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(0)", "1", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(180)", "-1", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(720/7)", "-cos(540/7)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(6300/29)", "-cos(1080/29)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(-6300/29)", "-cos(1080/29)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(61200000)", "1", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(-61200180)", "-1", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(-180*R(2))", "cos(180*R(2))", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(39330)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(15)", "(R(2)+R(6))/4", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(-15)", "(R(2)+R(6))/4", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(-765/2)", "R(2+R(2))/2", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(7380/6)", "-R(3)/2", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(180045)", "R(2)/2", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(-60)", "1/2", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(7380/5)", "(1+R(5))/4", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(112.5)", "-R(2-R(2))/2", Preferences::AngleUnit::Degree); // -- sin assert_parsed_expression_simplify_to("sin(0)", "0"); assert_parsed_expression_simplify_to("sin(P)", "0"); @@ -399,23 +399,23 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("sin(-P/3)", "-R(3)/2"); assert_parsed_expression_simplify_to("sin(17P/5)", "-(R(2)*R(5+R(5)))/4"); assert_parsed_expression_simplify_to("sin(P/5)", "(R(2)*R(5-R(5)))/4"); - assert_parsed_expression_simplify_to("sin(0)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(180)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(6300/29)", "-sin(1080/29)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(-6300/29)", "sin(1080/29)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(61200000)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(61200180)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(-61200180)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(15)", "((-R(2))+R(6))/4", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(-15)", "(R(2)-R(6))/4", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(-180*R(2))", "-sin(180*R(2))", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(39330)", "1", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(-765/2)", "-R(2-R(2))/2", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(1230)", "1/2", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(180045)", "R(2)/2", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(-60)", "-R(3)/2", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(612)", "-(R(2)*R(5+R(5)))/4", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(36)", "(R(2)*R(5-R(5)))/4", Expression::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(0)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(180)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(6300/29)", "-sin(1080/29)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(-6300/29)", "sin(1080/29)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(61200000)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(61200180)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(-61200180)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(15)", "((-R(2))+R(6))/4", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(-15)", "(R(2)-R(6))/4", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(-180*R(2))", "-sin(180*R(2))", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(39330)", "1", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(-765/2)", "-R(2-R(2))/2", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(1230)", "1/2", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(180045)", "R(2)/2", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(-60)", "-R(3)/2", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(612)", "-(R(2)*R(5+R(5)))/4", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(36)", "(R(2)*R(5-R(5)))/4", Preferences::AngleUnit::Degree); // -- tan assert_parsed_expression_simplify_to("tan(0)", "0"); assert_parsed_expression_simplify_to("tan(P)", "0"); @@ -433,21 +433,21 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("tan(P/4+1000P)", "1"); assert_parsed_expression_simplify_to("tan(-P/3)", "-R(3)"); assert_parsed_expression_simplify_to("tan(-P/10)", "-(R(5)*R(5-2*R(5)))/5"); - assert_parsed_expression_simplify_to("tan(0)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(180)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(6300/29)", "tan(1080/29)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(-6300/29)", "-tan(1080/29)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(61200000)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(61200180)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(-61200180)", "0", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(15)", "2-R(3)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(-15)", "(-2)+R(3)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(-180*R(2))", "-tan(180*R(2))", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(39330)", "undef", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(-382.5)", "1-R(2)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(1230)", "-R(3)/3", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(180045)", "1", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(-60)", "-R(3)", Expression::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(0)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(180)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(6300/29)", "tan(1080/29)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(-6300/29)", "-tan(1080/29)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(61200000)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(61200180)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(-61200180)", "0", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(15)", "2-R(3)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(-15)", "(-2)+R(3)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(-180*R(2))", "-tan(180*R(2))", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(39330)", "undef", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(-382.5)", "1-R(2)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(1230)", "-R(3)/3", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(180045)", "1", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(-60)", "-R(3)", Preferences::AngleUnit::Degree); assert_parsed_expression_simplify_to("tan(tan(tan(tan(9))))", "tan(tan(tan(tan(9))))"); // -- acos assert_parsed_expression_simplify_to("acos(-1/2)", "(2*P)/3"); @@ -459,15 +459,15 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("acos(cos(12))", "acos(cos(12))"); assert_parsed_expression_simplify_to("acos(cos(4P/7))", "(4*P)/7"); assert_parsed_expression_simplify_to("acos(-cos(2))", "(-2)+P"); - assert_parsed_expression_simplify_to("acos(-1/2)", "120", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("acos(-1.2)", "180-acos(6/5)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("acos(cos(2/3))", "2/3", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("acos(cos(190))", "170", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("acos(cos(75))", "75", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(acos(190))", "190", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("cos(acos(75))", "75", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("acos(cos(12))", "12", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("acos(cos(720/7))", "720/7", Expression::AngleUnit::Degree); + assert_parsed_expression_simplify_to("acos(-1/2)", "120", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("acos(-1.2)", "180-acos(6/5)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("acos(cos(2/3))", "2/3", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("acos(cos(190))", "170", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("acos(cos(75))", "75", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(acos(190))", "190", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("cos(acos(75))", "75", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("acos(cos(12))", "12", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("acos(cos(720/7))", "720/7", Preferences::AngleUnit::Degree); // -- asin assert_parsed_expression_simplify_to("asin(-1/2)", "-P/6"); assert_parsed_expression_simplify_to("asin(-1.2)", "-asin(6/5)"); @@ -478,14 +478,14 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("asin(sin(12))", "asin(sin(12))"); assert_parsed_expression_simplify_to("asin(sin(-P/7))", "-P/7"); assert_parsed_expression_simplify_to("asin(sin(-R(2)))", "-R(2)"); - assert_parsed_expression_simplify_to("asin(-1/2)", "-30", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("asin(-1.2)", "-asin(6/5)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("asin(sin(75))", "75", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(asin(75))", "75", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("sin(asin(190))", "190", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("asin(sin(32))", "32", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("asin(sin(400))", "40", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("asin(sin(-180/7))", "-180/7", Expression::AngleUnit::Degree); + assert_parsed_expression_simplify_to("asin(-1/2)", "-30", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("asin(-1.2)", "-asin(6/5)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("asin(sin(75))", "75", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(asin(75))", "75", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("sin(asin(190))", "190", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("asin(sin(32))", "32", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("asin(sin(400))", "40", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("asin(sin(-180/7))", "-180/7", Preferences::AngleUnit::Degree); // -- atan assert_parsed_expression_simplify_to("atan(-1)", "-P/4"); assert_parsed_expression_simplify_to("atan(-1.2)", "-atan(6/5)"); @@ -497,13 +497,13 @@ QUIZ_CASE(poincare_trigo_simplify) { assert_parsed_expression_simplify_to("atan(tan(-P/7))", "-P/7"); assert_parsed_expression_simplify_to("atan(R(3))", "P/3"); assert_parsed_expression_simplify_to("atan(tan(-R(2)))", "-R(2)"); - assert_parsed_expression_simplify_to("atan(-1)", "-45", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("atan(-1.2)", "-atan(6/5)", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("atan(tan(-45))", "-45", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(atan(120))", "120", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("tan(atan(2293))", "2293", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("atan(tan(2293))", "-47", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("atan(tan(1808))", "8", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("atan(tan(-180/7))", "-180/7", Expression::AngleUnit::Degree); - assert_parsed_expression_simplify_to("atan(R(3))", "60", Expression::AngleUnit::Degree); + assert_parsed_expression_simplify_to("atan(-1)", "-45", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("atan(-1.2)", "-atan(6/5)", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("atan(tan(-45))", "-45", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(atan(120))", "120", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("tan(atan(2293))", "2293", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("atan(tan(2293))", "-47", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("atan(tan(1808))", "8", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("atan(tan(-180/7))", "-180/7", Preferences::AngleUnit::Degree); + assert_parsed_expression_simplify_to("atan(R(3))", "60", Preferences::AngleUnit::Degree); }