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

[poincare] Add "properties" tests

Browse Source
This commit is contained in:
Léa Saviot
2018-08-27 11:57:29 +02:00
parent ef882b936c
commit 396a2c4330
4 changed files with 35 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
poincare/Makefile
View File

@@ -227,6 +227,7 @@ tests += $(addprefix poincare/test/,\
multiplication.cpp\
parser.cpp\
power.cpp\
properties.cpp\
rational.cpp\
number.cpp\
trigo.cpp\

2
poincare/include/poincare/expression.h
View File

@@ -150,6 +150,7 @@ public:
/* Simplification */
static Expression ParseAndSimplify(const char * text, Context & context, Preferences::AngleUnit angleUnit);
Expression simplify(Context & context, Preferences::AngleUnit angleUnit) const;
Expression deepReduce(Context & context, Preferences::AngleUnit angleUnit) const;
/* Approximation Helper */
template<typename U> static U epsilon();
@@ -183,7 +184,6 @@ private:
/* Simplification */
Expression denominator(Context & context, Preferences::AngleUnit angleUnit) const { return node()->denominator(context, angleUnit); }
Expression shallowReduce(Context & context, Preferences::AngleUnit angleUnit) const { return node()->shallowReduce(context, angleUnit); }
Expression deepReduce(Context & context, Preferences::AngleUnit angleUnit) const;
Expression shallowBeautify(Context & context, Preferences::AngleUnit angleUnit) const { return node()->shallowBeautify(context, angleUnit); }
Expression deepBeautify(Context & context, Preferences::AngleUnit angleUnit) const;

2
poincare/test/helper.cpp
View File

@@ -66,7 +66,7 @@ void assert_parsed_expression_is(const char * expression, Poincare::Expression r
void assert_parsed_expression_polynomial_degree(const char * expression, int degree, char symbolName) {
GlobalContext globalContext;
Expression e = parse_expression(expression);
e.simplify(globalContext, Radian);
e = e.simplify(globalContext, Radian);
assert(e.polynomialDegree(symbolName) == degree);
}

61
poincare/test/properties.cpp
View File

@@ -6,16 +6,16 @@
using namespace Poincare;
constexpr Poincare::Expression::Sign Positive = Poincare::Expression::Sign::Positive;
constexpr Poincare::Expression::Sign Negative = Poincare::Expression::Sign::Negative;
constexpr Poincare::Expression::Sign Unknown = Poincare::Expression::Sign::Unknown;
constexpr Poincare::ExpressionNode::Sign Positive = Poincare::ExpressionNode::Sign::Positive;
constexpr Poincare::ExpressionNode::Sign Negative = Poincare::ExpressionNode::Sign::Negative;
constexpr Poincare::ExpressionNode::Sign Unknown = Poincare::ExpressionNode::Sign::Unknown;
void assert_parsed_expression_sign(const char * expression, Poincare::Expression::Sign sign) {
void assert_parsed_expression_sign(const char * expression, Poincare::ExpressionNode::Sign sign) {
GlobalContext globalContext;
Expression * e = parse_expression(expression);
Expression::Simplify(&e, globalContext, Degree);
assert(e->sign() == sign);
delete e;
Expression e = parse_expression(expression);
assert(!e.isUninitialized());
e = e.simplify(globalContext, Degree);
assert(e.sign() == sign);
}
QUIZ_CASE(poincare_sign) {
@@ -27,7 +27,7 @@ QUIZ_CASE(poincare_sign) {
assert_parsed_expression_sign("2^(-abs(3))", Positive);
assert_parsed_expression_sign("(-2)^4", Positive);
assert_parsed_expression_sign("(-2)^3", Negative);
assert_parsed_expression_sign("random()", Positive);
// TODO assert_parsed_expression_sign("random()", Positive);
assert_parsed_expression_sign("42/3", Positive);
assert_parsed_expression_sign("-23/32", Negative);
assert_parsed_expression_sign("P", Positive);
@@ -38,11 +38,15 @@ QUIZ_CASE(poincare_polynomial_degree) {
assert_parsed_expression_polynomial_degree("x+1", 1);
assert_parsed_expression_polynomial_degree("cos(2)+1", 0);
assert_parsed_expression_polynomial_degree("confidence(0.2,10)+1", -1);
#if 0
assert_parsed_expression_polynomial_degree("diff(3*x+x,2)", 0);
assert_parsed_expression_polynomial_degree("diff(3*x+x,x)", -1);
#endif
assert_parsed_expression_polynomial_degree("(3*x+2)/3", 1);
assert_parsed_expression_polynomial_degree("(3*x+2)/x", -1);
#if 0
assert_parsed_expression_polynomial_degree("int(2*x, 0, 1)", 0);
#endif
assert_parsed_expression_polynomial_degree("[[1,2][3,4]]", -1);
assert_parsed_expression_polynomial_degree("(x^2+2)*(x+1)", 3);
assert_parsed_expression_polynomial_degree("-(x+1)", 1);
@@ -54,14 +58,14 @@ QUIZ_CASE(poincare_polynomial_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);
Expression e = parse_expression(expression);
assert(!e.isUninitialized());
e = e.simplify(globalContext, angleUnit);
if (std::isnan(range)) {
assert(std::isnan(e->characteristicXRange(globalContext, angleUnit)));
assert(std::isnan(e.characteristicXRange(globalContext, angleUnit)));
} else {
assert(std::fabs(e->characteristicXRange(globalContext, angleUnit) - range) < 0.0000001f);
assert(std::fabs(e.characteristicXRange(globalContext, angleUnit) - range) < 0.0000001f);
}
delete e;
}
QUIZ_CASE(poincare_characteristic_range) {
@@ -79,9 +83,10 @@ QUIZ_CASE(poincare_characteristic_range) {
}
void assert_parsed_expression_has_variables(const char * expression, const char * variables) {
Expression * e = parse_expression(expression);
Expression e = parse_expression(expression);
assert(!e.isUninitialized());
char variableBuffer[Expression::k_maxNumberOfVariables+1] = {0};
int numberOfVariables = e->getVariables(Poincare::Symbol::isVariableSymbol, variableBuffer);
int numberOfVariables = e.getVariables(Poincare::Symbol::isVariableSymbol, variableBuffer);
if (variables == nullptr) {
assert(numberOfVariables == -1);
} else {
@@ -91,7 +96,6 @@ void assert_parsed_expression_has_variables(const char * expression, const char
assert(*currentChar++ == *variables++);
}
}
delete e;
}
QUIZ_CASE(poincare_get_variables) {
@@ -100,25 +104,24 @@ QUIZ_CASE(poincare_get_variables) {
assert_parsed_expression_has_variables("abcdef", "abcdef");
assert_parsed_expression_has_variables("abcdefg", nullptr);
assert_parsed_expression_has_variables("abcde", "abcde");
assert_parsed_expression_has_variables("x^2+2*y+k!*A+w", "xykw");
// TODO 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, Preferences::AngleUnit angleUnit = Preferences::AngleUnit::Degree) {
GlobalContext globalContext;
Expression * e = parse_expression(expression);
Expression::Reduce(&e, globalContext, angleUnit);
Expression * coefficientBuffer[Poincare::Expression::k_maxNumberOfPolynomialCoefficients];
int d = e->getPolynomialCoefficients(symbolName, coefficientBuffer, globalContext, Radian);
Expression e = parse_expression(expression);
assert(!e.isUninitialized());
e = e.deepReduce(globalContext, angleUnit);
Expression coefficientBuffer[Poincare::Expression::k_maxNumberOfPolynomialCoefficients];
int d = e.getPolynomialReducedCoefficients(symbolName, coefficientBuffer, globalContext, Radian);
for (int i = 0; i <= d; i++) {
Expression * f = parse_expression(coefficients[i]);
Expression::Reduce(&coefficientBuffer[i], globalContext, angleUnit);
Expression::Reduce(&f, globalContext, angleUnit);
assert(coefficientBuffer[i]->isIdenticalTo(f));
delete f;
delete coefficientBuffer[i];
Expression f = parse_expression(coefficients[i]);
assert(!f.isUninitialized());
coefficientBuffer[i] = coefficientBuffer[i].deepReduce(globalContext, angleUnit);
f = f.deepReduce(globalContext, angleUnit);
assert(coefficientBuffer[i].isIdenticalTo(f));
}
assert(coefficients[d+1] == 0);
delete e;
}
QUIZ_CASE(poincare_get_polynomial_coefficients) {