diff --git a/apps/apps_container.cpp b/apps/apps_container.cpp index e7438192c..9e11115b0 100644 --- a/apps/apps_container.cpp +++ b/apps/apps_container.cpp @@ -6,11 +6,11 @@ extern "C" { AppsContainer::AppsContainer() : Container(), m_homeApp(this), - m_graphApp(this, &m_context), - m_probabilityApp(this, &m_context), - m_calculationApp(this, &m_context), - m_context(Context()), - m_variableBoxController(&m_context) + m_graphApp(this, &m_globalContext), + m_probabilityApp(this, &m_globalContext), + m_calculationApp(this, &m_globalContext), + m_globalContext(GlobalContext()), + m_variableBoxController(&m_globalContext) { } @@ -30,8 +30,8 @@ App * AppsContainer::appAtIndex(int index) { return apps[index]; } -Context * AppsContainer::context() { - return &m_context; +Context * AppsContainer::globalContext() { + return &m_globalContext; } ToolboxController * AppsContainer::toolboxController() { diff --git a/apps/apps_container.h b/apps/apps_container.h index 76e523054..54758bf41 100644 --- a/apps/apps_container.h +++ b/apps/apps_container.h @@ -19,7 +19,7 @@ public: int numberOfApps(); App * appAtIndex(int index); - Context * context(); + Context * globalContext(); ToolboxController * toolboxController(); VariableBoxController * variableBoxController(); bool handleEvent(Ion::Events::Event event) override; @@ -32,7 +32,7 @@ private: #if USE_PIC_VIEW_APP PicViewApp m_picViewApp; #endif - Context m_context; + GlobalContext m_globalContext; ToolboxController m_toolboxController; VariableBoxController m_variableBoxController; }; diff --git a/apps/calculation/Makefile b/apps/calculation/Makefile index 95649474f..e5f464fcf 100644 --- a/apps/calculation/Makefile +++ b/apps/calculation/Makefile @@ -2,12 +2,12 @@ app_objs += $(addprefix apps/calculation/,\ app.o\ calculation.o\ calculation_store.o\ - evaluate_context.o\ - selectable_table_view.o\ + edit_expression_controller.o\ history_view_cell.o\ history_controller.o\ - edit_expression_controller.o\ + local_context.o\ scrollable_expression_view.o\ + selectable_table_view.o\ text_field.o\ ) diff --git a/apps/calculation/app.cpp b/apps/calculation/app.cpp index d64a46f4e..3802119c4 100644 --- a/apps/calculation/app.cpp +++ b/apps/calculation/app.cpp @@ -6,15 +6,15 @@ namespace Calculation { App::App(Container * container, Context * context) : ::App(container, &m_editExpressionController, "Calcul", ImageStore::CalculationIcon), ExpressionTextFieldDelegate(), - m_evaluateContext(EvaluateContext(context, &m_calculationStore)), + m_localContext(LocalContext((GlobalContext *)context, &m_calculationStore)), m_calculationStore(CalculationStore()), m_historyController(HistoryController(&m_editExpressionController, &m_calculationStore)), m_editExpressionController(EditExpressionController(&m_modalViewController, &m_historyController, &m_calculationStore)) { } -Context * App::evaluateContext() { - return &m_evaluateContext; +Context * App::localContext() { + return &m_localContext; } } diff --git a/apps/calculation/app.h b/apps/calculation/app.h index 978cbc091..c4a4e0d87 100644 --- a/apps/calculation/app.h +++ b/apps/calculation/app.h @@ -2,7 +2,7 @@ #define CALCULATION_APP_H #include "edit_expression_controller.h" -#include "evaluate_context.h" +#include "local_context.h" #include "history_controller.h" #include "../expression_text_field_delegate.h" #include @@ -12,9 +12,9 @@ namespace Calculation { class App : public ::App, public ExpressionTextFieldDelegate { public: App(Container * container, Context * context); - Context * evaluateContext() override; + Context * localContext() override; private: - EvaluateContext m_evaluateContext; + LocalContext m_localContext; CalculationStore m_calculationStore; HistoryController m_historyController; EditExpressionController m_editExpressionController; diff --git a/apps/calculation/edit_expression_controller.cpp b/apps/calculation/edit_expression_controller.cpp index 14dbdb922..cee7730ed 100644 --- a/apps/calculation/edit_expression_controller.cpp +++ b/apps/calculation/edit_expression_controller.cpp @@ -89,7 +89,7 @@ bool EditExpressionController::textFieldDidReceiveEvent(::TextField * textField, bool EditExpressionController::textFieldDidFinishEditing(::TextField * textField, const char * text) { Calculation calculation = Calculation(); App * calculationApp = (App *)app(); - calculation.setContent(textBody(), calculationApp->evaluateContext()); + calculation.setContent(textBody(), calculationApp->localContext()); m_calculationStore->push(&calculation); m_historyController->reload(); m_contentView.mainView()->scrollToCell(0, m_historyController->numberOfRows()-1); diff --git a/apps/calculation/evaluate_context.cpp b/apps/calculation/evaluate_context.cpp deleted file mode 100644 index 764d3b874..000000000 --- a/apps/calculation/evaluate_context.cpp +++ /dev/null @@ -1,30 +0,0 @@ -#include "evaluate_context.h" -#include - -namespace Calculation { - -EvaluateContext::EvaluateContext(::Context * parentContext, CalculationStore * calculationStore) : - m_ansValue(nullptr), - m_calculationStore(calculationStore), - m_context(parentContext) -{ -} - -Expression * EvaluateContext::ansValue() { - if (m_calculationStore->numberOfCalculations() == 0) { - return defaultExpression(); - } - Calculation * lastCalculation = m_calculationStore->calculationAtIndex(m_calculationStore->numberOfCalculations()-1); - m_ansValue = lastCalculation->output(); - return m_ansValue; -} - -const Expression * EvaluateContext::expressionForSymbol(const Symbol * symbol) { - if (symbol->name() == Symbol::SpecialSymbols::Ans) { - return ansValue(); - } else { - return m_context->expressionForSymbol(symbol); - } -} - -} diff --git a/apps/calculation/evaluate_context.h b/apps/calculation/evaluate_context.h deleted file mode 100644 index 6721ddf8f..000000000 --- a/apps/calculation/evaluate_context.h +++ /dev/null @@ -1,22 +0,0 @@ -#ifndef CALCULATION_EVALUATECONTEXT_H -#define CALCULATION_EVALUATECONTEXT_H - -#include -#include "calculation_store.h" - -namespace Calculation { - -class EvaluateContext : public ::Context { - public: - EvaluateContext(Context * parentContext, CalculationStore * calculationStore); - Expression * ansValue(); - const Expression * expressionForSymbol(const Symbol * symbol) override; - private: - Expression * m_ansValue; - CalculationStore * m_calculationStore; - ::Context * m_context; -}; - -} - -#endif \ No newline at end of file diff --git a/apps/calculation/history_controller.cpp b/apps/calculation/history_controller.cpp index 42bbc5765..e17c93c87 100644 --- a/apps/calculation/history_controller.cpp +++ b/apps/calculation/history_controller.cpp @@ -68,7 +68,7 @@ bool HistoryController::handleEvent(Ion::Events::Event event) { calculation->output()->writeTextInBuffer(outputText, Calculation::k_maximalExpressionTextLength); /* TODO: this will work when we will parse float */ //App * calculationApp = (App *)app(); - //newCalculation.setContent(outputText, calculationApp->evaluateContext()); + //newCalculation.setContent(outputText, calculationApp->localContext()); } m_selectableTableView.deselectTable(); m_calculationStore->push(&newCalculation); diff --git a/apps/calculation/local_context.cpp b/apps/calculation/local_context.cpp new file mode 100644 index 000000000..d84e4de89 --- /dev/null +++ b/apps/calculation/local_context.cpp @@ -0,0 +1,34 @@ +#include "local_context.h" +#include + +namespace Calculation { + +LocalContext::LocalContext(GlobalContext * parentContext, CalculationStore * calculationStore) : + m_calculationStore(calculationStore), + m_parentContext(parentContext) +{ +} + +Expression * LocalContext::ansValue() { + if (m_calculationStore->numberOfCalculations() == 0) { + return m_parentContext->defaultExpression(); + } + Calculation * lastCalculation = m_calculationStore->calculationAtIndex(m_calculationStore->numberOfCalculations()-1); + return lastCalculation->output(); +} + +void LocalContext::setExpressionForSymbolName(Expression * expression, const Symbol * symbol) { + if (symbol->name() != Symbol::SpecialSymbols::Ans) { + m_parentContext->setExpressionForSymbolName(expression, symbol); + } +} + +const Expression * LocalContext::expressionForSymbol(const Symbol * symbol) { + if (symbol->name() == Symbol::SpecialSymbols::Ans) { + return ansValue(); + } else { + return m_parentContext->expressionForSymbol(symbol); + } +} + +} diff --git a/apps/calculation/local_context.h b/apps/calculation/local_context.h new file mode 100644 index 000000000..98521bcd5 --- /dev/null +++ b/apps/calculation/local_context.h @@ -0,0 +1,22 @@ +#ifndef CALCULATION_LOCAL_CONTEXT_H +#define CALCULATION_LOCAL_CONTEXT_H + +#include +#include "calculation_store.h" + +namespace Calculation { + +class LocalContext : public Context { +public: + LocalContext(GlobalContext * parentContext, CalculationStore * calculationStore); + void setExpressionForSymbolName(Expression * expression, const Symbol * symbol) override; + const Expression * expressionForSymbol(const Symbol * symbol) override; +private: + Expression * ansValue(); + CalculationStore * m_calculationStore; + GlobalContext * m_parentContext; +}; + +} + +#endif \ No newline at end of file diff --git a/apps/expression_text_field_delegate.cpp b/apps/expression_text_field_delegate.cpp index 4dd8f94e7..b6c8aa125 100644 --- a/apps/expression_text_field_delegate.cpp +++ b/apps/expression_text_field_delegate.cpp @@ -32,7 +32,7 @@ bool ExpressionTextFieldDelegate::textFieldDidReceiveEvent(TextField * textField textField->app()->displayWarning("Attention a la syntaxe jeune padawan"); return true; } - Expression * evaluation = exp->evaluate(*evaluateContext()); + Expression * evaluation = exp->evaluate(*localContext()); if (evaluation == nullptr) { delete exp; textField->app()->displayWarning("Relis ton cours de maths, veux tu?"); diff --git a/apps/expression_text_field_delegate.h b/apps/expression_text_field_delegate.h index 300e5bd17..fc86f299f 100644 --- a/apps/expression_text_field_delegate.h +++ b/apps/expression_text_field_delegate.h @@ -6,7 +6,7 @@ class ExpressionTextFieldDelegate : public TextFieldDelegate { public: - virtual Context * evaluateContext() = 0; + virtual Context * localContext() = 0; virtual const char * XNT(); bool textFieldDidReceiveEvent(TextField * textField, Ion::Events::Event event) override; private: diff --git a/apps/float_parameter_controller.cpp b/apps/float_parameter_controller.cpp index dd3c147d2..0f29080cf 100644 --- a/apps/float_parameter_controller.cpp +++ b/apps/float_parameter_controller.cpp @@ -32,7 +32,7 @@ void FloatParameterController::willDisplayCellForIndex(TableViewCell * cell, int bool FloatParameterController::textFieldDidFinishEditing(TextField * textField, const char * text) { AppsContainer * appsContainer = (AppsContainer *)app()->container(); - Context * globalContext = appsContainer->context(); + Context * globalContext = appsContainer->globalContext(); float floatBody = Expression::parse(text)->approximate(*globalContext); setParameterAtIndex(m_selectableTableView.selectedRow(), floatBody); willDisplayCellForIndex(m_selectableTableView.cellAtLocation(m_selectableTableView.selectedColumn(), diff --git a/apps/graph/Makefile b/apps/graph/Makefile index 94fd50153..12869b1c7 100644 --- a/apps/graph/Makefile +++ b/apps/graph/Makefile @@ -1,6 +1,5 @@ app_objs += $(addprefix apps/graph/,\ app.o\ - evaluate_context.o\ function.o\ function_store.o\ function_title_cell.o\ @@ -17,6 +16,7 @@ app_objs += $(addprefix apps/graph/,\ list/new_function_cell.o\ list/list_controller.o\ list/parameter_controller.o\ + local_context.o\ values/abscissa_parameter_controller.o\ values/derivative_parameter_controller.o\ values/editable_value_cell.o\ diff --git a/apps/graph/app.cpp b/apps/graph/app.cpp index a6ea1841f..c36430d03 100644 --- a/apps/graph/app.cpp +++ b/apps/graph/app.cpp @@ -7,7 +7,7 @@ App::App(Container * container, Context * context) : ::App(container, &m_inputViewController, "Graph", ImageStore::GraphIcon), ExpressionTextFieldDelegate(), m_functionStore(FunctionStore()), - m_evaluateContext(EvaluateContext(context)), + m_localContext(LocalContext(context)), m_listController(ListController(&m_listHeader, &m_functionStore, &m_listHeader)), m_listHeader(HeaderViewController(nullptr, &m_listController, &m_listController)), m_listStackViewController(StackViewController(&m_tabViewController, &m_listHeader)), @@ -28,8 +28,8 @@ InputViewController * App::inputViewController() { return &m_inputViewController; } -Context * App::evaluateContext() { - return &m_evaluateContext; +Context * App::localContext() { + return &m_localContext; } } diff --git a/apps/graph/app.h b/apps/graph/app.h index 0512fdf1e..85ef0e517 100644 --- a/apps/graph/app.h +++ b/apps/graph/app.h @@ -3,7 +3,7 @@ #include #include "function_store.h" -#include "evaluate_context.h" +#include "local_context.h" #include "graph/graph_controller.h" #include "list/list_controller.h" #include "values/values_controller.h" @@ -15,10 +15,10 @@ class App : public ::App, public ExpressionTextFieldDelegate { public: App(Container * container, Context * context); InputViewController * inputViewController(); - Context * evaluateContext() override; + Context * localContext() override; private: FunctionStore m_functionStore; - EvaluateContext m_evaluateContext; + LocalContext m_localContext; ListController m_listController; HeaderViewController m_listHeader; StackViewController m_listStackViewController; diff --git a/apps/graph/evaluate_context.cpp b/apps/graph/evaluate_context.cpp deleted file mode 100644 index f2f12e7bd..000000000 --- a/apps/graph/evaluate_context.cpp +++ /dev/null @@ -1,24 +0,0 @@ -#include "evaluate_context.h" -#include - -namespace Graph { - -EvaluateContext::EvaluateContext(::Context * parentContext) : - m_xValue(Float(0.0f)), - m_context(parentContext) -{ -} - -void EvaluateContext::setOverridenValueForSymbolX(float f) { - m_xValue = Float(f); -} - -const Expression * EvaluateContext::expressionForSymbol(const Symbol * symbol) { - if (symbol->name() == 'x') { - return &m_xValue; - } else { - return m_context->expressionForSymbol(symbol); - } -} - -} diff --git a/apps/graph/evaluate_context.h b/apps/graph/evaluate_context.h deleted file mode 100644 index 93aa92947..000000000 --- a/apps/graph/evaluate_context.h +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef GRAPH_EVALUATECONTEXT_H -#define GRAPH_EVALUATECONTEXT_H - -#include - -namespace Graph { - -class EvaluateContext : public ::Context { - public: - EvaluateContext(Context * parentContext); - void setOverridenValueForSymbolX(float f); - const Expression * expressionForSymbol(const Symbol * symbol) override; - private: - Float m_xValue; - ::Context * m_context; -}; - -} - -#endif \ No newline at end of file diff --git a/apps/graph/function.cpp b/apps/graph/function.cpp index 3a49e7176..a69a0beda 100644 --- a/apps/graph/function.cpp +++ b/apps/graph/function.cpp @@ -74,12 +74,14 @@ void Function::setDisplayDerivative(bool display) { m_displayDerivative = display; } -float Function::evaluateAtAbscissa(float x, EvaluateContext * context) const { - context->setOverridenValueForSymbolX(x); +float Function::evaluateAtAbscissa(float x, Context * context) const { + Symbol xSymbol = Symbol('x'); + Float e = Float(x); + context->setExpressionForSymbolName(&e, &xSymbol); return m_expression->approximate(*context); } -float Function::approximateDerivative(float x, EvaluateContext * context) const { +float Function::approximateDerivative(float x, Context * context) const { float functionPlus = evaluateAtAbscissa(x + k_epsilon, context); float functionMinus = evaluateAtAbscissa(x - k_epsilon, context); float growthRate = (functionPlus - functionMinus)/(2*k_epsilon); diff --git a/apps/graph/function.h b/apps/graph/function.h index 56bab2ebe..d55778d2d 100644 --- a/apps/graph/function.h +++ b/apps/graph/function.h @@ -3,7 +3,6 @@ #include #include -#include "evaluate_context.h" namespace Graph { @@ -24,8 +23,8 @@ public: void setDisplayDerivative(bool display); void setContent(const char * c); void setColor(KDColor m_color); - float evaluateAtAbscissa(float x, EvaluateContext * context) const; - float approximateDerivative(float x, EvaluateContext * context) const; + float evaluateAtAbscissa(float x, Context * context) const; + float approximateDerivative(float x, Context * context) const; private: constexpr static float k_epsilon = 0.0001f; constexpr static int k_bodyLength = 255; diff --git a/apps/graph/graph/graph_controller.cpp b/apps/graph/graph/graph_controller.cpp index 921bf4b24..a6e930b16 100644 --- a/apps/graph/graph/graph_controller.cpp +++ b/apps/graph/graph/graph_controller.cpp @@ -103,11 +103,11 @@ Button * GraphController::buttonAtIndex(int index) { void GraphController::didBecomeFirstResponder() { if (m_view.context() == nullptr) { App * graphApp = (Graph::App *)app(); - m_view.setContext(graphApp->evaluateContext()); + m_view.setContext(graphApp->localContext()); } if (m_graphWindow.context() == nullptr) { App * graphApp = (Graph::App *)app(); - m_graphWindow.setContext(graphApp->evaluateContext()); + m_graphWindow.setContext(graphApp->localContext()); } // if new functions were added to the store, the window parameters need to be refresh if (m_graphWindow.computeYaxes()) { diff --git a/apps/graph/graph/graph_view.cpp b/apps/graph/graph/graph_view.cpp index 9956469bb..faf7e00fe 100644 --- a/apps/graph/graph/graph_view.cpp +++ b/apps/graph/graph/graph_view.cpp @@ -15,7 +15,7 @@ GraphView::GraphView(FunctionStore * functionStore, GraphWindow * graphWindow) : m_visibleCursor(true), m_graphWindow(graphWindow), m_functionStore(functionStore), - m_evaluateContext(nullptr) + m_context(nullptr) { } @@ -29,11 +29,11 @@ View * GraphView::subviewAtIndex(int index) { } void GraphView::setContext(Context * context) { - m_evaluateContext = (EvaluateContext *)context; + m_context = context; } Context * GraphView::context() const { - return m_evaluateContext; + return m_context; } int GraphView::indexFunctionSelectedByCursor() { @@ -71,7 +71,7 @@ float GraphView::xCursorPosition() { void GraphView::goToAbscissaOnFunction(float abscissa, Function * function) { m_graphWindow->centerAxisAround(GraphWindow::Axis::X, abscissa); m_xCursorPosition = floatToPixel(Axis::Horizontal, abscissa); - float ordinate = function->evaluateAtAbscissa(abscissa, m_evaluateContext); + float ordinate = function->evaluateAtAbscissa(abscissa, m_context); m_graphWindow->centerAxisAround(GraphWindow::Axis::Y, ordinate); m_yCursorPosition = floatToPixel(Axis::Vertical, ordinate); reload(); @@ -86,7 +86,7 @@ void GraphView::initCursorPosition() { float center = (min(Axis::Horizontal)+max(Axis::Horizontal))/2.0f; m_indexFunctionSelectedByCursor = 0; Function * firstFunction = m_functionStore->activeFunctionAtIndex(0); - float fCenter = firstFunction->evaluateAtAbscissa(center, m_evaluateContext); + float fCenter = firstFunction->evaluateAtAbscissa(center, m_context); m_xCursorPosition = (bounds().width()-1.0f)/2.0f; m_yCursorPosition = floatToPixel(Axis::Vertical, fCenter); } @@ -96,7 +96,7 @@ void GraphView::moveCursorHorizontally(KDCoordinate xOffset) { m_xCursorPosition = m_xCursorPosition + xOffset; float x = pixelToFloat(Axis::Horizontal, m_xCursorPosition); Function * f = m_functionStore->activeFunctionAtIndex(m_indexFunctionSelectedByCursor); - float y = f->evaluateAtAbscissa(x, m_evaluateContext); + float y = f->evaluateAtAbscissa(x, m_context); float xMargin = pixelToFloat(Axis::Horizontal, k_cursorMarginToBorder) - pixelToFloat(Axis::Horizontal, 0); float yMargin = pixelToFloat(Axis::Vertical, 0) - pixelToFloat(Axis::Vertical, k_cursorMarginToBorder); bool windowHasMoved = m_graphWindow->panToMakePointVisible(x, y, xMargin, yMargin); @@ -112,12 +112,12 @@ void GraphView::moveCursorHorizontally(KDCoordinate xOffset) { Function * GraphView::moveCursorVertically(int direction) { float x = pixelToFloat(Axis::Horizontal, m_xCursorPosition); Function * actualFunction = m_functionStore->activeFunctionAtIndex(m_indexFunctionSelectedByCursor); - float y = actualFunction->evaluateAtAbscissa(x, m_evaluateContext); + float y = actualFunction->evaluateAtAbscissa(x, m_context); Function * nextFunction = actualFunction; float nextY = direction > 0 ? FLT_MAX : -FLT_MAX; for (int i = 0; i < m_functionStore->numberOfActiveFunctions(); i++) { Function * f = m_functionStore->activeFunctionAtIndex(i); - float newY = f->evaluateAtAbscissa(x, m_evaluateContext); + float newY = f->evaluateAtAbscissa(x, m_context); bool isNextFunction = direction > 0 ? (newY > y && newY < nextY) : (newY < y && newY > nextY); if (isNextFunction) { m_indexFunctionSelectedByCursor = i; @@ -195,8 +195,10 @@ float GraphView::max(Axis axis) const { } float GraphView::evaluateExpressionAtAbscissa(Expression * expression, float abscissa) const { - m_evaluateContext->setOverridenValueForSymbolX(abscissa); - return expression->approximate(*m_evaluateContext); + Symbol xSymbol = Symbol('x'); + Float e = Float(abscissa); + m_context->setExpressionForSymbolName(&e, &xSymbol); + return expression->approximate(*m_context); } } diff --git a/apps/graph/graph/graph_view.h b/apps/graph/graph/graph_view.h index 7fd4da499..d10243091 100644 --- a/apps/graph/graph/graph_view.h +++ b/apps/graph/graph/graph_view.h @@ -7,7 +7,7 @@ #include "../../curve_view.h" #include "../../constant.h" #include "../function_store.h" -#include "../evaluate_context.h" +#include "../local_context.h" namespace Graph { @@ -23,7 +23,7 @@ public: void initCursorPosition(); void moveCursorHorizontally(KDCoordinate xOffset); Function * moveCursorVertically(int direction); - void setContext(Context * evaluateContext); + void setContext(Context * context); Context * context() const; int indexFunctionSelectedByCursor(); void reload(); @@ -56,7 +56,7 @@ private: GraphWindow * m_graphWindow; FunctionStore * m_functionStore; - EvaluateContext * m_evaluateContext; + Context * m_context; }; } diff --git a/apps/graph/graph/graph_window.cpp b/apps/graph/graph/graph_window.cpp index da1cdf291..72d74d185 100644 --- a/apps/graph/graph/graph_window.cpp +++ b/apps/graph/graph/graph_window.cpp @@ -16,7 +16,7 @@ GraphWindow::GraphWindow(FunctionStore * functionStore) : m_xGridUnit(2.0f), m_yGridUnit(2.0f), m_functionStore(functionStore), - m_evaluateContext(nullptr) + m_context(nullptr) { } @@ -87,7 +87,7 @@ bool GraphWindow::computeYaxes() { Function * f = m_functionStore->activeFunctionAtIndex(i); float y = 0.0f; for (float x = m_xMin; x <= m_xMax; x += step) { - y = f->evaluateAtAbscissa(x, m_evaluateContext); + y = f->evaluateAtAbscissa(x, m_context); if (!isnan(y) && !isinf(y)) { min = min < y ? min : y; max = max > y ? max : y; @@ -109,11 +109,11 @@ bool GraphWindow::computeYaxes() { } Context * GraphWindow::context() { - return m_evaluateContext; + return m_context; } void GraphWindow::setContext(Context * context) { - m_evaluateContext = (EvaluateContext *)context; + m_context = context; } void GraphWindow::zoom(float ratio) { diff --git a/apps/graph/graph/graph_window.h b/apps/graph/graph/graph_window.h index 14adac251..eb1b94835 100644 --- a/apps/graph/graph/graph_window.h +++ b/apps/graph/graph/graph_window.h @@ -2,7 +2,6 @@ #define GRAPH_GRAPH_AXIS_INTERVAL_H #include "../function_store.h" -#include "../evaluate_context.h" namespace Graph { @@ -61,7 +60,7 @@ private: float m_xGridUnit; float m_yGridUnit; FunctionStore * m_functionStore; - EvaluateContext * m_evaluateContext; + Context * m_context; }; } diff --git a/apps/graph/graph/window_parameter_controller.cpp b/apps/graph/graph/window_parameter_controller.cpp index 18bdc34a1..320523e68 100644 --- a/apps/graph/graph/window_parameter_controller.cpp +++ b/apps/graph/graph/window_parameter_controller.cpp @@ -42,7 +42,7 @@ void WindowParameterController::willDisplayCellForIndex(TableViewCell * cell, in bool WindowParameterController::textFieldDidFinishEditing(TextField * textField, const char * text) { AppsContainer * appsContainer = (AppsContainer *)app()->container(); - Context * globalContext = appsContainer->context(); + Context * globalContext = appsContainer->globalContext(); float floatBody = Expression::parse(text)->approximate(*globalContext); setParameterAtIndex(m_selectableTableView.selectedRow(), floatBody); willDisplayCellForIndex(m_selectableTableView.cellAtLocation(m_selectableTableView.selectedColumn(), diff --git a/apps/graph/local_context.cpp b/apps/graph/local_context.cpp new file mode 100644 index 000000000..541ced6b2 --- /dev/null +++ b/apps/graph/local_context.cpp @@ -0,0 +1,28 @@ +#include "local_context.h" +#include + +namespace Graph { + +LocalContext::LocalContext(::Context * parentContext) : + m_xValue(Float(0.0f)), + m_parentContext(parentContext) +{ +} + +void LocalContext::setExpressionForSymbolName(Expression * expression, const Symbol * symbol) { + if (symbol->name() == 'x') { + m_xValue = Float(expression->approximate(*m_parentContext)); + } else { + m_parentContext->setExpressionForSymbolName(expression, symbol); + } +} + +const Expression * LocalContext::expressionForSymbol(const Symbol * symbol) { + if (symbol->name() == 'x') { + return &m_xValue; + } else { + return m_parentContext->expressionForSymbol(symbol); + } +} + +} diff --git a/apps/graph/local_context.h b/apps/graph/local_context.h new file mode 100644 index 000000000..5e8346e97 --- /dev/null +++ b/apps/graph/local_context.h @@ -0,0 +1,20 @@ +#ifndef GRAPH_LOCAL_CONTEXT_H +#define GRAPH_LOCAL_CONTEXT_H + +#include + +namespace Graph { + +class LocalContext : public Context { +public: + LocalContext(Context * parentContext); + void setExpressionForSymbolName(Expression * expression, const Symbol * symbol) override; + const Expression * expressionForSymbol(const Symbol * symbol) override; +private: + Float m_xValue; + Context * m_parentContext; +}; + +} + +#endif \ No newline at end of file diff --git a/apps/graph/values/values_controller.cpp b/apps/graph/values/values_controller.cpp index d3c772f54..4c5491071 100644 --- a/apps/graph/values/values_controller.cpp +++ b/apps/graph/values/values_controller.cpp @@ -217,7 +217,7 @@ bool ValuesController::textFieldDidReceiveEvent(TextField * textField, Ion::Even bool ValuesController::textFieldDidFinishEditing(TextField * textField, const char * text) { AppsContainer * appsContainer = (AppsContainer *)app()->container(); - Context * globalContext = appsContainer->context(); + Context * globalContext = appsContainer->globalContext(); float floatBody = Expression::parse(text)->approximate(*globalContext); m_interval.setElement(activeRow()-1, floatBody); willDisplayCellAtLocation(m_selectableTableView.cellAtLocation(activeColumn(), activeRow()), activeColumn(), activeRow()); @@ -365,9 +365,9 @@ void ValuesController::willDisplayCellAtLocation(TableViewCell * cell, int i, in float x = m_interval.element(j-1); App * graphApp = (Graph::App *)app(); if (isDerivativeColumn(i)) { - Float(function->approximateDerivative(x, (EvaluateContext *)graphApp->evaluateContext())).convertFloatToText(buffer, Constant::FloatBufferSizeInScientificMode, Constant::NumberOfDigitsInMantissaForDerivativeNumberInScientificMode); + Float(function->approximateDerivative(x, graphApp->localContext())).convertFloatToText(buffer, Constant::FloatBufferSizeInScientificMode, Constant::NumberOfDigitsInMantissaForDerivativeNumberInScientificMode); } else { - Float(function->evaluateAtAbscissa(x, (EvaluateContext *)graphApp->evaluateContext())).convertFloatToText(buffer, Constant::FloatBufferSizeInScientificMode, Constant::NumberOfDigitsInMantissaInScientificMode); + Float(function->evaluateAtAbscissa(x, graphApp->localContext())).convertFloatToText(buffer, Constant::FloatBufferSizeInScientificMode, Constant::NumberOfDigitsInMantissaInScientificMode); } myValueCell->setText(buffer); } diff --git a/apps/probability/Makefile b/apps/probability/Makefile index f0eca7332..059a36387 100644 --- a/apps/probability/Makefile +++ b/apps/probability/Makefile @@ -3,7 +3,6 @@ app_objs += $(addprefix apps/probability/,\ calculation.o\ calculation_controller.o\ cell.o\ - evaluate_context.o\ image_table_view.o\ law/binomial_law.o\ law/exponential_law.o\ @@ -15,6 +14,7 @@ app_objs += $(addprefix apps/probability/,\ law/uniform_law.o\ law_controller.o\ law_curve_view.o\ + local_context.o\ parameters_controller.o\ ) diff --git a/apps/probability/app.cpp b/apps/probability/app.cpp index f200761a3..a09a82746 100644 --- a/apps/probability/app.cpp +++ b/apps/probability/app.cpp @@ -5,14 +5,14 @@ namespace Probability { App::App(Container * container, Context * context) : ::App(container, &m_stackViewController, "Probability", ImageStore::ProbabilityIcon), - m_evaluateContext(EvaluateContext(context)), - m_lawController(LawController(nullptr, &m_evaluateContext)), + m_localContext(LocalContext(context)), + m_lawController(LawController(nullptr, &m_localContext)), m_stackViewController(&m_modalViewController, &m_lawController, true) { } -Context * App::evaluateContext() { - return &m_evaluateContext; +Context * App::localContext() { + return &m_localContext; } } \ No newline at end of file diff --git a/apps/probability/app.h b/apps/probability/app.h index 511f9027e..6b5cfc478 100644 --- a/apps/probability/app.h +++ b/apps/probability/app.h @@ -2,8 +2,9 @@ #define PROBABILITY_PROBABILITY_APP_H #include +#include #include "law_controller.h" -#include "evaluate_context.h" +#include "local_context.h" #include "../expression_text_field_delegate.h" namespace Probability { @@ -15,9 +16,9 @@ public: Student }; App(Container * container, Context * context); - Context * evaluateContext() override; + Context * localContext() override; private: - EvaluateContext m_evaluateContext; + LocalContext m_localContext; LawController m_lawController; StackViewController m_stackViewController; }; diff --git a/apps/probability/calculation.h b/apps/probability/calculation.h index d1887c3a3..0fa606cb7 100644 --- a/apps/probability/calculation.h +++ b/apps/probability/calculation.h @@ -1,7 +1,6 @@ #ifndef PROBABILITE_CALCULATION_H #define PROBABILITE_CALCULATION_H -#include "evaluate_context.h" #include "law/law.h" namespace Probability { diff --git a/apps/probability/calculation_controller.cpp b/apps/probability/calculation_controller.cpp index 43e0f1907..82e244418 100644 --- a/apps/probability/calculation_controller.cpp +++ b/apps/probability/calculation_controller.cpp @@ -190,7 +190,7 @@ bool CalculationController::textFieldDidReceiveEvent(TextField * textField, Ion: bool CalculationController::textFieldDidFinishEditing(TextField * textField, const char * text) { AppsContainer * appsContainer = (AppsContainer *)app()->container(); - Context * globalContext = appsContainer->context(); + Context * globalContext = appsContainer->globalContext(); float floatBody = Expression::parse(text)->approximate(*globalContext); m_calculation.setParameterAtIndex(floatBody, m_highlightedSubviewIndex-1); for (int k = 0; k < ContentView::k_maxNumberOfEditableFields; k++) { diff --git a/apps/probability/evaluate_context.cpp b/apps/probability/evaluate_context.cpp deleted file mode 100644 index 87236cf1a..000000000 --- a/apps/probability/evaluate_context.cpp +++ /dev/null @@ -1,39 +0,0 @@ -#include "evaluate_context.h" -#include - -namespace Probability { - -EvaluateContext::EvaluateContext(::Context * parentContext) : - m_tValue(Float(0.0f)), - m_firstParameterValue(Float(0.0f)), - m_secondParameterValue(Float(0.0f)), - m_context(parentContext) -{ -} - -void EvaluateContext::setOverridenValueForSymbolT(float f) { - m_tValue = Float(f); -} - -void EvaluateContext::setOverridenValueForFirstParameter(float f) { - m_firstParameterValue = Float(f); -} - -void EvaluateContext::setOverridenValueForSecondParameter(float f) { - m_secondParameterValue = Float(f); -} - -const Expression * EvaluateContext::expressionForSymbol(const Symbol * symbol) { - if (symbol->name() == 't') { - return &m_tValue; - } - if (symbol->name() == Symbol::SpecialSymbols::p1) { - return &m_firstParameterValue; - } - if (symbol->name() == Symbol::SpecialSymbols::p2) { - return &m_secondParameterValue; - } - return m_context->expressionForSymbol(symbol); -} - -} diff --git a/apps/probability/evaluate_context.h b/apps/probability/evaluate_context.h deleted file mode 100644 index 997533b06..000000000 --- a/apps/probability/evaluate_context.h +++ /dev/null @@ -1,24 +0,0 @@ -#ifndef PROBABILITY_EVALUATECONTEXT_H -#define PROBABILITY_EVALUATECONTEXT_H - -#include - -namespace Probability { - -class EvaluateContext : public ::Context { - public: - EvaluateContext(Context * parentContext); - void setOverridenValueForSymbolT(float f); - void setOverridenValueForFirstParameter(float f); - void setOverridenValueForSecondParameter(float f); - const Expression * expressionForSymbol(const Symbol * symbol) override; - private: - Float m_tValue; - Float m_firstParameterValue; - Float m_secondParameterValue; - ::Context * m_context; -}; - -} - -#endif \ No newline at end of file diff --git a/apps/probability/law/binomial_law.cpp b/apps/probability/law/binomial_law.cpp index ee7b28205..7951ce64c 100644 --- a/apps/probability/law/binomial_law.cpp +++ b/apps/probability/law/binomial_law.cpp @@ -3,11 +3,11 @@ namespace Probability { -BinomialLaw::BinomialLaw(EvaluateContext * evaluateContext) : - TwoParameterLaw(evaluateContext), - m_expression(Expression::parse("p1-p2*t")) +BinomialLaw::BinomialLaw(Context * context) : + TwoParameterLaw(context), + m_expression(Expression::parse("a-b*t")) { - //m_expression = Expression::parse("binomial(p1, p2)*p2^t*(1-p2)^(p1-t)"); + //m_expression = Expression::parse("binomial(a, b)*b^t*(1-b)^(a-t)"); assert(m_expression != nullptr); } diff --git a/apps/probability/law/binomial_law.h b/apps/probability/law/binomial_law.h index c0b32786c..4d38e2fbc 100644 --- a/apps/probability/law/binomial_law.h +++ b/apps/probability/law/binomial_law.h @@ -7,7 +7,7 @@ namespace Probability { class BinomialLaw : public TwoParameterLaw { public: - BinomialLaw(EvaluateContext * evaluateContext); + BinomialLaw(Context * context); ~BinomialLaw() override; const char * title() override; Expression * expression() const override; diff --git a/apps/probability/law/exponential_law.cpp b/apps/probability/law/exponential_law.cpp index 562d09a76..902836bc9 100644 --- a/apps/probability/law/exponential_law.cpp +++ b/apps/probability/law/exponential_law.cpp @@ -3,11 +3,11 @@ namespace Probability { -ExponentialLaw::ExponentialLaw(EvaluateContext * evaluateContext) : - OneParameterLaw(evaluateContext), - m_expression(Expression::parse("p1*t")) +ExponentialLaw::ExponentialLaw(Context * context) : + OneParameterLaw(context), + m_expression(Expression::parse("a*t")) { - //m_expression = Expression::parse("p1*exp(-p1*t)"); + //m_expression = Expression::parse("a*exp(-a*t)"); assert(m_expression != nullptr); } diff --git a/apps/probability/law/exponential_law.h b/apps/probability/law/exponential_law.h index 164606516..e063b7fa3 100644 --- a/apps/probability/law/exponential_law.h +++ b/apps/probability/law/exponential_law.h @@ -7,7 +7,7 @@ namespace Probability { class ExponentialLaw : public OneParameterLaw { public: - ExponentialLaw(EvaluateContext * evaluateContext); + ExponentialLaw(Context * context); ~ExponentialLaw() override; const char * title() override; Expression * expression() const override; diff --git a/apps/probability/law/law.cpp b/apps/probability/law/law.cpp index 331736f48..f46901818 100644 --- a/apps/probability/law/law.cpp +++ b/apps/probability/law/law.cpp @@ -3,13 +3,13 @@ namespace Probability { -Law::Law(EvaluateContext * evaluateContext): - m_evaluateContext(evaluateContext) +Law::Law(Context * context): + m_context(context) { } -EvaluateContext * Law::evaluateContext() { - return m_evaluateContext; +Context * Law::context() { + return m_context; } float Law::gridUnit() { @@ -28,8 +28,10 @@ float Law::gridUnit() { } float Law::evaluateAtAbscissa(float t) const { - m_evaluateContext->setOverridenValueForSymbolT(t); - return expression()->approximate(*m_evaluateContext); + Symbol tSymbol = Symbol('t'); + Float e = Float(t); + m_context->setExpressionForSymbolName(&e, &tSymbol); + return expression()->approximate(*m_context); } } diff --git a/apps/probability/law/law.h b/apps/probability/law/law.h index 731068f3c..635c4d696 100644 --- a/apps/probability/law/law.h +++ b/apps/probability/law/law.h @@ -1,7 +1,7 @@ #ifndef PROBABILITE_LAW_H #define PROBABILITE_LAW_H -#include "../evaluate_context.h" +#include namespace Probability { @@ -14,10 +14,10 @@ public: Normal, Poisson }; - Law(EvaluateContext * evaluateContext); + Law(Context * context); virtual ~Law() {}; virtual const char * title() = 0; - EvaluateContext * evaluateContext(); + Context * context(); virtual Type type() const = 0; virtual Expression * expression() const = 0; virtual bool isContinuous() = 0; @@ -38,7 +38,7 @@ protected: constexpr static float k_oneUnit = 1.0f; constexpr static float k_twoUnit = 2.0f; constexpr static float k_fiveUnit = 5.0f; - EvaluateContext * m_evaluateContext; + Context * m_context; }; } diff --git a/apps/probability/law/normal_law.cpp b/apps/probability/law/normal_law.cpp index 9f3c86b8a..3af53fbd4 100644 --- a/apps/probability/law/normal_law.cpp +++ b/apps/probability/law/normal_law.cpp @@ -3,11 +3,11 @@ namespace Probability { -NormalLaw::NormalLaw(EvaluateContext * evaluateContext) : - TwoParameterLaw(evaluateContext), - m_expression(Expression::parse("p1-p2*t")) +NormalLaw::NormalLaw(Context * context) : + TwoParameterLaw(context), + m_expression(Expression::parse("a-b*t")) { - //m_expression = Expression::parse("(1/(p2*sqrt(2*Pi))*exp(-0.5*((t-p1)/p2)^2)"); + //m_expression = Expression::parse("(1/(b*sqrt(2*Pi))*exp(-0.5*((t-a)/b)^2)"); assert(m_expression != nullptr); } diff --git a/apps/probability/law/normal_law.h b/apps/probability/law/normal_law.h index a913371e5..e0e7f05ec 100644 --- a/apps/probability/law/normal_law.h +++ b/apps/probability/law/normal_law.h @@ -7,7 +7,7 @@ namespace Probability { class NormalLaw : public TwoParameterLaw { public: - NormalLaw(EvaluateContext * evaluateContext); + NormalLaw(Context * context); ~NormalLaw() override; const char * title() override; Expression * expression() const override; diff --git a/apps/probability/law/one_parameter_law.cpp b/apps/probability/law/one_parameter_law.cpp index 789accdcc..5787ee02a 100644 --- a/apps/probability/law/one_parameter_law.cpp +++ b/apps/probability/law/one_parameter_law.cpp @@ -3,11 +3,13 @@ namespace Probability { -OneParameterLaw::OneParameterLaw(EvaluateContext * evaluateContext) : - Law(evaluateContext), +OneParameterLaw::OneParameterLaw(Context * context) : + Law(context), m_parameter1(0.5f) { - m_evaluateContext->setOverridenValueForFirstParameter(m_parameter1); + Symbol aSymbol = Symbol('a'); + Float e = Float(m_parameter1); + m_context->setExpressionForSymbolName(&e, &aSymbol); } int OneParameterLaw::numberOfParameter() { @@ -22,7 +24,9 @@ float OneParameterLaw::parameterValueAtIndex(int index) { void OneParameterLaw::setParameterAtIndex(float f, int index) { assert(index == 0); m_parameter1 = f; - m_evaluateContext->setOverridenValueForFirstParameter(f); + Symbol aSymbol = Symbol('a'); + Float e = Float(f); + m_context->setExpressionForSymbolName(&e, &aSymbol); } } diff --git a/apps/probability/law/one_parameter_law.h b/apps/probability/law/one_parameter_law.h index 68457904f..0c52f5ce5 100644 --- a/apps/probability/law/one_parameter_law.h +++ b/apps/probability/law/one_parameter_law.h @@ -7,7 +7,7 @@ namespace Probability { class OneParameterLaw : public Law { public: - OneParameterLaw(EvaluateContext * evaluateContext); + OneParameterLaw(Context * context); virtual ~OneParameterLaw() {}; int numberOfParameter() override; float parameterValueAtIndex(int index) override; diff --git a/apps/probability/law/poisson_law.cpp b/apps/probability/law/poisson_law.cpp index 7bbfe043a..98b4f34ce 100644 --- a/apps/probability/law/poisson_law.cpp +++ b/apps/probability/law/poisson_law.cpp @@ -4,11 +4,11 @@ namespace Probability { -PoissonLaw::PoissonLaw(EvaluateContext * evaluateContext) : - OneParameterLaw(evaluateContext), - m_expression(Expression::parse("p1*t")) +PoissonLaw::PoissonLaw(Context * context) : + OneParameterLaw(context), + m_expression(Expression::parse("a*t")) { - //m_expression = Expression::parse("exp(-p1)*p1^t/t!"); + //m_expression = Expression::parse("exp(-a)*a^t/t!"); assert(m_expression != nullptr); } diff --git a/apps/probability/law/poisson_law.h b/apps/probability/law/poisson_law.h index 8ebcc0302..4f9b51227 100644 --- a/apps/probability/law/poisson_law.h +++ b/apps/probability/law/poisson_law.h @@ -7,7 +7,7 @@ namespace Probability { class PoissonLaw : public OneParameterLaw { public: - PoissonLaw(EvaluateContext * evaluateContext); + PoissonLaw(Context * context); ~PoissonLaw() override; const char * title() override; Expression * expression() const override; diff --git a/apps/probability/law/two_parameter_law.cpp b/apps/probability/law/two_parameter_law.cpp index 62f295aeb..f91a005fe 100644 --- a/apps/probability/law/two_parameter_law.cpp +++ b/apps/probability/law/two_parameter_law.cpp @@ -3,13 +3,17 @@ namespace Probability { -TwoParameterLaw::TwoParameterLaw(EvaluateContext * evaluateContext) : - Law(evaluateContext), +TwoParameterLaw::TwoParameterLaw(Context * context) : + Law(context), m_parameter1(0.0f), m_parameter2(0.0f) { - m_evaluateContext->setOverridenValueForFirstParameter(m_parameter1); - m_evaluateContext->setOverridenValueForSecondParameter(m_parameter2); + Symbol aSymbol = Symbol('a'); + Float e1 = Float(m_parameter1); + m_context->setExpressionForSymbolName(&e1, &aSymbol); + Symbol bSymbol = Symbol('b'); + Float e2 = Float(m_parameter2); + m_context->setExpressionForSymbolName(&e2, &bSymbol); } int TwoParameterLaw::numberOfParameter() { @@ -28,10 +32,14 @@ void TwoParameterLaw::setParameterAtIndex(float f, int index) { assert(index >= 0 && index < 2); if (index == 0) { m_parameter1 = f; - m_evaluateContext->setOverridenValueForFirstParameter(f); + Symbol aSymbol = Symbol('a'); + Float e1 = Float(f); + m_context->setExpressionForSymbolName(&e1, &aSymbol); } else { m_parameter2 = f; - m_evaluateContext->setOverridenValueForSecondParameter(f); + Symbol bSymbol = Symbol('b'); + Float e2 = Float(f); + m_context->setExpressionForSymbolName(&e2, &bSymbol); } } diff --git a/apps/probability/law/two_parameter_law.h b/apps/probability/law/two_parameter_law.h index a20889052..051b5e12d 100644 --- a/apps/probability/law/two_parameter_law.h +++ b/apps/probability/law/two_parameter_law.h @@ -7,7 +7,7 @@ namespace Probability { class TwoParameterLaw : public Law { public: - TwoParameterLaw(EvaluateContext * evaluateContext); + TwoParameterLaw(Context * context); virtual ~TwoParameterLaw() {}; int numberOfParameter() override; float parameterValueAtIndex(int index) override; diff --git a/apps/probability/law/uniform_law.cpp b/apps/probability/law/uniform_law.cpp index 8f379d3c4..639ffef17 100644 --- a/apps/probability/law/uniform_law.cpp +++ b/apps/probability/law/uniform_law.cpp @@ -3,11 +3,11 @@ namespace Probability { -UniformLaw::UniformLaw(EvaluateContext * evaluateContext) : - TwoParameterLaw(evaluateContext) +UniformLaw::UniformLaw(Context * context) : + TwoParameterLaw(context) { // TODO: parse indicator function - m_expression = Expression::parse("1/(p2-p1)"); + m_expression = Expression::parse("1/(a-b)"); assert(m_expression != nullptr); } diff --git a/apps/probability/law/uniform_law.h b/apps/probability/law/uniform_law.h index ac7bb7f5d..db5084efe 100644 --- a/apps/probability/law/uniform_law.h +++ b/apps/probability/law/uniform_law.h @@ -7,7 +7,7 @@ namespace Probability { class UniformLaw : public TwoParameterLaw { public: - UniformLaw(EvaluateContext * evaluateContext); + UniformLaw(Context * context); ~UniformLaw() override; const char * title() override; Expression * expression() const override; diff --git a/apps/probability/law_controller.cpp b/apps/probability/law_controller.cpp index bbdaa35ef..c0c765ef1 100644 --- a/apps/probability/law_controller.cpp +++ b/apps/probability/law_controller.cpp @@ -27,12 +27,12 @@ static const char * sMessages[] = { "Poisson" }; -LawController::LawController(Responder * parentResponder, EvaluateContext * evaluateContext) : +LawController::LawController(Responder * parentResponder, Context * context) : ViewController(parentResponder), m_selectableTableView(SelectableTableView(this, this, Metric::TopMargin, Metric::RightMargin, Metric::BottomMargin, Metric::LeftMargin)), m_law(nullptr), - m_evaluateContext(evaluateContext), + m_context(context), m_parametersController(ParametersController(nullptr)) { m_messages = sMessages; @@ -112,19 +112,19 @@ void Probability::LawController::setLawAccordingToIndex(int index) { } switch (index) { case 0: - m_law = new BinomialLaw(m_evaluateContext); + m_law = new BinomialLaw(m_context); break; case 1: - m_law = new UniformLaw(m_evaluateContext); + m_law = new UniformLaw(m_context); break; case 2: - m_law = new ExponentialLaw(m_evaluateContext); + m_law = new ExponentialLaw(m_context); break; case 3: - m_law = new NormalLaw(m_evaluateContext); + m_law = new NormalLaw(m_context); break; case 4: - m_law = new PoissonLaw(m_evaluateContext); + m_law = new PoissonLaw(m_context); break; default: return; diff --git a/apps/probability/law_controller.h b/apps/probability/law_controller.h index 0856ebd1e..43f9ccc3d 100644 --- a/apps/probability/law_controller.h +++ b/apps/probability/law_controller.h @@ -5,13 +5,12 @@ #include "cell.h" #include "law/law.h" #include "parameters_controller.h" -#include "evaluate_context.h" namespace Probability { class LawController : public ViewController, public SimpleListViewDataSource { public: - LawController(Responder * parentResponder, EvaluateContext * EvaluateContext); + LawController(Responder * parentResponder, Context * context); View * view() override; const char * title() const override; bool handleEvent(Ion::Events::Event event) override; @@ -31,7 +30,7 @@ private: SelectableTableView m_selectableTableView; const char ** m_messages; Law * m_law; - EvaluateContext * m_evaluateContext; + Context * m_context; ParametersController m_parametersController; }; diff --git a/apps/probability/law_curve_view.cpp b/apps/probability/law_curve_view.cpp index bdba7fd2c..f7b483098 100644 --- a/apps/probability/law_curve_view.cpp +++ b/apps/probability/law_curve_view.cpp @@ -46,8 +46,10 @@ char * LawCurveView::label(Axis axis, int index) const { } float LawCurveView::evaluateExpressionAtAbscissa(Expression * expression, float abscissa) const { - m_law->evaluateContext()->setOverridenValueForSymbolT(abscissa); - return expression->approximate(*(m_law->evaluateContext())); + Symbol tSymbol = Symbol('t'); + Float e = Float(abscissa); + m_law->context()->setExpressionForSymbolName(&e, &tSymbol); + return expression->approximate(*(m_law->context())); } } diff --git a/apps/probability/local_context.cpp b/apps/probability/local_context.cpp new file mode 100644 index 000000000..daa573ce8 --- /dev/null +++ b/apps/probability/local_context.cpp @@ -0,0 +1,45 @@ +#include "local_context.h" +#include + +namespace Probability { + +LocalContext::LocalContext(::Context * parentContext) : + m_tValue(Float(0.0f)), + m_aValue(Float(0.0f)), + m_bValue(Float(0.0f)), + m_parentContext(parentContext) +{ +} + + +void LocalContext::setExpressionForSymbolName(Expression * expression, const Symbol * symbol) { + // TODO: Add syntax error if expression is a matrix? + if (symbol->name() == 't') { + m_tValue = Float(expression->approximate(*m_parentContext)); + return; + } + if (symbol->name() == 'a') { + m_aValue = Float(expression->approximate(*m_parentContext)); + return; + } + if (symbol->name() == 'b') { + m_bValue = Float(expression->approximate(*m_parentContext)); + return; + } + m_parentContext->setExpressionForSymbolName(expression, symbol); +} + +const Expression * LocalContext::expressionForSymbol(const Symbol * symbol) { + if (symbol->name() == 't') { + return &m_tValue; + } + if (symbol->name() == 'a') { + return &m_aValue; + } + if (symbol->name() == 'b') { + return &m_bValue; + } + return m_parentContext->expressionForSymbol(symbol); +} + +} diff --git a/apps/probability/local_context.h b/apps/probability/local_context.h new file mode 100644 index 000000000..7cfbef1c1 --- /dev/null +++ b/apps/probability/local_context.h @@ -0,0 +1,22 @@ +#ifndef PROBABILITY_LOCAL_CONTEXT_H +#define PROBABILITY_LOCAL_CONTEXT_H + +#include + +namespace Probability { + +class LocalContext : public Context { +public: + LocalContext(Context * parentContext); + void setExpressionForSymbolName(Expression * expression, const Symbol * symbol) override; + const Expression * expressionForSymbol(const Symbol * symbol) override; +private: + Float m_tValue; + Float m_aValue; + Float m_bValue; + Context * m_parentContext; +}; + +} + +#endif \ No newline at end of file diff --git a/apps/variable_box_controller.cpp b/apps/variable_box_controller.cpp index 2d6168200..5c364cd68 100644 --- a/apps/variable_box_controller.cpp +++ b/apps/variable_box_controller.cpp @@ -69,11 +69,11 @@ int VariableBoxController::ContentViewController::numberOfRows() { case Page::RootMenu: return 3; case Page::Scalar: - return Context::k_maxNumberOfScalarExpressions; + return GlobalContext::k_maxNumberOfScalarExpressions; case Page::List: - return Context::k_maxNumberOfListExpressions; + return GlobalContext::k_maxNumberOfListExpressions; case Page::Matrix: - return Context::k_maxNumberOfMatrixExpressions; + return GlobalContext::k_maxNumberOfMatrixExpressions; default: return 0; } diff --git a/poincare/Makefile b/poincare/Makefile index 4bf3ec5a0..89113f8ce 100644 --- a/poincare/Makefile +++ b/poincare/Makefile @@ -5,7 +5,7 @@ include poincare/src/simplify/Makefile objs += $(addprefix poincare/src/,\ addition.o\ binary_operation.o\ - context.o\ + global_context.o\ cosine.o\ expression.o\ expression_lexer.o\ diff --git a/poincare/include/poincare.h b/poincare/include/poincare.h index 05c6ecd7c..278a5e4b1 100644 --- a/poincare/include/poincare.h +++ b/poincare/include/poincare.h @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include diff --git a/poincare/include/poincare/context.h b/poincare/include/poincare/context.h index d525db011..9c196df8b 100644 --- a/poincare/include/poincare/context.h +++ b/poincare/include/poincare/context.h @@ -3,25 +3,11 @@ #include #include -#include - -class Integer; - -//TODO: We should probably make a COPY of the expressions we store class Context { - public: - Context(); - virtual const Expression * expressionForSymbol(const Symbol * symbol); - void setExpressionForSymbolName(Expression * expression, const Symbol * symbol); - static constexpr uint16_t k_maxNumberOfScalarExpressions = 26; - static constexpr uint16_t k_maxNumberOfListExpressions = 10; - static constexpr uint16_t k_maxNumberOfMatrixExpressions = 10; - protected: - static Float * defaultExpression(); - private: - int symbolIndex(const Symbol * symbol) const; - Expression * m_expressions[k_maxNumberOfScalarExpressions]; +public: + virtual const Expression * expressionForSymbol(const Symbol * symbol) = 0; + virtual void setExpressionForSymbolName(Expression * expression, const Symbol * symbol) = 0; }; #endif diff --git a/poincare/include/poincare/global_context.h b/poincare/include/poincare/global_context.h new file mode 100644 index 000000000..c4285216b --- /dev/null +++ b/poincare/include/poincare/global_context.h @@ -0,0 +1,25 @@ +#ifndef POINCARE_GLOBAL_CONTEXT_H +#define POINCARE_GLOBAL_CONTEXT_H + +#include +#include + +class Integer; + +/* The global context only stores symbols A-Z, L1-L9 and M1-M9 */ + +class GlobalContext : public Context { +public: + GlobalContext(); + const Expression * expressionForSymbol(const Symbol * symbol) override; + void setExpressionForSymbolName(Expression * expression, const Symbol * symbol) override; + static constexpr uint16_t k_maxNumberOfScalarExpressions = 26; + static constexpr uint16_t k_maxNumberOfListExpressions = 10; + static constexpr uint16_t k_maxNumberOfMatrixExpressions = 10; + static Float * defaultExpression(); +private: + int symbolIndex(const Symbol * symbol) const; + Expression * m_expressions[k_maxNumberOfScalarExpressions]; +}; + +#endif diff --git a/poincare/include/poincare/symbol.h b/poincare/include/poincare/symbol.h index eb1cb1bc7..6b80bfdd3 100644 --- a/poincare/include/poincare/symbol.h +++ b/poincare/include/poincare/symbol.h @@ -6,9 +6,7 @@ class Symbol : public LeafExpression { public: enum SpecialSymbols : char { - Ans = '^', - p1 = '*', - p2 = '$' + Ans = '^' }; Symbol(char name); ExpressionLayout * createLayout() const override; diff --git a/poincare/src/expression_lexer.l b/poincare/src/expression_lexer.l index 2430e10e9..4e574ec3d 100644 --- a/poincare/src/expression_lexer.l +++ b/poincare/src/expression_lexer.l @@ -67,10 +67,8 @@ %% [0-9]+ { poincare_expression_yylval.string = yytext; return(INTEGER); } -[A-Zxnt] { poincare_expression_yylval.character = yytext[0]; return SYMBOL; } +[A-Zxntab] { poincare_expression_yylval.character = yytext[0]; return SYMBOL; } ans { poincare_expression_yylval.character = Symbol::Ans; return SYMBOL; } -p1 { poincare_expression_yylval.character = Symbol::p1; return SYMBOL; } -p2 { poincare_expression_yylval.character = Symbol::p2; return SYMBOL; } sin { poincare_expression_yylval.expression = new Sine(); return FUNCTION; } cos { poincare_expression_yylval.expression = new Cosine(); return FUNCTION; } tan { poincare_expression_yylval.expression = new Tangent(); return FUNCTION; } diff --git a/poincare/src/context.cpp b/poincare/src/global_context.cpp similarity index 61% rename from poincare/src/context.cpp rename to poincare/src/global_context.cpp index 72d9f4bf6..0eefdcac7 100644 --- a/poincare/src/context.cpp +++ b/poincare/src/global_context.cpp @@ -1,24 +1,24 @@ -#include +#include #include -Context::Context() +GlobalContext::GlobalContext() { for (int i = 0; i < k_maxNumberOfScalarExpressions; i++) { m_expressions[i] = nullptr; } } -Float * Context::defaultExpression() { +Float * GlobalContext::defaultExpression() { static Float * defaultExpression = new Float(0); return defaultExpression; } -int Context::symbolIndex(const Symbol * symbol) const { +int GlobalContext::symbolIndex(const Symbol * symbol) const { int index = symbol->name() - 'A'; return index; } -const Expression * Context::expressionForSymbol(const Symbol * symbol) { +const Expression * GlobalContext::expressionForSymbol(const Symbol * symbol) { int index = symbolIndex(symbol); if (index < 0 || index >= k_maxNumberOfScalarExpressions) { return nullptr; @@ -29,7 +29,7 @@ const Expression * Context::expressionForSymbol(const Symbol * symbol) { return m_expressions[index]; } -void Context::setExpressionForSymbolName(Expression * expression, const Symbol * symbol) { +void GlobalContext::setExpressionForSymbolName(Expression * expression, const Symbol * symbol) { int index = symbolIndex(symbol); m_expressions[index] = expression; } diff --git a/poincare/test/addition.cpp b/poincare/test/addition.cpp index 1dbeffae9..8f1d5e9e6 100644 --- a/poincare/test/addition.cpp +++ b/poincare/test/addition.cpp @@ -3,39 +3,39 @@ #include QUIZ_CASE(poincare_addition_approximate) { - Context context; + GlobalContext globalContext; Expression * a = Expression::parse("1+2"); - assert(a->approximate(context) == 3.0f); + assert(a->approximate(globalContext) == 3.0f); delete a; } QUIZ_CASE(poincare_addition_evaluate) { - Context context; + GlobalContext globalContext; Expression * a = Expression::parse("1+2"); - Expression * e = a->evaluate(context); - assert(e->approximate(context) == 3.0f); + Expression * e = a->evaluate(globalContext); + assert(e->approximate(globalContext) == 3.0f); delete a; delete e; a = Expression::parse("[[1,2][3,4][5,6]]+3"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == 4.0f); - assert(e->operand(1)->approximate(context) == 5.0f); - assert(e->operand(2)->approximate(context) == 6.0f); - assert(e->operand(3)->approximate(context) == 7.0f); - assert(e->operand(4)->approximate(context) == 8.0f); - assert(e->operand(5)->approximate(context) == 9.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == 4.0f); + assert(e->operand(1)->approximate(globalContext) == 5.0f); + assert(e->operand(2)->approximate(globalContext) == 6.0f); + assert(e->operand(3)->approximate(globalContext) == 7.0f); + assert(e->operand(4)->approximate(globalContext) == 8.0f); + assert(e->operand(5)->approximate(globalContext) == 9.0f); delete a; delete e; a = Expression::parse("[[1,2][3,4][5,6]]+[[1,2][3,4][5,6]]"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == 2.0f); - assert(e->operand(1)->approximate(context) == 4.0f); - assert(e->operand(2)->approximate(context) == 6.0f); - assert(e->operand(3)->approximate(context) == 8.0f); - assert(e->operand(4)->approximate(context) == 10.0f); - assert(e->operand(5)->approximate(context) == 12.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == 2.0f); + assert(e->operand(1)->approximate(globalContext) == 4.0f); + assert(e->operand(2)->approximate(globalContext) == 6.0f); + assert(e->operand(3)->approximate(globalContext) == 8.0f); + assert(e->operand(4)->approximate(globalContext) == 10.0f); + assert(e->operand(5)->approximate(globalContext) == 12.0f); delete a; delete e; } diff --git a/poincare/test/float.cpp b/poincare/test/float.cpp index 39cf2f6fa..c7210581d 100644 --- a/poincare/test/float.cpp +++ b/poincare/test/float.cpp @@ -28,17 +28,17 @@ QUIZ_CASE(poincare_float_to_text) { } QUIZ_CASE(poincare_float_approximate) { - Context context; + GlobalContext globalContext; Expression * a = new Float(123.456f); - assert(a->approximate(context) == 123.456f); + assert(a->approximate(globalContext) == 123.456f); delete a; } QUIZ_CASE(poincare_float_evaluate) { - Context context; + GlobalContext globalContext; Expression * a = new Float(123.456f); - Expression * e = a->evaluate(context); - assert(e->approximate(context) == 123.456f); + Expression * e = a->evaluate(globalContext); + assert(e->approximate(globalContext) == 123.456f); delete a; delete e; } diff --git a/poincare/test/fraction.cpp b/poincare/test/fraction.cpp index 3b3ef56ef..fbf2b0fa9 100644 --- a/poincare/test/fraction.cpp +++ b/poincare/test/fraction.cpp @@ -3,28 +3,28 @@ #include QUIZ_CASE(poincare_fraction_approximate) { - Context context; + GlobalContext globalContext; Expression * f = Expression::parse("1/2"); - assert(f->approximate(context) == 0.5f); + assert(f->approximate(globalContext) == 0.5f); delete f; } QUIZ_CASE(poincare_fraction_evaluate) { - Context context; + GlobalContext globalContext; Expression * a = Expression::parse("1/2"); - Expression * e = a->evaluate(context); - assert(e->approximate(context) == 0.5f); + Expression * e = a->evaluate(globalContext); + assert(e->approximate(globalContext) == 0.5f); delete a; delete e; a = Expression::parse("[[1,2][3,4][5,6]]/2"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == 0.5f); - assert(e->operand(1)->approximate(context) == 1.0f); - assert(e->operand(2)->approximate(context) == 1.5f); - assert(e->operand(3)->approximate(context) == 2.0f); - assert(e->operand(4)->approximate(context) == 2.5f); - assert(e->operand(5)->approximate(context) == 3.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == 0.5f); + assert(e->operand(1)->approximate(globalContext) == 1.0f); + assert(e->operand(2)->approximate(globalContext) == 1.5f); + assert(e->operand(3)->approximate(globalContext) == 2.0f); + assert(e->operand(4)->approximate(globalContext) == 2.5f); + assert(e->operand(5)->approximate(globalContext) == 3.0f); delete a; delete e; // TODO: test matrice fraction when implemented diff --git a/poincare/test/integer.cpp b/poincare/test/integer.cpp index cd2463e50..78139f711 100644 --- a/poincare/test/integer.cpp +++ b/poincare/test/integer.cpp @@ -51,32 +51,32 @@ QUIZ_CASE(poincare_integer_divide) { } QUIZ_CASE(poincare_integer_approximate) { - Context context; - assert(Integer(1).approximate(context) == 1.0f); - assert(Integer("12345678").approximate(context) == 12345678.0f); - assert(Integer("0").approximate(context) == 0); - assert(Integer("-0").approximate(context) == -0); - assert(Integer(-1).approximate(context) == -1); + GlobalContext globalContext; + assert(Integer(1).approximate(globalContext) == 1.0f); + assert(Integer("12345678").approximate(globalContext) == 12345678.0f); + assert(Integer("0").approximate(globalContext) == 0); + assert(Integer("-0").approximate(globalContext) == -0); + assert(Integer(-1).approximate(globalContext) == -1); } QUIZ_CASE(poincare_integer_evaluate) { - Context context; - Expression * e = Integer(1).evaluate(context); - assert(e->approximate(context) == 1.0f); + GlobalContext globalContext; + Expression * e = Integer(1).evaluate(globalContext); + assert(e->approximate(globalContext) == 1.0f); delete e; - e = Integer(12345678).evaluate(context); - assert(e->approximate(context) == 12345678.0f); + e = Integer(12345678).evaluate(globalContext); + assert(e->approximate(globalContext) == 12345678.0f); delete e; - e = Integer(0).evaluate(context); - assert(e->approximate(context) == 0.0f); + e = Integer(0).evaluate(globalContext); + assert(e->approximate(globalContext) == 0.0f); delete e; - e = Integer(-0).evaluate(context); - assert(e->approximate(context) == 0.0f); + e = Integer(-0).evaluate(globalContext); + assert(e->approximate(globalContext) == 0.0f); delete e; - e = Integer(-0).evaluate(context); - assert(e->approximate(context) == 0.0f); + e = Integer(-0).evaluate(globalContext); + assert(e->approximate(globalContext) == 0.0f); delete e; - e = Integer(-1).evaluate(context); - assert(e->approximate(context) == -1.0f); + e = Integer(-1).evaluate(globalContext); + assert(e->approximate(globalContext) == -1.0f); delete e; } diff --git a/poincare/test/matrix.cpp b/poincare/test/matrix.cpp index f83a15281..444e9a139 100644 --- a/poincare/test/matrix.cpp +++ b/poincare/test/matrix.cpp @@ -3,13 +3,13 @@ #include QUIZ_CASE(poincare_matrix_evaluate) { - Context context; + GlobalContext globalContext; Expression * f = Expression::parse("[[1,2,3][4,5,6]]"); - assert(f->operand(0)->approximate(context) == 1.0f); - assert(f->operand(1)->approximate(context) == 2.0f); - assert(f->operand(2)->approximate(context) == 3.0f); - assert(f->operand(3)->approximate(context) == 4.0f); - assert(f->operand(4)->approximate(context) == 5.0f); - assert(f->operand(5)->approximate(context) == 6.0f); + assert(f->operand(0)->approximate(globalContext) == 1.0f); + assert(f->operand(1)->approximate(globalContext) == 2.0f); + assert(f->operand(2)->approximate(globalContext) == 3.0f); + assert(f->operand(3)->approximate(globalContext) == 4.0f); + assert(f->operand(4)->approximate(globalContext) == 5.0f); + assert(f->operand(5)->approximate(globalContext) == 6.0f); delete f; } diff --git a/poincare/test/power.cpp b/poincare/test/power.cpp index f0957169c..32c991c55 100644 --- a/poincare/test/power.cpp +++ b/poincare/test/power.cpp @@ -3,26 +3,26 @@ #include QUIZ_CASE(poincare_power_approximate) { - Context context; + GlobalContext globalContext; Expression * p = Expression::parse("2^3"); - assert(p->approximate(context) == 8.0f); + assert(p->approximate(globalContext) == 8.0f); delete p; } QUIZ_CASE(poincare_power_evaluate) { - Context context; + GlobalContext globalContext; Expression * a = Expression::parse("2^3"); - Expression * e = a->evaluate(context); - assert(e->approximate(context) == 8.0f); + Expression * e = a->evaluate(globalContext); + assert(e->approximate(globalContext) == 8.0f); delete a; delete e; a = Expression::parse("[[1,2][3,4]]^3"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == 37.0f); - assert(e->operand(1)->approximate(context) == 54.0f); - assert(e->operand(2)->approximate(context) == 81.0f); - assert(e->operand(3)->approximate(context) == 118.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == 37.0f); + assert(e->operand(1)->approximate(globalContext) == 54.0f); + assert(e->operand(2)->approximate(globalContext) == 81.0f); + assert(e->operand(3)->approximate(globalContext) == 118.0f); delete a; delete e; } diff --git a/poincare/test/product.cpp b/poincare/test/product.cpp index bd6b6f79f..5b2dc2e72 100644 --- a/poincare/test/product.cpp +++ b/poincare/test/product.cpp @@ -3,56 +3,56 @@ #include QUIZ_CASE(poincare_procuct_approximate) { - Context context; + GlobalContext globalContext; Expression * p = Expression::parse("1*2"); - assert(p->approximate(context) == 2.0f); + assert(p->approximate(globalContext) == 2.0f); delete p; } QUIZ_CASE(poincare_product_evaluate) { - Context context; + GlobalContext globalContext; Expression * a = Expression::parse("1*2"); - Expression * e = a->evaluate(context); - assert(e->approximate(context) == 2.0f); + Expression * e = a->evaluate(globalContext); + assert(e->approximate(globalContext) == 2.0f); delete a; delete e; a = Expression::parse("[[1,2][3,4][5,6]]*2"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == 2.0f); - assert(e->operand(1)->approximate(context) == 4.0f); - assert(e->operand(2)->approximate(context) == 6.0f); - assert(e->operand(3)->approximate(context) == 8.0f); - assert(e->operand(4)->approximate(context) == 10.0f); - assert(e->operand(5)->approximate(context) == 12.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == 2.0f); + assert(e->operand(1)->approximate(globalContext) == 4.0f); + assert(e->operand(2)->approximate(globalContext) == 6.0f); + assert(e->operand(3)->approximate(globalContext) == 8.0f); + assert(e->operand(4)->approximate(globalContext) == 10.0f); + assert(e->operand(5)->approximate(globalContext) == 12.0f); delete a; delete e; a = Expression::parse("3*[[1,2][3,4][5,6]]"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == 3.0f); - assert(e->operand(1)->approximate(context) == 6.0f); - assert(e->operand(2)->approximate(context) == 9.0f); - assert(e->operand(3)->approximate(context) == 12.0f); - assert(e->operand(4)->approximate(context) == 15.0f); - assert(e->operand(5)->approximate(context) == 18.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == 3.0f); + assert(e->operand(1)->approximate(globalContext) == 6.0f); + assert(e->operand(2)->approximate(globalContext) == 9.0f); + assert(e->operand(3)->approximate(globalContext) == 12.0f); + assert(e->operand(4)->approximate(globalContext) == 15.0f); + assert(e->operand(5)->approximate(globalContext) == 18.0f); delete a; delete e; a = Expression::parse("[[1,2][3,4][5,6]]*[[1,2,3,4][5,6,7,8]]"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == 11.0f); - assert(e->operand(1)->approximate(context) == 14.0f); - assert(e->operand(2)->approximate(context) == 17.0f); - assert(e->operand(3)->approximate(context) == 20.0f); - assert(e->operand(4)->approximate(context) == 23.0f); - assert(e->operand(5)->approximate(context) == 30.0f); - assert(e->operand(6)->approximate(context) == 37.0f); - assert(e->operand(7)->approximate(context) == 44.0f); - assert(e->operand(8)->approximate(context) == 35.0f); - assert(e->operand(9)->approximate(context) == 46.0f); - assert(e->operand(10)->approximate(context) == 57.0f); - assert(e->operand(11)->approximate(context) == 68.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == 11.0f); + assert(e->operand(1)->approximate(globalContext) == 14.0f); + assert(e->operand(2)->approximate(globalContext) == 17.0f); + assert(e->operand(3)->approximate(globalContext) == 20.0f); + assert(e->operand(4)->approximate(globalContext) == 23.0f); + assert(e->operand(5)->approximate(globalContext) == 30.0f); + assert(e->operand(6)->approximate(globalContext) == 37.0f); + assert(e->operand(7)->approximate(globalContext) == 44.0f); + assert(e->operand(8)->approximate(globalContext) == 35.0f); + assert(e->operand(9)->approximate(globalContext) == 46.0f); + assert(e->operand(10)->approximate(globalContext) == 57.0f); + assert(e->operand(11)->approximate(globalContext) == 68.0f); delete a; delete e; } diff --git a/poincare/test/subtraction.cpp b/poincare/test/subtraction.cpp index 163260fc8..656dd7a1d 100644 --- a/poincare/test/subtraction.cpp +++ b/poincare/test/subtraction.cpp @@ -3,50 +3,50 @@ #include QUIZ_CASE(poincare_subtraction_approximate) { - Context context; + GlobalContext globalContext; Expression * s = Expression::parse("1-2"); - assert(s->approximate(context) == -1.0f); + assert(s->approximate(globalContext) == -1.0f); delete s; } QUIZ_CASE(poincare_substraction_evaluate) { - Context context; + GlobalContext globalContext; Expression * a = Expression::parse("1-2"); - Expression * e = a->evaluate(context); - assert(e->approximate(context) == -1.0f); + Expression * e = a->evaluate(globalContext); + assert(e->approximate(globalContext) == -1.0f); delete a; delete e; a = Expression::parse("[[1,2][3,4][5,6]]-3"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == -2.0f); - assert(e->operand(1)->approximate(context) == -1.0f); - assert(e->operand(2)->approximate(context) == 0.0f); - assert(e->operand(3)->approximate(context) == 1.0f); - assert(e->operand(4)->approximate(context) == 2.0f); - assert(e->operand(5)->approximate(context) == 3.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == -2.0f); + assert(e->operand(1)->approximate(globalContext) == -1.0f); + assert(e->operand(2)->approximate(globalContext) == 0.0f); + assert(e->operand(3)->approximate(globalContext) == 1.0f); + assert(e->operand(4)->approximate(globalContext) == 2.0f); + assert(e->operand(5)->approximate(globalContext) == 3.0f); delete a; delete e; a = Expression::parse("3-[[1,2][3,4][5,6]]"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == 2.0f); - assert(e->operand(1)->approximate(context) == 1.0f); - assert(e->operand(2)->approximate(context) == 0.0f); - assert(e->operand(3)->approximate(context) == -1.0f); - assert(e->operand(4)->approximate(context) == -2.0f); - assert(e->operand(5)->approximate(context) == -3.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == 2.0f); + assert(e->operand(1)->approximate(globalContext) == 1.0f); + assert(e->operand(2)->approximate(globalContext) == 0.0f); + assert(e->operand(3)->approximate(globalContext) == -1.0f); + assert(e->operand(4)->approximate(globalContext) == -2.0f); + assert(e->operand(5)->approximate(globalContext) == -3.0f); delete a; delete e; a = Expression::parse("[[1,2][3,4][5,6]]-[[6,5][4,3][2,1]]"); - e = a->evaluate(context); - assert(e->operand(0)->approximate(context) == -5.0f); - assert(e->operand(1)->approximate(context) == -3.0f); - assert(e->operand(2)->approximate(context) == -1.0f); - assert(e->operand(3)->approximate(context) == 1.0f); - assert(e->operand(4)->approximate(context) == 3.0f); - assert(e->operand(5)->approximate(context) == 5.0f); + e = a->evaluate(globalContext); + assert(e->operand(0)->approximate(globalContext) == -5.0f); + assert(e->operand(1)->approximate(globalContext) == -3.0f); + assert(e->operand(2)->approximate(globalContext) == -1.0f); + assert(e->operand(3)->approximate(globalContext) == 1.0f); + assert(e->operand(4)->approximate(globalContext) == 3.0f); + assert(e->operand(5)->approximate(globalContext) == 5.0f); delete a; delete e; }