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

[apps/poincare] Clearer method names

Browse Source
This commit is contained in:
Léa Saviot
2019-08-27 15:50:26 +02:00
parent faca423a82
commit dcb5a061e9
19 changed files with 42 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
apps/regression/regression_context.cpp
View File

@@ -9,7 +9,7 @@ using namespace Shared;
namespace Regression {
const Expression RegressionContext::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
const Expression RegressionContext::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
if (symbol.type() == ExpressionNode::Type::Symbol && Symbol::isRegressionSymbol(symbol.name())) {
const char * seriesName = symbol.name();
assert(strlen(seriesName) == 2);
@@ -24,7 +24,7 @@ const Expression RegressionContext::expressionForSymbol(const SymbolAbstract & s
assert(m_seriesPairIndex < m_store->numberOfPairsOfSeries(series));
return Float<double>::Builder(m_store->get(series, storeI, m_seriesPairIndex));
} else {
return m_parentContext->expressionForSymbol(symbol, clone);
return m_parentContext->expressionForSymbolAbstract(symbol, clone);
}
}

2
apps/regression/regression_context.h
View File

@@ -9,7 +9,7 @@ namespace Regression {
class RegressionContext : public Shared::StoreContext {
public:
using Shared::StoreContext::StoreContext;
const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override;
const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override;
};
}

8
apps/sequence/cache_context.cpp
View File

@@ -14,7 +14,7 @@ CacheContext<T>::CacheContext(Context * parentContext) :
}
template<typename T>
const Expression CacheContext<T>::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
const Expression CacheContext<T>::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
// [u|v|w](n(+1)?)
if (symbol.type() == ExpressionNode::Type::Symbol
&& symbol.name()[0] >= SequenceStore::k_sequenceNames[0][0]
@@ -24,12 +24,12 @@ const Expression CacheContext<T>::expressionForSymbol(const SymbolAbstract & sym
Symbol s = const_cast<Symbol &>(static_cast<const Symbol &>(symbol));
return Float<T>::Builder(m_values[nameIndexForSymbol(s)][rankIndexForSymbol(s)]);
}
return m_parentContext->expressionForSymbol(symbol, clone);
return m_parentContext->expressionForSymbolAbstract(symbol, clone);
}
template<typename T>
void CacheContext<T>::setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
m_parentContext->setExpressionForSymbol(expression, symbol, context);
void CacheContext<T>::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
m_parentContext->setExpressionForSymbolAbstract(expression, symbol, context);
}
template<typename T>

4
apps/sequence/cache_context.h
View File

@@ -12,8 +12,8 @@ template<typename T>
class CacheContext : public Poincare::Context {
public:
CacheContext(Poincare::Context * parentContext);
const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override;
void setExpressionForSymbol(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override;
const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override;
void setExpressionForSymbolAbstract(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override;
void setValueForSymbol(T value, const Poincare::Symbol & symbol);
private:
int nameIndexForSymbol(const Poincare::Symbol & symbol);

10
apps/sequence/sequence_context.h
View File

@@ -41,15 +41,15 @@ public:
m_doubleSequenceContext(),
m_sequenceStore(sequenceStore),
m_parentContext(parentContext) {}
/* expressionForSymbol & setExpressionForSymbolName directly call the parent
/* expressionForSymbolAbstract & setExpressionForSymbolAbstractName directly call the parent
* context respective methods. Indeed, special chars like n, u(n), u(n+1),
* v(n), v(n+1) are taken into accound only when evaluating sequences which
* is done in another context. */
const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override {
return m_parentContext->expressionForSymbol(symbol, clone);
const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override {
return m_parentContext->expressionForSymbolAbstract(symbol, clone);
}
void setExpressionForSymbol(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override {
m_parentContext->setExpressionForSymbol(expression, symbol, context);
void setExpressionForSymbolAbstract(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override {
m_parentContext->setExpressionForSymbolAbstract(expression, symbol, context);
}
template<typename T> T valueOfSequenceAtPreviousRank(int sequenceIndex, int rank) const {
if (sizeof(T) == sizeof(float)) {

4
apps/shared/global_context.cpp
View File

@@ -57,12 +57,12 @@ void GlobalContext::DestroyRecordsBaseNamedWithoutExtension(const char * baseNam
}
}
const Expression GlobalContext::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
const Expression GlobalContext::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
Ion::Storage::Record r = SymbolAbstractRecordWithBaseName(symbol.name());
return ExpressionForSymbolAndRecord(symbol, r);
}
void GlobalContext::setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
void GlobalContext::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
/* If the new expression contains the symbol, replace it because it will be
* destroyed afterwards (to be able to do A+2->A) */
Ion::Storage::Record record = SymbolAbstractRecordWithBaseName(symbol.name());

4
apps/shared/global_context.h
View File

@@ -33,8 +33,8 @@ public:
/* Expression for symbol
* The expression recorded in global context is already an expression.
* Otherwise, we would need the context and the angle unit to evaluate it */
const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override;
void setExpressionForSymbol(
const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override;
void setExpressionForSymbolAbstract(
const Poincare::Expression & expression,
const Poincare::SymbolAbstract & symbol,
Poincare::Context * context) override;

4
apps/shared/store_context.cpp
View File

@@ -7,8 +7,8 @@ using namespace Poincare;
namespace Shared {
void StoreContext::setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
m_parentContext->setExpressionForSymbol(expression, symbol, context);
void StoreContext::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
m_parentContext->setExpressionForSymbolAbstract(expression, symbol, context);
}
}

2
apps/shared/store_context.h
View File

@@ -19,7 +19,7 @@ public:
{}
void setParentContext(Poincare::Context * parentContext) { m_parentContext = parentContext; }
void setSeriesPairIndex(int j) { m_seriesPairIndex = j; }
void setExpressionForSymbol(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override;
void setExpressionForSymbolAbstract(const Poincare::Expression & expression, const Poincare::SymbolAbstract & symbol, Poincare::Context * context) override;
protected:
Shared::DoublePairStore * m_store;
int m_seriesPairIndex;

4
apps/statistics/statistics_context.cpp
View File

@@ -9,7 +9,7 @@ using namespace Shared;
namespace Statistics {
const Expression StatisticsContext::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
const Expression StatisticsContext::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
if (symbol.type() == ExpressionNode::Type::Symbol && Symbol::isSeriesSymbol(symbol.name())) {
const char * seriesName = symbol.name();
assert(strlen(seriesName) == 2);
@@ -24,7 +24,7 @@ const Expression StatisticsContext::expressionForSymbol(const SymbolAbstract & s
assert(m_seriesPairIndex < m_store->numberOfPairsOfSeries(series));
return Float<double>::Builder(m_store->get(series, storeI, m_seriesPairIndex));
} else {
return m_parentContext->expressionForSymbol(symbol, clone);
return m_parentContext->expressionForSymbolAbstract(symbol, clone);
}
}

2
apps/statistics/statistics_context.h
View File

@@ -8,7 +8,7 @@ namespace Statistics {
class StatisticsContext : public Shared::StoreContext {
public:
using Shared::StoreContext::StoreContext;
const Poincare::Expression expressionForSymbol(const Poincare::SymbolAbstract & symbol, bool clone) override;
const Poincare::Expression expressionForSymbolAbstract(const Poincare::SymbolAbstract & symbol, bool clone) override;
};
}

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

@@ -8,8 +8,8 @@ class SymbolAbstract;
class Context {
public:
virtual const Expression expressionForSymbol(const SymbolAbstract & symbol, bool clone) = 0;
virtual void setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) = 0;
virtual const Expression expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) = 0;
virtual void setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) = 0;
};
}

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

@@ -13,8 +13,8 @@ public:
void setApproximationForVariable(T value);
// Context
void setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) override;
const Expression expressionForSymbol(const SymbolAbstract & symbol, bool clone) override;
void setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) override;
const Expression expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) override;
private:
const char * m_name;

4
poincare/src/expression.cpp
View File

@@ -320,9 +320,9 @@ bool Expression::hasReplaceableSymbols(Context * context) const {
return recursivelyMatches([](const Expression e, Context * context) {
return (e.type() == ExpressionNode::Type::Symbol
&& !static_cast<const Symbol &>(e).isSystemSymbol()
&& !context->expressionForSymbol(static_cast<const Symbol &>(e), false).isUninitialized())
&& !context->expressionForSymbolAbstract(static_cast<const Symbol &>(e), false).isUninitialized())
|| (e.type() == ExpressionNode::Type::Function
&& !context->expressionForSymbol(static_cast<const Function &>(e), false).isUninitialized());
&& !context->expressionForSymbolAbstract(static_cast<const Function &>(e), false).isUninitialized());
}, context, false);
}

6
poincare/src/function.cpp
View File

@@ -129,7 +129,7 @@ Expression Function::shallowReduce(ExpressionNode::ReductionContext reductionCon
}
Expression Function::shallowReplaceReplaceableSymbols(Context * context) {
Expression e = context->expressionForSymbol(*this, true);
Expression e = context->expressionForSymbolAbstract(*this, true);
if (e.isUninitialized()) {
return *this;
}
@@ -154,7 +154,7 @@ VariableContext Function::unknownXContext(Context & parentContext) const {
/* If the parentContext already has an expression for UnknownX, we have to
* replace in childAtIndex(0) any occurence of UnknownX by its value in
* parentContext. That way, we handle: evaluatin f(x-1) with x = 2 & f:x->x^2 */
Expression unknownXValue = parentContext.expressionForSymbol(unknownXSymbol, true);
Expression unknownXValue = parentContext.expressionForSymbolAbstract(unknownXSymbol, true);
if (!unknownXValue.isUninitialized()) {
xContext = static_cast<VariableContext &>(parentContext); // copy the parentContext
child.replaceSymbolWithExpression(unknownXSymbol, unknownXValue);
@@ -164,7 +164,7 @@ VariableContext Function::unknownXContext(Context & parentContext) const {
assert(!child.recursivelyMatches([](const Expression e, Context * context, bool replaceSymbol) {
return e.type() == ExpressionNode::Type::Symbol && static_cast<const Symbol &>(e).isSystemSymbol();
}, parentContext, false));
xContext.setExpressionForSymbol(child, unknownXSymbol, xContext);
xContext.setExpressionForSymbolAbstract(child, unknownXSymbol, xContext);
return xContext;
}
#endif

6
poincare/src/store.cpp
View File

@@ -38,7 +38,7 @@ template<typename T>
Evaluation<T> StoreNode::templatedApproximate(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const {
/* If we are here, it means that the store node was not shallowReduced.
* Otherwise, it would have been replaced by its symbol. We thus have to
* setExpressionForSymbol. */
* setExpressionForSymbolAbstract. */
Expression storedExpression = Store(this).storeValueForSymbol(context, complexFormat, angleUnit);
assert(!storedExpression.isUninitialized());
return storedExpression.node()->approximate(T(), context, complexFormat, angleUnit);
@@ -80,8 +80,8 @@ Expression Store::storeValueForSymbol(Context * context, Preferences::ComplexFor
finalValue = childAtIndex(0);
}
assert(!finalValue.isUninitialized());
context->setExpressionForSymbol(finalValue, symbol(), context);
Expression storedExpression = context->expressionForSymbol(symbol(), true);
context->setExpressionForSymbolAbstract(finalValue, symbol(), context);
Expression storedExpression = context->expressionForSymbolAbstract(symbol(), true);
if (storedExpression.isUninitialized()) {
return Undefined::Builder();

2
poincare/src/symbol.cpp
View File

@@ -235,7 +235,7 @@ Expression Symbol::shallowReplaceReplaceableSymbols(Context * context) {
if (isSystemSymbol()) {
return *this;
}
Expression e = context->expressionForSymbol(*this, true);
Expression e = context->expressionForSymbolAbstract(*this, true);
if (e.isUninitialized()) {
return *this;
}

2
poincare/src/symbol_abstract.cpp
View File

@@ -60,7 +60,7 @@ Expression SymbolAbstract::Expand(const SymbolAbstract & symbol, Context * conte
bool isFunction = symbol.type() == ExpressionNode::Type::Function;
/* Always clone the expression for Function because we are going to alter e
* by replacing all UnknownX in it. */
Expression e = context->expressionForSymbol(symbol, clone || isFunction);
Expression e = context->expressionForSymbolAbstract(symbol, clone || isFunction);
/* Replace all the symbols iteratively. This prevents a memory failure when
* symbols are defined circularly. */
e = Expression::ExpressionWithoutSymbols(e, context);

8
poincare/src/variable_context.cpp
View File

@@ -18,22 +18,22 @@ void VariableContext::setApproximationForVariable(T value) {
m_value = Float<T>::Builder(value);
}
void VariableContext::setExpressionForSymbol(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
void VariableContext::setExpressionForSymbolAbstract(const Expression & expression, const SymbolAbstract & symbol, Context * context) {
if (strcmp(symbol.name(), m_name) == 0) {
if (expression.isUninitialized()) {
return;
}
m_value = expression.clone();
} else {
m_parentContext->setExpressionForSymbol(expression, symbol, context);
m_parentContext->setExpressionForSymbolAbstract(expression, symbol, context);
}
}
const Expression VariableContext::expressionForSymbol(const SymbolAbstract & symbol, bool clone) {
const Expression VariableContext::expressionForSymbolAbstract(const SymbolAbstract & symbol, bool clone) {
if (strcmp(symbol.name(), m_name) == 0) {
return clone ? m_value.clone() : m_value;
} else {
return m_parentContext->expressionForSymbol(symbol, clone);
return m_parentContext->expressionForSymbolAbstract(symbol, clone);
}
}