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/test] Add VectorOperation tests, tidy rref tests

Browse Source 
Change-Id: I4072bee6b2d3bf1ad17045149bff8dcdb6a2f238
This commit is contained in:
Hugo Saint-Vignes
2020-07-22 12:07:46 +02:00
committed by Émilie Feral
parent 6db02ea122
commit 8d2af7e77f
4 changed files with 55 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
poincare/test/approximation.cpp
View File

@@ -420,26 +420,23 @@ QUIZ_CASE(poincare_approximation_function) {
assert_expression_approximates_to<double>("transpose([[1,7,5][4,2,8]])", "[[1,4][7,2][5,8]]");
assert_expression_approximates_to<double>("transpose([[1,2][4,5][7,8]])", "[[1,4,7][2,5,8]]");
/* Results for ref depend on the implementation. In any case :
* - Rows with only zeros must be at the bottom.
* - Leading coefficient of other rows must be to the right (strictly) of the
* - one above.
* - (Optional, but sometimes recommended) Leading coefficients must be 1. */
assert_expression_approximates_to<double>("ref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,1.4,1.2,1.6][0,1,1.1,1.2][0,0,1,1.2215568862275]]");
assert_expression_approximates_to<double>("rref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,0,0,3.3532934131737ᴇ-1][0,1,0,-0.1437125748503][0,0,1,1.2215568862275]]");
assert_expression_approximates_to<double>("ref([[1,0][5,6][0,10]])", "[[1,1.2][0,1][0,0]]");
assert_expression_approximates_to<double>("rref([[1,0][5,6][0,10]])", "[[1,0][0,1][0,0]]");
assert_expression_approximates_to<double>("ref([[0,0][0,0][0,0]])", "[[0,0][0,0][0,0]]");
assert_expression_approximates_to<double>("rref([[0,0][0,0][0,0]])", "[[0,0][0,0][0,0]]");
assert_expression_approximates_to<double>("ref([[0,2,-1][5,6,7][12,11,10]])", "[[1,9.1666666666667ᴇ-1,8.3333333333333ᴇ-1][0,1,-0.5][0,0,1]]");
assert_expression_approximates_to<double>("rref([[0,2,-1][5,6,7][12,11,10]])", "[[1,0,0][0,1,0][0,0,1]]");
assert_expression_approximates_to<double>("ref([[3,9][2,5]])", "[[1,3][0,1]]");
assert_expression_approximates_to<double>("ref([[3,2][5,7]])", "[[1,1.4][0,1]]");
assert_expression_approximates_to<double>("ref([[3,11][5,7]])", "[[1,1.4][0,1]]");
assert_expression_approximates_to<double>("ref([[2,5][2,7]])", "[[1,2.5][0,1]]");
assert_expression_approximates_to<double>("ref([[3,12][-4,1]])", "[[1,-0.25][0,1]]");
assert_expression_approximates_to<double>("ref([[0,1][1ᴇ-100,1]])", "[[1,1ᴇ100][0,1]]");
assert_expression_approximates_to<double>("rref([[0,1][1ᴇ-100,1]])", "[[1,0][0,1]]");
assert_expression_approximates_to<float>("ref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,1.4,1.2,1.6][0,1,1.1,1.2][0,0,1,1.221557]]");
assert_expression_approximates_to<float>("rref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,0,0,0.3353293][0,1,0,-0.1437126][0,0,1,1.221557]]");
assert_expression_approximates_to<float>("ref([[0,2,-1][5,6,7][12,11,10]])", "[[1,0.9166667,0.8333333][0,1,-0.5][0,0,1]]");
assert_expression_approximates_to<float>("rref([[0,2,-1][5,6,7][12,11,10]])", "[[1,0,0][0,1,0][0,0,1]]");
assert_expression_approximates_to<float>("cross([[1][2][3]],[[4][7][8]])", "[[-5][4][-1]]");
assert_expression_approximates_to<double>("cross([[1][2][3]],[[4][7][8]])", "[[-5][4][-1]]");
assert_expression_approximates_to<float>("dot([[1][2][3]],[[4][7][8]])", "42");
assert_expression_approximates_to<double>("dot([[1][2][3]],[[4][7][8]])", "42");
assert_expression_approximates_to<float>("norm([[-5][4][-1]])", "6.480741");
assert_expression_approximates_to<double>("norm([[-5][4][-1]])", "6.4807406984079");
assert_expression_approximates_to<float>("round(2.3246,3)", "2.325");
assert_expression_approximates_to<double>("round(2.3245,3)", "2.325");

1
poincare/test/expression_properties.cpp
View File

@@ -65,6 +65,7 @@ QUIZ_CASE(poincare_properties_is_matrix) {
assert_expression_has_property("transpose([[1,2][3,4]])", &context, Expression::IsMatrix);
assert_expression_has_property("ref([[1,2][3,4]])", &context, Expression::IsMatrix);
assert_expression_has_property("rref([[1,2][3,4]])", &context, Expression::IsMatrix);
assert_expression_has_property("cross([[1][2][3]],[[3][4][5]])", &context, Expression::IsMatrix);
assert_expression_has_not_property("2*3+1", &context, Expression::IsMatrix);
}

7
poincare/test/parsing.cpp
View File

@@ -365,12 +365,14 @@ QUIZ_CASE(poincare_parsing_identifiers) {
assert_parsed_expression_is("binomial(2,1)", BinomialCoefficient::Builder(BasedInteger::Builder(2),BasedInteger::Builder(1)));
assert_parsed_expression_is("ceil(1)", Ceiling::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("confidence(1,2)", ConfidenceInterval::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("cross(1,1)", VectorCross::Builder(BasedInteger::Builder(1),BasedInteger::Builder(1)));
assert_text_not_parsable("diff(1,2,3)");
assert_text_not_parsable("diff(0,_s,0)");
assert_parsed_expression_is("diff(1,x,3)", Derivative::Builder(BasedInteger::Builder(1),Symbol::Builder("x",1),BasedInteger::Builder(3)));
assert_parsed_expression_is("dim(1)", MatrixDimension::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("conj(1)", Conjugate::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("det(1)", Determinant::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("dot(1,1)", VectorDot::Builder(BasedInteger::Builder(1),BasedInteger::Builder(1)));
assert_parsed_expression_is("cos(1)", Cosine::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("cosh(1)", HyperbolicCosine::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("factor(1)", Factor::Builder(BasedInteger::Builder(1)));
@@ -393,6 +395,7 @@ QUIZ_CASE(poincare_parsing_identifiers) {
assert_parsed_expression_is("log{2}(1)", Logarithm::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("permute(2,1)", PermuteCoefficient::Builder(BasedInteger::Builder(2),BasedInteger::Builder(1)));
assert_parsed_expression_is("prediction95(1,2)", PredictionInterval::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("norm(1)", VectorNorm::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("prediction(1,2)", SimplePredictionInterval::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("product(1,n,2,3)", Product::Builder(BasedInteger::Builder(1),Symbol::Builder("n",1),BasedInteger::Builder(2),BasedInteger::Builder(3)));
assert_text_not_parsable("product(1,2,3,4)");
@@ -401,9 +404,11 @@ QUIZ_CASE(poincare_parsing_identifiers) {
assert_parsed_expression_is("random()", Random::Builder());
assert_parsed_expression_is("randint(1,2)", Randint::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("re(1)", RealPart::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("ref(1)", MatrixRowEchelonForm::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("rem(1,2)", DivisionRemainder::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("root(1,2)", NthRoot::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("round(1,2)", Round::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("rref(1)", MatrixReducedRowEchelonForm::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("sin(1)", Sine::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("sign(1)", SignFunction::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("sinh(1)", HyperbolicSine::Builder(BasedInteger::Builder(1)));
@@ -414,8 +419,6 @@ QUIZ_CASE(poincare_parsing_identifiers) {
assert_parsed_expression_is("tanh(1)", HyperbolicTangent::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("trace(1)", MatrixTrace::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("transpose(1)", MatrixTranspose::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("ref(1)", MatrixRowEchelonForm::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("rref(1)", MatrixReducedRowEchelonForm::Builder(BasedInteger::Builder(1)));
assert_parsed_expression_is("√(1)", SquareRoot::Builder(BasedInteger::Builder(1)));
assert_text_not_parsable("cos(1,2)");
assert_text_not_parsable("log(1,2,3)");

38
poincare/test/simplification.cpp
View File

@@ -381,10 +381,12 @@ QUIZ_CASE(poincare_simplification_units) {
assert_parsed_expression_simplify_to("conj(_s)", "undef");
assert_parsed_expression_simplify_to("cos(_s)", "undef");
assert_parsed_expression_simplify_to("cosh(_s)", "undef");
assert_parsed_expression_simplify_to("cross(_s,[[1][2][3]])", "undef");
assert_parsed_expression_simplify_to("det(_s)", "undef");
assert_parsed_expression_simplify_to("diff(_s,x,0)", "undef");
assert_parsed_expression_simplify_to("diff(0,x,_s)", "undef");
assert_parsed_expression_simplify_to("dim(_s)", "undef");
assert_parsed_expression_simplify_to("dot(_s,[[1][2][3]])", "undef");
assert_parsed_expression_simplify_to("factor(_s)", "undef");
assert_parsed_expression_simplify_to("(_s)!", "undef");
assert_parsed_expression_simplify_to("floor(_s)", "undef");
@@ -411,6 +413,7 @@ QUIZ_CASE(poincare_simplification_units) {
assert_parsed_expression_simplify_to("log(_s)", "undef");
assert_parsed_expression_simplify_to("log(_s,2)", "undef");
assert_parsed_expression_simplify_to("log(1,_s)", "undef");
assert_parsed_expression_simplify_to("norm(_s)", "undef");
assert_parsed_expression_simplify_to("normcdf(_s,2,3)", "undef");
assert_parsed_expression_simplify_to("normcdf(2,_s,3)", "undef");
assert_parsed_expression_simplify_to("normcdf(2,3,_s)", "undef");
@@ -435,10 +438,12 @@ QUIZ_CASE(poincare_simplification_units) {
assert_parsed_expression_simplify_to("randint(_s,1)", "undef");
assert_parsed_expression_simplify_to("randint(1,_s)", "undef");
assert_parsed_expression_simplify_to("re(_s)", "undef");
assert_parsed_expression_simplify_to("ref(_s)", "undef");
assert_parsed_expression_simplify_to("rem(_s,1)", "undef");
assert_parsed_expression_simplify_to("rem(1,_s)", "undef");
assert_parsed_expression_simplify_to("round(_s,1)", "undef");
assert_parsed_expression_simplify_to("round(1,_s)", "undef");
assert_parsed_expression_simplify_to("rref(_s)", "undef");
assert_parsed_expression_simplify_to("sign(_s)", "undef");
assert_parsed_expression_simplify_to("sin(_s)", "undef");
assert_parsed_expression_simplify_to("sinh(_s)", "undef");
@@ -449,8 +454,6 @@ QUIZ_CASE(poincare_simplification_units) {
assert_parsed_expression_simplify_to("tanh(_s)", "undef");
assert_parsed_expression_simplify_to("trace(_s)", "undef");
assert_parsed_expression_simplify_to("transpose(_s)", "undef");
assert_parsed_expression_simplify_to("ref(_s)", "undef");
assert_parsed_expression_simplify_to("rref(_s)", "undef");
/* Valid expressions */
assert_parsed_expression_simplify_to("-2×_A", "-2×_A");
@@ -960,6 +963,37 @@ QUIZ_CASE(poincare_simplification_matrix) {
assert_parsed_expression_simplify_to("ref([[1,0,√(4)][0,1,1/√(2)][0,0,1]])", "[[1,0,2][0,1,√(2)/2][0,0,1]]");
assert_parsed_expression_simplify_to("rref([[1,0,√(4)][0,1,1/√(2)][0,0,0]])", "[[1,0,2][0,1,√(2)/2][0,0,0]]");
assert_parsed_expression_simplify_to("ref([[1,0,3,4][5,7,6,8][0,10,11,12]])", "[[1,7/5,6/5,8/5][0,1,11/10,6/5][0,0,1,204/167]]");
assert_parsed_expression_simplify_to("ref([[1,0][5,6][0,10]])", "[[1,6/5][0,1][0,0]]");
assert_parsed_expression_simplify_to("rref([[1,0][5,6][0,10]])", "[[1,0][0,1][0,0]]");
assert_parsed_expression_simplify_to("ref([[0,0][0,0][0,0]])", "[[0,0][0,0][0,0]]");
assert_parsed_expression_simplify_to("rref([[0,0][0,0][0,0]])", "[[0,0][0,0][0,0]]");
assert_parsed_expression_simplify_to("rref([[0,1][1ᴇ-100,1]])", "[[1,0][0,1]]");
/* Results for ref depend on the implementation. In any case :
* - Rows with only zeros must be at the bottom.
* - Leading coefficient of other rows must be to the right (strictly) of the
* - one above.
* - (Optional, but sometimes recommended) Leading coefficients must be 1. */
assert_parsed_expression_simplify_to("ref([[3,9][2,5]])", "[[1,3][0,1]]");
assert_parsed_expression_simplify_to("ref([[3,2][5,7]])", "[[1,7/5][0,1]]");
assert_parsed_expression_simplify_to("ref([[3,11][5,7]])", "[[1,7/5][0,1]]");
assert_parsed_expression_simplify_to("ref([[2,5][2,7]])", "[[1,5/2][0,1]]");
assert_parsed_expression_simplify_to("ref([[3,12][-4,1]])", "[[1,-1/4][0,1]]");
assert_parsed_expression_simplify_to("ref([[0,1][1ᴇ-100,1]])", "[[1,10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000][0,1]]");
// Cross product
assert_parsed_expression_simplify_to("cross([[0][1/√(2)][0]],[[0][0][1]])", "[[√(2)/2][0][0]]");
assert_parsed_expression_simplify_to("cross([[1][2][3]],[[4][7][8]])", "[[-5][4][-1]]");
assert_parsed_expression_simplify_to("cross([[1][π][𝐢]],[[𝐢π][𝐢π^2][-π]])", "[[0][0][0]]");
// Dot product
assert_parsed_expression_simplify_to("dot([[1/√(2)][0][0]],[[1][0][0]])", "√(2)/2");
assert_parsed_expression_simplify_to("dot([[1][1][0]],[[0][0][1]])", "0");
assert_parsed_expression_simplify_to("dot([[1][1][1]],[[0][π][𝐢]])", "π+𝐢");
// Vector norm
assert_parsed_expression_simplify_to("norm([[1/√(2)][0][0]])", "√(2)/2");
assert_parsed_expression_simplify_to("norm([[1][2][3]])", "√(14)");
assert_parsed_expression_simplify_to("norm([[1][𝐢+1][π][-5]])", "√(π^2+28)");
// Expressions with unreduced matrix
assert_reduce("confidence(cos(2)/25,3)→a");