diff --git a/src/algebra/TinyMatrix.hpp b/src/algebra/TinyMatrix.hpp
index f4c66232816b33d8ee7e8ac897436507181d5644..e34f98ed8c25df7a77ba90bbd7cd05305b5eb115 100644
--- a/src/algebra/TinyMatrix.hpp
+++ b/src/algebra/TinyMatrix.hpp
@@ -150,11 +150,14 @@ class [[nodiscard]] TinyMatrix
{
os << '[';
for (size_t i = 0; i < M; ++i) {
- os << '(' << NaNHelper(A(i, 0));
+ if (i > 0) {
+ os << ',';
+ }
+ os << '[' << NaNHelper(A(i, 0));
for (size_t j = 1; j < N; ++j) {
os << ',' << NaNHelper(A(i, j));
}
- os << ')';
+ os << ']';
}
os << ']';
diff --git a/src/algebra/TinyVector.hpp b/src/algebra/TinyVector.hpp
index 3ca3d2a38550b5a31bb16843d25a35cebdb10fd0..ae616a4849d0e681bf09e613ad4d19263d0f035a 100644
--- a/src/algebra/TinyVector.hpp
+++ b/src/algebra/TinyVector.hpp
@@ -100,11 +100,11 @@ class [[nodiscard]] TinyVector
PUGS_INLINE
constexpr friend std::ostream& operator<<(std::ostream& os, const TinyVector& v)
{
- os << '(' << NaNHelper(v.m_values[0]);
+ os << '[' << NaNHelper(v.m_values[0]);
for (size_t i = 1; i < N; ++i) {
os << ',' << NaNHelper(v.m_values[i]);
}
- os << ')';
+ os << ']';
return os;
}
diff --git a/src/language/PEGGrammar.hpp b/src/language/PEGGrammar.hpp
index d173f50745e781d2be5cade0372a0b15524f4850..78aaafe96e4795542a639144827851bbc3421029 100644
--- a/src/language/PEGGrammar.hpp
+++ b/src/language/PEGGrammar.hpp
@@ -55,6 +55,9 @@ struct character : if_must_else< one< '\\' >, escaped_c, ascii::any> {};
struct open_parent : seq< one< '(' >, ignored > {};
struct close_parent : seq< one< ')' >, ignored > {};
+struct open_bracket : seq< one< '[' >, ignored > {};
+struct close_bracket : seq< one< ']' >, ignored > {};
+
struct literal : star< minus<character, one < '"' > > >{};
struct quoted_literal : if_must< one< '"' >, seq< literal, one< '"' > > >{};
@@ -153,11 +156,16 @@ struct COMMA : seq< comma , ignored > {};
struct expression;
struct parented_expression : if_must< open_parent, expression, close_parent >{};
-struct tuple_expression;
-struct function_argument_list : if_must< open_parent, opt< list_must< sor< tuple_expression, expression >, COMMA > >, close_parent >{};
+struct vector_expression : if_must< open_bracket, list_must<expression, COMMA >, close_bracket >{};
+
+struct row_expression : if_must< open_bracket, list_must<expression, COMMA >, close_bracket >{};
+struct matrix_expression : seq< open_bracket, list_must<row_expression, COMMA >, close_bracket >{};
+
+struct inner_expression_list;
+struct function_argument_list : if_must< open_parent, opt< list_must< sor< inner_expression_list, expression >, COMMA > >, close_parent >{};
struct function_evaluation : seq< NAME, function_argument_list > {};
-struct primary_expression : sor< BOOL, REAL, INTEGER, LITERAL, function_evaluation, NAME, parented_expression > {};
+struct primary_expression : sor< BOOL, REAL, INTEGER, LITERAL, function_evaluation, NAME, parented_expression, matrix_expression, vector_expression >{};
struct unary_plusplus : TAO_PEGTL_STRING("++") {};
struct unary_minusminus : TAO_PEGTL_STRING("--") {};
@@ -174,9 +182,6 @@ struct post_minusminus : TAO_PEGTL_STRING("--") {};
struct postfix_operator : seq< sor< post_plusplus, post_minusminus>, ignored > {};
-struct open_bracket : seq< one< '[' >, ignored > {};
-struct close_bracket : seq< one< ']' >, ignored > {};
-
struct subscript_expression : if_must< open_bracket, list_must<expression, COMMA>, close_bracket >{};
struct postfix_expression : seq< primary_expression, star< sor< subscript_expression , postfix_operator> > >{};
@@ -228,12 +233,12 @@ struct logical_or : list_must< logical_and, or_op >{};
struct expression : logical_or {};
-struct tuple_expression : seq< open_parent, expression, plus< if_must< COMMA, expression > >, close_parent >{};
+struct inner_expression_list : seq< open_parent, expression, plus< if_must< COMMA, expression > >, close_parent >{};
-struct expression_list : seq< open_parent, sor< seq< tuple_expression,
- star< if_must< COMMA, sor< tuple_expression, expression > > > >,
+struct expression_list : seq< open_parent, sor< seq< inner_expression_list,
+ star< if_must< COMMA, sor< inner_expression_list, expression > > > >,
seq< expression,
- plus< if_must< COMMA, sor< tuple_expression, expression > > > > >, close_parent >{};
+ plus< if_must< COMMA, sor< inner_expression_list, expression > > > > >, close_parent >{};
struct affect_op : sor< eq_op, multiplyeq_op, divideeq_op, pluseq_op, minuseq_op > {};
diff --git a/src/language/ast/ASTBuilder.cpp b/src/language/ast/ASTBuilder.cpp
index db7f77b29695bf82fc650ade4176592eefe5b651..4e380783e3af91072e130f9fa71a19164fcae08f 100644
--- a/src/language/ast/ASTBuilder.cpp
+++ b/src/language/ast/ASTBuilder.cpp
@@ -229,8 +229,11 @@ using selector = TAO_PEGTL_NAMESPACE::parse_tree::selector<
language::Z_set,
language::R_set,
language::type_name_id,
- language::tuple_expression,
+ language::inner_expression_list,
+ language::vector_expression,
language::vector_type,
+ language::matrix_expression,
+ language::row_expression,
language::matrix_type,
language::string_type,
language::var_declaration,
diff --git a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
index cc26d368ee6cb0d6a3f105604ae6484628d69890..32117039587e2c53907ea030ac73a7e10e544255 100644
--- a/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeAffectationExpressionBuilder.cpp
@@ -37,12 +37,6 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
ASTNode& lhs_node = *node.children[0];
ASTNode& rhs_node = *node.children[1];
- if (rhs_node.m_data_type == ASTNodeDataType::list_t) {
- if ((lhs_node.m_data_type == ASTNodeDataType::vector_t) or (lhs_node.m_data_type == ASTNodeDataType::matrix_t)) {
- ASTNodeNaturalConversionChecker(rhs_node, lhs_node.m_data_type);
- }
- }
-
node.m_node_processor = optional_processor_builder.value()->getNodeProcessor(lhs_node, rhs_node);
} else {
std::ostringstream error_message;
diff --git a/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp b/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp
index cdd9c43d977c6718dc5d900dbe0b96a15de54f47..e2b4a947f1f93fff1060e6fab3f578265b37526c 100644
--- a/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp
@@ -85,16 +85,6 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
// LCOV_EXCL_STOP
}
}
- case ASTNodeDataType::list_t: {
- if (argument_node_sub_data_type.m_parent_node.children.size() == parameter_v.dimension()) {
- return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, ParameterT>>(argument_number);
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: invalid argument dimension",
- std::vector{argument_node_sub_data_type.m_parent_node.begin()});
- // LCOV_EXCL_STOP
- }
- }
case ASTNodeDataType::int_t: {
if (argument_node_sub_data_type.m_parent_node.is_type<language::integer>()) {
if (std::stoi(argument_node_sub_data_type.m_parent_node.string()) == 0) {
@@ -162,17 +152,6 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
// LCOV_EXCL_STOP
}
}
- case ASTNodeDataType::list_t: {
- if (argument_node_sub_data_type.m_parent_node.children.size() ==
- (parameter_v.numberOfRows() * parameter_v.numberOfColumns())) {
- return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, ParameterT>>(argument_number);
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: invalid argument dimension",
- std::vector{argument_node_sub_data_type.m_parent_node.begin()});
- // LCOV_EXCL_STOP
- }
- }
case ASTNodeDataType::int_t: {
if (argument_node_sub_data_type.m_parent_node.is_type<language::integer>()) {
if (std::stoi(argument_node_sub_data_type.m_parent_node.string()) == 0) {
diff --git a/src/language/ast/ASTNodeDataTypeBuilder.cpp b/src/language/ast/ASTNodeDataTypeBuilder.cpp
index cb9e479df5f2e1f64edb4d5cb732acebcb505af6..6793bdcd1078fa738e1edd3f7a6146c4101e766c 100644
--- a/src/language/ast/ASTNodeDataTypeBuilder.cpp
+++ b/src/language/ast/ASTNodeDataTypeBuilder.cpp
@@ -45,45 +45,7 @@ ASTNodeDataTypeBuilder::_buildDeclarationNodeDataTypes(ASTNode& type_node, ASTNo
} else if (type_node.is_type<language::matrix_type>()) {
data_type = getMatrixDataType(type_node);
} else if (type_node.is_type<language::tuple_type_specifier>()) {
- const auto& content_node = type_node.children[0];
-
- if (content_node->is_type<language::type_name_id>()) {
- const std::string& type_name_id = content_node->string();
-
- auto& symbol_table = *type_node.m_symbol_table;
-
- const auto [i_type_symbol, found] = symbol_table.find(type_name_id, content_node->begin());
- if (not found) {
- throw ParseError("undefined type identifier", std::vector{content_node->begin()});
- } else if (i_type_symbol->attributes().dataType() != ASTNodeDataType::type_name_id_t) {
- std::ostringstream os;
- os << "invalid type identifier, '" << type_name_id << "' was previously defined as a '"
- << dataTypeName(i_type_symbol->attributes().dataType()) << '\'';
- throw ParseError(os.str(), std::vector{content_node->begin()});
- }
-
- content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::type_id_t>(type_name_id);
- } else if (content_node->is_type<language::B_set>()) {
- content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
- } else if (content_node->is_type<language::Z_set>()) {
- content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::int_t>();
- } else if (content_node->is_type<language::N_set>()) {
- content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
- } else if (content_node->is_type<language::R_set>()) {
- content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::double_t>();
- } else if (content_node->is_type<language::vector_type>()) {
- content_node->m_data_type = getVectorDataType(*type_node.children[0]);
- } else if (content_node->is_type<language::matrix_type>()) {
- content_node->m_data_type = getMatrixDataType(*type_node.children[0]);
- } else if (content_node->is_type<language::string_type>()) {
- content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::string_t>();
- } else {
- // LCOV_EXCL_START
- throw UnexpectedError("unexpected content type in tuple");
- // LCOV_EXCL_STOP
- }
-
- data_type = ASTNodeDataType::build<ASTNodeDataType::tuple_t>(content_node->m_data_type);
+ data_type = getTupleDataType(type_node);
} else if (type_node.is_type<language::string_type>()) {
data_type = ASTNodeDataType::build<ASTNodeDataType::string_t>();
} else if (type_node.is_type<language::type_name_id>()) {
@@ -154,6 +116,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
n.m_data_type = ASTNodeDataType::build<ASTNodeDataType::double_t>();
} else if (n.is_type<language::integer>()) {
n.m_data_type = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ } else if (n.is_type<language::row_expression>()) {
+ n.m_data_type = ASTNodeDataType::build<ASTNodeDataType::void_t>();
} else if (n.is_type<language::vector_type>()) {
n.m_data_type = getVectorDataType(n);
} else if (n.is_type<language::matrix_type>()) {
@@ -322,6 +286,11 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
this->_buildNodeDataTypes(*child);
}
+ if (n.is_type<language::vector_expression>()) {
+ n.m_data_type = getVectorExpressionType(n);
+ } else if (n.is_type<language::matrix_expression>()) {
+ n.m_data_type = getMatrixExpressionType(n);
+ }
if (n.is_type<language::break_kw>() or n.is_type<language::continue_kw>()) {
n.m_data_type = ASTNodeDataType::build<ASTNodeDataType::void_t>();
} else if (n.is_type<language::eq_op>() or n.is_type<language::multiplyeq_op>() or
@@ -329,7 +298,7 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
n.is_type<language::minuseq_op>()) {
n.m_data_type = ASTNodeDataType::build<ASTNodeDataType::void_t>();
- } else if (n.is_type<language::tuple_expression>()) {
+ } else if (n.is_type<language::inner_expression_list>()) {
std::vector<std::shared_ptr<const ASTNodeDataType>> sub_data_type_list;
sub_data_type_list.reserve(n.children.size());
@@ -365,6 +334,8 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n) const
value_type = ASTNodeDataType::build<ASTNodeDataType::string_t>();
} else if (image_node.is_type<language::type_name_id>()) {
value_type = ASTNodeDataType::build<ASTNodeDataType::type_id_t>(image_node.m_data_type.nameOfTypeId());
+ } else if (image_node.is_type<language::tuple_type_specifier>()) {
+ value_type = getTupleDataType(image_node);
}
// LCOV_EXCL_START
diff --git a/src/language/ast/ASTNodeExpressionBuilder.cpp b/src/language/ast/ASTNodeExpressionBuilder.cpp
index bbbcda43e788356d6bf4ec338643a79049069fc0..70722aea1a1ac73851df7157820a029e87266a66 100644
--- a/src/language/ast/ASTNodeExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeExpressionBuilder.cpp
@@ -16,10 +16,11 @@
#include <language/node_processor/FakeProcessor.hpp>
#include <language/node_processor/ForProcessor.hpp>
#include <language/node_processor/IfProcessor.hpp>
+#include <language/node_processor/InnerListToVectorProcessor.hpp>
#include <language/node_processor/LocalNameProcessor.hpp>
#include <language/node_processor/NameProcessor.hpp>
-#include <language/node_processor/TupleToTinyVectorProcessor.hpp>
-#include <language/node_processor/TupleToVectorProcessor.hpp>
+#include <language/node_processor/TinyMatrixExpressionProcessor.hpp>
+#include <language/node_processor/TinyVectorExpressionProcessor.hpp>
#include <language/node_processor/ValueProcessor.hpp>
#include <language/node_processor/WhileProcessor.hpp>
#include <language/utils/ParseError.hpp>
@@ -51,8 +52,9 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
ASTNodeAffectationExpressionBuilder{n};
}
- } else if (n.is_type<language::tuple_expression>()) {
- n.m_node_processor = std::make_unique<TupleToVectorProcessor<ASTNodeExpressionListProcessor>>(n);
+ } else if (n.is_type<language::inner_expression_list>()) {
+ n.m_node_processor = std::make_unique<InnerListToVectorProcessor>(n);
+
} else if (n.is_type<language::function_definition>()) {
this->_checkIsPureFunction(n);
@@ -75,6 +77,54 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
} else if (n.is_type<language::false_kw>()) {
n.m_node_processor = std::make_unique<ValueProcessor>(n);
+ } else if (n.is_type<language::vector_expression>()) {
+ Assert(n.m_data_type == ASTNodeDataType::vector_t);
+ switch (n.m_data_type.dimension()) {
+ case 1: {
+ n.m_node_processor = std::make_unique<TinyVectorExpressionProcessor<1>>(n);
+ break;
+ }
+ case 2: {
+ n.m_node_processor = std::make_unique<TinyVectorExpressionProcessor<2>>(n);
+ break;
+ }
+ case 3: {
+ n.m_node_processor = std::make_unique<TinyVectorExpressionProcessor<3>>(n);
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid vector dimension");
+ }
+ // LCOV_EXCL_STOP
+ }
+ } else if (n.is_type<language::matrix_expression>()) {
+ Assert(n.m_data_type == ASTNodeDataType::matrix_t);
+ Assert(n.m_data_type.numberOfRows() == n.m_data_type.numberOfColumns());
+
+ switch (n.m_data_type.numberOfRows()) {
+ case 1: {
+ n.m_node_processor = std::make_unique<TinyMatrixExpressionProcessor<1, 1>>(n);
+ break;
+ }
+ case 2: {
+ n.m_node_processor = std::make_unique<TinyMatrixExpressionProcessor<2, 2>>(n);
+ break;
+ }
+ case 3: {
+ n.m_node_processor = std::make_unique<TinyMatrixExpressionProcessor<3, 3>>(n);
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid matrix dimension");
+ }
+ // LCOV_EXCL_STOP
+ }
+
+ } else if ((n.is_type<language::row_expression>())) {
+ n.m_node_processor = std::make_unique<FakeProcessor>();
+
} else if ((n.is_type<language::function_argument_list>()) or (n.is_type<language::expression_list>())) {
n.m_node_processor = std::make_unique<ASTNodeExpressionListProcessor>(n);
diff --git a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
index 6a91a15d13978b423daa563c1b668c5fe0f93489..a381123884250e9cd574495d7c3add369863aa59 100644
--- a/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeFunctionExpressionBuilder.cpp
@@ -3,8 +3,6 @@
#include <language/PEGGrammar.hpp>
#include <language/ast/ASTNodeDataTypeFlattener.hpp>
#include <language/node_processor/FunctionProcessor.hpp>
-#include <language/node_processor/TupleToTinyMatrixProcessor.hpp>
-#include <language/node_processor/TupleToTinyVectorProcessor.hpp>
#include <language/utils/ASTNodeNaturalConversionChecker.hpp>
#include <language/utils/FunctionTable.hpp>
#include <language/utils/SymbolTable.hpp>
@@ -80,16 +78,6 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
// LCOV_EXCL_STOP
}
}
- case ASTNodeDataType::list_t: {
- if (node_sub_data_type.m_parent_node.children.size() == parameter_v.dimension()) {
- return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, ParameterT>>(parameter_id);
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: invalid argument dimension",
- std::vector{node_sub_data_type.m_parent_node.begin()});
- // LCOV_EXCL_STOP
- }
- }
case ASTNodeDataType::int_t: {
if (node_sub_data_type.m_parent_node.is_type<language::integer>()) {
if (std::stoi(node_sub_data_type.m_parent_node.string()) == 0) {
@@ -122,16 +110,6 @@ ASTNodeFunctionExpressionBuilder::_getArgumentConverter(SymbolType& parameter_sy
// LCOV_EXCL_STOP
}
}
- case ASTNodeDataType::list_t: {
- if (node_sub_data_type.m_parent_node.children.size() == parameter_v.dimension()) {
- return std::make_unique<FunctionTinyMatrixArgumentConverter<ParameterT, ParameterT>>(parameter_id);
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: invalid argument dimension",
- std::vector{node_sub_data_type.m_parent_node.begin()});
- // LCOV_EXCL_STOP
- }
- }
case ASTNodeDataType::int_t: {
if (node_sub_data_type.m_parent_node.is_type<language::integer>()) {
if (std::stoi(node_sub_data_type.m_parent_node.string()) == 0) {
@@ -327,17 +305,6 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
// LCOV_EXCL_STOP
}
}
- case ASTNodeDataType::list_t: {
- if (function_component_expression.children.size() == return_v.dimension()) {
- return std::make_unique<FunctionExpressionProcessor<ReturnT, AggregateDataVariant>>(
- function_component_expression);
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: invalid dimension for returned vector",
- std::vector{function_component_expression.begin()});
- // LCOV_EXCL_STOP
- }
- }
case ASTNodeDataType::int_t: {
if (function_component_expression.is_type<language::integer>()) {
if (std::stoi(function_component_expression.string()) == 0) {
@@ -372,17 +339,6 @@ ASTNodeFunctionExpressionBuilder::_getFunctionProcessor(const ASTNodeDataType& r
// LCOV_EXCL_STOP
}
}
- case ASTNodeDataType::list_t: {
- if (function_component_expression.children.size() == return_v.dimension()) {
- return std::make_unique<FunctionExpressionProcessor<ReturnT, AggregateDataVariant>>(
- function_component_expression);
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: invalid dimension for returned vector",
- std::vector{function_component_expression.begin()});
- // LCOV_EXCL_STOP
- }
- }
case ASTNodeDataType::int_t: {
if (function_component_expression.is_type<language::integer>()) {
if (std::stoi(function_component_expression.string()) == 0) {
@@ -561,33 +517,7 @@ ASTNodeFunctionExpressionBuilder::ASTNodeFunctionExpressionBuilder(ASTNode& node
ASTNodeNaturalConversionChecker<AllowRToR1Conversion>{function_expression, vector_type};
- if (function_expression.is_type<language::expression_list>()) {
- Assert(vector_type.dimension() == function_expression.children.size());
-
- for (size_t i = 0; i < vector_type.dimension(); ++i) {
- function_processor->addFunctionExpressionProcessor(
- this->_getFunctionProcessor(ASTNodeDataType::build<ASTNodeDataType::double_t>(), node,
- *function_expression.children[i]));
- }
-
- switch (vector_type.dimension()) {
- case 2: {
- node.m_node_processor =
- std::make_unique<TupleToTinyVectorProcessor<FunctionProcessor, 2>>(node, std::move(function_processor));
- break;
- }
- case 3: {
- node.m_node_processor =
- std::make_unique<TupleToTinyVectorProcessor<FunctionProcessor, 3>>(node, std::move(function_processor));
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: invalid vector_t dimension", std::vector{node.begin()});
- }
- // LCOV_EXCL_STOP
- }
- } else if (function_expression.is_type<language::integer>()) {
+ if (function_expression.is_type<language::integer>()) {
if (std::stoi(function_expression.string()) == 0) {
switch (vector_type.dimension()) {
case 1: {
@@ -628,33 +558,7 @@ ASTNodeFunctionExpressionBuilder::ASTNodeFunctionExpressionBuilder(ASTNode& node
ASTNodeNaturalConversionChecker<AllowRToR1Conversion>{function_expression, matrix_type};
- if (function_expression.is_type<language::expression_list>()) {
- Assert(matrix_type.numberOfRows() * matrix_type.numberOfColumns() == function_expression.children.size());
-
- for (size_t i = 0; i < matrix_type.numberOfRows() * matrix_type.numberOfColumns(); ++i) {
- function_processor->addFunctionExpressionProcessor(
- this->_getFunctionProcessor(ASTNodeDataType::build<ASTNodeDataType::double_t>(), node,
- *function_expression.children[i]));
- }
-
- switch (matrix_type.numberOfRows()) {
- case 2: {
- node.m_node_processor =
- std::make_unique<TupleToTinyMatrixProcessor<FunctionProcessor, 2>>(node, std::move(function_processor));
- break;
- }
- case 3: {
- node.m_node_processor =
- std::make_unique<TupleToTinyMatrixProcessor<FunctionProcessor, 3>>(node, std::move(function_processor));
- break;
- }
- // LCOV_EXCL_START
- default: {
- throw ParseError("unexpected error: invalid matrix_t dimensions", std::vector{node.begin()});
- }
- // LCOV_EXCL_STOP
- }
- } else if (function_expression.is_type<language::integer>()) {
+ if (function_expression.is_type<language::integer>()) {
if (std::stoi(function_expression.string()) == 0) {
switch (matrix_type.numberOfRows()) {
case 1: {
diff --git a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp
index edec0c149615f28a35256afc62f3ceef3182c3e1..5ec9c784508f92d9051e23d72e8cbd420712346c 100644
--- a/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp
+++ b/src/language/ast/ASTNodeListAffectationExpressionBuilder.cpp
@@ -37,8 +37,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
}
// LCOV_EXCL_START
default: {
- throw ParseError("unexpected error: invalid operand type for affectation",
- std::vector{node_sub_data_type.m_parent_node.begin()});
+ throw UnexpectedError("invalid operand type for affectation");
}
// LCOV_EXCL_STOP
}
@@ -58,25 +57,21 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
if ((node_sub_data_type.m_data_type == ASTNodeDataType::vector_t) and
(node_sub_data_type.m_data_type.dimension() == value.dimension())) {
list_affectation_processor->template add<ValueT, ValueT>(value_node);
- } else if ((node_sub_data_type.m_data_type == ASTNodeDataType::list_t) and
- (node_sub_data_type.m_parent_node.children.size() == value.dimension())) {
- list_affectation_processor->template add<ValueT, AggregateDataVariant>(value_node);
} else if (node_sub_data_type.m_parent_node.is_type<language::integer>()) {
if (std::stoi(node_sub_data_type.m_parent_node.string()) == 0) {
list_affectation_processor->template add<ValueT, ZeroType>(value_node);
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: invalid operand value",
- std::vector{node_sub_data_type.m_parent_node.begin()});
+ throw UnexpectedError("unexpected error: invalid operand value");
// LCOV_EXCL_STOP
}
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: invalid dimension", std::vector{node_sub_data_type.m_parent_node.begin()});
+ throw UnexpectedError("invalid dimension");
// LCOV_EXCL_STOP
}
} else {
- throw ParseError("unexpected error: invalid value type", std::vector{node_sub_data_type.m_parent_node.begin()});
+ static_assert(std::is_same_v<ValueT, TinyVector<1>>, "unexpected value type");
}
};
@@ -96,25 +91,585 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
(node_sub_data_type.m_data_type.numberOfRows() == value.numberOfRows()) and
(node_sub_data_type.m_data_type.numberOfColumns() == value.numberOfColumns())) {
list_affectation_processor->template add<ValueT, ValueT>(value_node);
- } else if ((node_sub_data_type.m_data_type == ASTNodeDataType::list_t) and
- (node_sub_data_type.m_parent_node.children.size() == value.numberOfRows() * value.numberOfColumns())) {
- list_affectation_processor->template add<ValueT, AggregateDataVariant>(value_node);
} else if (node_sub_data_type.m_parent_node.is_type<language::integer>()) {
if (std::stoi(node_sub_data_type.m_parent_node.string()) == 0) {
list_affectation_processor->template add<ValueT, ZeroType>(value_node);
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: invalid operand value",
- std::vector{node_sub_data_type.m_parent_node.begin()});
+ throw UnexpectedError("invalid operand value");
// LCOV_EXCL_STOP
}
} else {
// LCOV_EXCL_START
- throw ParseError("unexpected error: invalid dimension", std::vector{node_sub_data_type.m_parent_node.begin()});
+ throw UnexpectedError("invalid dimension");
// LCOV_EXCL_STOP
}
} else {
- throw ParseError("unexpected error: invalid value type", std::vector{node_sub_data_type.m_parent_node.begin()});
+ static_assert(std::is_same_v<ValueT, TinyMatrix<1>>, "unexpected value type");
+ }
+ };
+
+ auto add_affectation_processor_for_tuple_data = [&](const ASTNodeDataType& tuple_type,
+ const ASTNodeSubDataType& node_sub_data_type) {
+ if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
+ if (node_sub_data_type.m_data_type == ASTNodeDataType::tuple_t) {
+ const ASTNodeDataType& rhs_tuple_content = node_sub_data_type.m_data_type.contentType();
+ switch (tuple_type.contentType()) {
+ case ASTNodeDataType::bool_t: {
+ if (rhs_tuple_content == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<bool>, std::vector<bool>>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::unsigned_int_t: {
+ if (rhs_tuple_content == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<uint64_t>, std::vector<bool>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<uint64_t>, std::vector<uint64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<uint64_t>, std::vector<int64_t>>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::int_t: {
+ if (rhs_tuple_content == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<int64_t>, std::vector<bool>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<int64_t>, std::vector<uint64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<int64_t>, std::vector<int64_t>>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::double_t: {
+ if (rhs_tuple_content == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<double>, std::vector<bool>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<double>, std::vector<uint64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<double>, std::vector<int64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::double_t) {
+ list_affectation_processor->template add<std::vector<double>, std::vector<double>>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::string_t: {
+ if (rhs_tuple_content == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<bool>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<uint64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<int64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::double_t) {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<double>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::string_t) {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<std::string>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::vector_t) {
+ switch (rhs_tuple_content.dimension()) {
+ case 1: {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<TinyVector<1>>>(
+ value_node);
+ break;
+ }
+ case 2: {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<TinyVector<2>>>(
+ value_node);
+ break;
+ }
+ case 3: {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<TinyVector<3>>>(
+ value_node);
+ break;
+ }
+ }
+ } else if (rhs_tuple_content == ASTNodeDataType::matrix_t) {
+ Assert(rhs_tuple_content.numberOfRows() == rhs_tuple_content.numberOfColumns());
+ switch (rhs_tuple_content.numberOfRows()) {
+ case 1: {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<TinyMatrix<1>>>(
+ value_node);
+ break;
+ }
+ case 2: {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<TinyMatrix<2>>>(
+ value_node);
+ break;
+ }
+ case 3: {
+ list_affectation_processor->template add<std::vector<std::string>, std::vector<TinyMatrix<3>>>(
+ value_node);
+ break;
+ }
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::vector_t: {
+ switch (tuple_type.contentType().dimension()) {
+ case 1: {
+ if (rhs_tuple_content == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<bool>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<uint64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<int64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::double_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<double>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::vector_t) {
+ Assert(rhs_tuple_content.dimension() == 1);
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, std::vector<TinyVector<1>>>(
+ value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case 2: {
+ if (rhs_tuple_content == ASTNodeDataType::vector_t) {
+ Assert(rhs_tuple_content.dimension() == 2);
+ list_affectation_processor->template add<std::vector<TinyVector<2>>, std::vector<TinyVector<2>>>(
+ value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case 3: {
+ if (rhs_tuple_content == ASTNodeDataType::vector_t) {
+ Assert(rhs_tuple_content.dimension() == 3);
+ list_affectation_processor->template add<std::vector<TinyVector<3>>, std::vector<TinyVector<3>>>(
+ value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid dimension");
+ }
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::matrix_t: {
+ Assert(tuple_type.contentType().numberOfRows() == tuple_type.contentType().numberOfColumns());
+ switch (tuple_type.contentType().numberOfRows()) {
+ case 1: {
+ if (rhs_tuple_content == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<bool>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<uint64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<int64_t>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::double_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<double>>(value_node);
+ } else if (rhs_tuple_content == ASTNodeDataType::matrix_t) {
+ Assert(rhs_tuple_content.numberOfRows() == 1);
+ Assert(rhs_tuple_content.numberOfColumns() == 1);
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, std::vector<TinyMatrix<1>>>(
+ value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case 2: {
+ if (rhs_tuple_content == ASTNodeDataType::matrix_t) {
+ Assert(rhs_tuple_content.numberOfRows() == 2);
+ Assert(rhs_tuple_content.numberOfColumns() == 2);
+ list_affectation_processor->template add<std::vector<TinyMatrix<2>>, std::vector<TinyMatrix<2>>>(
+ value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case 3: {
+ if (rhs_tuple_content == ASTNodeDataType::matrix_t) {
+ Assert(rhs_tuple_content.numberOfRows() == 3);
+ Assert(rhs_tuple_content.numberOfColumns() == 3);
+ list_affectation_processor->template add<std::vector<TinyMatrix<3>>, std::vector<TinyMatrix<3>>>(
+ value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid dimension");
+ }
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::type_id_t: {
+ if (rhs_tuple_content == ASTNodeDataType::type_id_t) {
+ Assert(rhs_tuple_content.nameOfTypeId() == tuple_type.contentType().nameOfTypeId());
+ list_affectation_processor->template add<std::vector<EmbeddedData>, std::vector<EmbeddedData>>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid operand type for tuple affectation");
+ }
+ // LCOV_EXCL_STOP
+ }
+ } else if (node_sub_data_type.m_data_type == ASTNodeDataType::list_t) {
+ switch (tuple_type.contentType()) {
+ case ASTNodeDataType::bool_t: {
+ list_affectation_processor->template add<std::vector<bool>, AggregateDataVariant>(value_node);
+ break;
+ }
+ case ASTNodeDataType::unsigned_int_t: {
+ list_affectation_processor->template add<std::vector<uint64_t>, AggregateDataVariant>(value_node);
+ break;
+ }
+ case ASTNodeDataType::int_t: {
+ list_affectation_processor->template add<std::vector<int64_t>, AggregateDataVariant>(value_node);
+ break;
+ }
+ case ASTNodeDataType::double_t: {
+ list_affectation_processor->template add<std::vector<double_t>, AggregateDataVariant>(value_node);
+ break;
+ }
+ case ASTNodeDataType::string_t: {
+ list_affectation_processor->template add<std::vector<std::string>, AggregateDataVariant>(value_node);
+ break;
+ }
+ case ASTNodeDataType::vector_t: {
+ switch (tuple_type.contentType().dimension()) {
+ case 1: {
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, AggregateDataVariant>(value_node);
+ break;
+ }
+ case 2: {
+ list_affectation_processor->template add<std::vector<TinyVector<2>>, AggregateDataVariant>(value_node);
+ break;
+ }
+ case 3: {
+ list_affectation_processor->template add<std::vector<TinyVector<3>>, AggregateDataVariant>(value_node);
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid vector dimension");
+ }
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::matrix_t: {
+ Assert(tuple_type.contentType().numberOfRows() == tuple_type.contentType().numberOfColumns());
+ switch (tuple_type.contentType().numberOfRows()) {
+ case 1: {
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, AggregateDataVariant>(value_node);
+ break;
+ }
+ case 2: {
+ list_affectation_processor->template add<std::vector<TinyMatrix<2>>, AggregateDataVariant>(value_node);
+ break;
+ }
+ case 3: {
+ list_affectation_processor->template add<std::vector<TinyMatrix<3>>, AggregateDataVariant>(value_node);
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid matrix dimension");
+ }
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::type_id_t: {
+ list_affectation_processor->template add<std::vector<EmbeddedData>, AggregateDataVariant>(value_node);
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid operand type for tuple affectation");
+ }
+ // LCOV_EXCL_STOP
+ }
+ } else {
+ const ASTNodeDataType& rhs_type = node_sub_data_type.m_data_type;
+ switch (tuple_type.contentType()) {
+ case ASTNodeDataType::bool_t: {
+ if (rhs_type == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<bool>, bool>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::unsigned_int_t: {
+ if (rhs_type == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<uint64_t>, bool>(value_node);
+ } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<uint64_t>, uint64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<uint64_t>, int64_t>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::int_t: {
+ if (rhs_type == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<int64_t>, bool>(value_node);
+ } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<int64_t>, uint64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<int64_t>, int64_t>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::double_t: {
+ if (rhs_type == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<double>, bool>(value_node);
+ } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<double>, uint64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<double>, int64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::double_t) {
+ list_affectation_processor->template add<std::vector<double>, double>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::string_t: {
+ if (rhs_type == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<std::string>, bool>(value_node);
+ } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<std::string>, uint64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<std::string>, int64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::double_t) {
+ list_affectation_processor->template add<std::vector<std::string>, double>(value_node);
+ } else if (rhs_type == ASTNodeDataType::string_t) {
+ list_affectation_processor->template add<std::vector<std::string>, std::string>(value_node);
+ } else if (rhs_type == ASTNodeDataType::vector_t) {
+ switch (rhs_type.dimension()) {
+ case 1: {
+ list_affectation_processor->template add<std::vector<std::string>, TinyVector<1>>(value_node);
+ break;
+ }
+ case 2: {
+ list_affectation_processor->template add<std::vector<std::string>, TinyVector<2>>(value_node);
+ break;
+ }
+ case 3: {
+ list_affectation_processor->template add<std::vector<std::string>, TinyVector<3>>(value_node);
+ break;
+ }
+ }
+ } else if (rhs_type == ASTNodeDataType::matrix_t) {
+ Assert(rhs_type.numberOfRows() == rhs_type.numberOfColumns());
+ switch (rhs_type.numberOfRows()) {
+ case 1: {
+ list_affectation_processor->template add<std::vector<std::string>, TinyMatrix<1>>(value_node);
+ break;
+ }
+ case 2: {
+ list_affectation_processor->template add<std::vector<std::string>, TinyMatrix<2>>(value_node);
+ break;
+ }
+ case 3: {
+ list_affectation_processor->template add<std::vector<std::string>, TinyMatrix<3>>(value_node);
+ break;
+ }
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible rhs type in tuple affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::vector_t: {
+ switch (tuple_type.contentType().dimension()) {
+ case 1: {
+ if (rhs_type == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, bool>(value_node);
+ } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, uint64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, int64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::double_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, double>(value_node);
+ } else if (rhs_type == ASTNodeDataType::vector_t) {
+ Assert(rhs_type.dimension() == 1);
+ list_affectation_processor->template add<std::vector<TinyVector<1>>, TinyVector<1>>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case 2: {
+ if (rhs_type == ASTNodeDataType::vector_t) {
+ Assert(rhs_type.dimension() == 2);
+ list_affectation_processor->template add<std::vector<TinyVector<2>>, TinyVector<2>>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<2>>, int64_t>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case 3: {
+ if (rhs_type == ASTNodeDataType::vector_t) {
+ Assert(rhs_type.dimension() == 3);
+ list_affectation_processor->template add<std::vector<TinyVector<3>>, TinyVector<3>>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<TinyVector<3>>, int64_t>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid vector dimension for tuple affectation");
+ }
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::matrix_t: {
+ Assert(tuple_type.contentType().numberOfRows() == tuple_type.contentType().numberOfColumns());
+ switch (tuple_type.contentType().numberOfRows()) {
+ case 1: {
+ if (rhs_type == ASTNodeDataType::bool_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, bool>(value_node);
+ } else if (rhs_type == ASTNodeDataType::unsigned_int_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, uint64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, int64_t>(value_node);
+ } else if (rhs_type == ASTNodeDataType::double_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, double>(value_node);
+ } else if (rhs_type == ASTNodeDataType::matrix_t) {
+ Assert(rhs_type.numberOfRows() == 1);
+ Assert(rhs_type.numberOfColumns() == 1);
+ list_affectation_processor->template add<std::vector<TinyMatrix<1>>, TinyMatrix<1>>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case 2: {
+ if (rhs_type == ASTNodeDataType::matrix_t) {
+ Assert(rhs_type.numberOfRows() == 2);
+ Assert(rhs_type.numberOfColumns() == 2);
+ list_affectation_processor->template add<std::vector<TinyMatrix<2>>, TinyMatrix<2>>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<2>>, int64_t>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case 3: {
+ if (rhs_type == ASTNodeDataType::matrix_t) {
+ Assert(rhs_type.numberOfRows() == 3);
+ Assert(rhs_type.numberOfColumns() == 3);
+ list_affectation_processor->template add<std::vector<TinyMatrix<3>>, TinyMatrix<3>>(value_node);
+ } else if (rhs_type == ASTNodeDataType::int_t) {
+ list_affectation_processor->template add<std::vector<TinyMatrix<3>>, int64_t>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid vector dimension for tuple affectation");
+ }
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::type_id_t: {
+ if (rhs_type == ASTNodeDataType::type_id_t) {
+ Assert(rhs_type.nameOfTypeId() == tuple_type.contentType().nameOfTypeId());
+ list_affectation_processor->template add<std::vector<EmbeddedData>, EmbeddedData>(value_node);
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("incompatible tuple types in affectation");
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid operand type for tuple affectation");
+ }
+ // LCOV_EXCL_STOP
+ }
+ }
+ } else {
+ static_assert(std::is_same_v<OperatorT, language::eq_op>, "unexpected operator type");
}
};
@@ -127,14 +682,12 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
}
// LCOV_EXCL_START
default: {
- throw ParseError("unexpected error:invalid operand type for embedded data affectation",
- std::vector{node_sub_data_type.m_parent_node.begin()});
+ throw UnexpectedError("invalid operand type for embedded data affectation");
}
// LCOV_EXCL_STOP
}
} else {
- throw ParseError("unexpected error: undefined operator type for embedded data affectation",
- std::vector{m_node.begin()});
+ static_assert(std::is_same_v<OperatorT, language::eq_op>, "unexpected operator type");
}
};
@@ -177,22 +730,44 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
}
// LCOV_EXCL_START
default: {
- throw ParseError("unexpected error: invalid vector dimension",
- std::vector{node_sub_data_type.m_parent_node.begin()});
+ throw UnexpectedError("invalid vector dimension");
+ }
+ // LCOV_EXCL_STOP
+ }
+ break;
+ }
+ case ASTNodeDataType::matrix_t: {
+ Assert(node_sub_data_type.m_data_type.numberOfRows() == node_sub_data_type.m_data_type.numberOfColumns());
+ switch (node_sub_data_type.m_data_type.numberOfRows()) {
+ case 1: {
+ list_affectation_processor->template add<std::string, TinyMatrix<1>>(value_node);
+ break;
+ }
+ case 2: {
+ list_affectation_processor->template add<std::string, TinyMatrix<2>>(value_node);
+ break;
+ }
+ case 3: {
+ list_affectation_processor->template add<std::string, TinyMatrix<3>>(value_node);
+ break;
+ }
+ // LCOV_EXCL_START
+ default: {
+ throw UnexpectedError("invalid vector dimension");
}
// LCOV_EXCL_STOP
}
break;
}
+
// LCOV_EXCL_START
default: {
- throw ParseError("unexpected error:invalid operand type for string affectation",
- std::vector{node_sub_data_type.m_parent_node.begin()});
+ throw UnexpectedError("invalid operand type for string affectation");
}
// LCOV_EXCL_STOP
}
} else {
- throw ParseError("unexpected error: undefined operator type for string affectation", std::vector{m_node.begin()});
+ static_assert(std::is_same_v<OperatorT, language::eq_op>, "unexpected operator type");
}
};
@@ -235,7 +810,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
}
// LCOV_EXCL_START
default: {
- throw ParseError("invalid dimension", std::vector{value_node.begin()});
+ throw UnexpectedError("invalid dimension");
}
// LCOV_EXCL_STOP
}
@@ -258,7 +833,7 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
}
// LCOV_EXCL_START
default: {
- throw ParseError("invalid dimension", std::vector{value_node.begin()});
+ throw UnexpectedError("invalid dimension");
}
// LCOV_EXCL_STOP
}
@@ -267,10 +842,14 @@ ASTNodeListAffectationExpressionBuilder::_buildAffectationProcessor(
case ASTNodeDataType::string_t: {
add_affectation_processor_for_string_data(node_sub_data_type);
break;
+ }
+ case ASTNodeDataType::tuple_t: {
+ add_affectation_processor_for_tuple_data(value_type, node_sub_data_type);
+ break;
}
// LCOV_EXCL_START
default: {
- throw ParseError("unexpected error: undefined value type for tuple affectation", std::vector{value_node.begin()});
+ throw UnexpectedError("unexpected error: undefined value type for tuple affectation");
}
// LCOV_EXCL_STOP
}
diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp
index 6b764b8d8a0d013b1170f754cb6d551e68ab0fff..bb9b7f03667783c99d19dc34ac5d0befbd98d969 100644
--- a/src/language/node_processor/AffectationProcessor.hpp
+++ b/src/language/node_processor/AffectationProcessor.hpp
@@ -82,6 +82,15 @@ class AffectationExecutor final : public IAffectationExecutor
return true;
}()};
+ template <typename T>
+ std::string
+ _stringify(const T& value)
+ {
+ std::ostringstream os;
+ os << std::boolalpha << value;
+ return os.str();
+ }
+
public:
AffectationExecutor(ASTNode& node, ValueT& lhs) : m_lhs(lhs)
{
@@ -101,65 +110,20 @@ class AffectationExecutor final : public IAffectationExecutor
if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
if constexpr (std::is_same_v<std::string, DataT>) {
m_lhs = std::get<DataT>(rhs);
- } else if constexpr (std::is_arithmetic_v<DataT>) {
- m_lhs = std::to_string(std::get<DataT>(rhs));
} else {
- std::ostringstream os;
- os << std::get<DataT>(rhs);
- m_lhs = os.str();
+ m_lhs = std::move(_stringify(std::get<DataT>(rhs)));
}
} else {
if constexpr (std::is_same_v<std::string, DataT>) {
m_lhs += std::get<std::string>(rhs);
- } else if constexpr (std::is_arithmetic_v<DataT>) {
- m_lhs += std::to_string(std::get<DataT>(rhs));
} else {
- std::ostringstream os;
- os << std::get<DataT>(rhs);
- m_lhs += os.str();
+ m_lhs += std::move(_stringify(std::get<DataT>(rhs)));
}
}
} else {
if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
if constexpr (std::is_convertible_v<DataT, ValueT>) {
m_lhs = std::get<DataT>(rhs);
- } else if constexpr (std::is_same_v<DataT, AggregateDataVariant>) {
- const AggregateDataVariant& v = std::get<AggregateDataVariant>(rhs);
- if constexpr (is_tiny_vector_v<ValueT>) {
- for (size_t i = 0; i < m_lhs.dimension(); ++i) {
- std::visit(
- [&](auto&& vi) {
- using Vi_T = std::decay_t<decltype(vi)>;
- if constexpr (std::is_convertible_v<Vi_T, double>) {
- m_lhs[i] = vi;
- } else {
- // LCOV_EXCL_START
- throw UnexpectedError("unexpected rhs type in affectation");
- // LCOV_EXCL_STOP
- }
- },
- v[i]);
- }
- } else if constexpr (is_tiny_matrix_v<ValueT>) {
- for (size_t i = 0, l = 0; i < m_lhs.numberOfRows(); ++i) {
- for (size_t j = 0; j < m_lhs.numberOfColumns(); ++j, ++l) {
- std::visit(
- [&](auto&& Aij) {
- using Aij_T = std::decay_t<decltype(Aij)>;
- if constexpr (std::is_convertible_v<Aij_T, double>) {
- m_lhs(i, j) = Aij;
- } else {
- // LCOV_EXCL_START
- throw UnexpectedError("unexpected rhs type in affectation");
- // LCOV_EXCL_STOP
- }
- },
- v[l]);
- }
- }
- } else {
- static_assert(is_tiny_matrix_v<ValueT> or is_tiny_vector_v<ValueT>, "invalid rhs type");
- }
} else if constexpr (std::is_same_v<TinyVector<1>, ValueT>) {
std::visit(
[&](auto&& v) {
@@ -186,8 +150,223 @@ class AffectationExecutor final : public IAffectationExecutor
}
},
rhs);
+ } else if constexpr (is_std_vector_v<ValueT> and is_std_vector_v<DataT>) {
+ using ValueContentT = typename ValueT::value_type;
+ using DataContentT = typename DataT::value_type;
+
+ static_assert(not std::is_same_v<ValueContentT, DataContentT>,
+ "the case should have been treated previously");
+ if constexpr (std::is_convertible_v<DataContentT, ValueContentT>) {
+ m_lhs.resize(std::get<DataT>(rhs).size());
+ std::visit(
+ [&](auto&& v) {
+ using Vi_T = std::decay_t<decltype(v)>;
+ if constexpr (is_std_vector_v<Vi_T>) {
+ if constexpr (std::is_arithmetic_v<typename Vi_T::value_type>) {
+ for (size_t i = 0; i < v.size(); ++i) {
+ m_lhs[i] = v[i];
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected rhs type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected rhs type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ },
+ rhs);
+ } else if constexpr (std::is_same_v<ValueContentT, std::string>) {
+ m_lhs.resize(std::get<DataT>(rhs).size());
+
+ std::visit(
+ [&](auto&& v) {
+ using V_T = std::decay_t<decltype(v)>;
+ if constexpr (is_std_vector_v<V_T>) {
+ for (size_t i = 0; i < v.size(); ++i) {
+ if constexpr (std::is_same_v<typename V_T::value_type, bool>) {
+ // Ugly workaround to allow compilation with libstdc++-9
+ bool v_i = v[i];
+ m_lhs[i] = std::move(_stringify(v_i));
+ } else {
+ m_lhs[i] = std::move(_stringify(v[i]));
+ }
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected rhs type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ },
+ rhs);
+ } else if constexpr (is_tiny_vector_v<ValueContentT>) {
+ static_assert(not std::is_same_v<DataContentT, ValueContentT>, "should have been treated before");
+ static_assert(ValueContentT::Dimension == 1,
+ "conversions are only allowed for dimension 1 TinyVector's");
+
+ m_lhs.resize(std::get<DataT>(rhs).size());
+
+ std::visit(
+ [&](auto&& v) {
+ if constexpr (is_std_vector_v<std::decay_t<decltype(v)>>) {
+ using Vi_T = typename std::decay_t<decltype(v)>::value_type;
+ for (size_t i = 0; i < v.size(); ++i) {
+ if constexpr (std::is_arithmetic_v<Vi_T>) {
+ m_lhs[i][0] = v[i];
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected rhs type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected rhs type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ },
+ rhs);
+
+ } else if constexpr (is_tiny_matrix_v<ValueContentT>) {
+ static_assert(not std::is_same_v<DataContentT, ValueContentT>, "should have been treated before");
+ static_assert(ValueContentT::Dimension == 1, "conversions are only allowed for 1x1 TinyMatrix's");
+
+ m_lhs.resize(std::get<DataT>(rhs).size());
+
+ std::visit(
+ [&](auto&& v) {
+ if constexpr (is_std_vector_v<std::decay_t<decltype(v)>>) {
+ using Vi_T = typename std::decay_t<decltype(v)>::value_type;
+ for (size_t i = 0; i < v.size(); ++i) {
+ if constexpr (std::is_arithmetic_v<Vi_T>) {
+ m_lhs[i](0, 0) = v[i];
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected rhs type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected rhs type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ },
+ rhs);
+
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("invalid value type");
+ // LCOV_EXCL_STOP
+ }
+ } else if constexpr (is_std_vector_v<ValueT> and std::is_same_v<DataT, AggregateDataVariant>) {
+ using ValueContentT = typename ValueT::value_type;
+ const AggregateDataVariant& children_values = std::get<AggregateDataVariant>(rhs);
+ m_lhs.resize(children_values.size());
+ auto& tuple_value = m_lhs;
+ for (size_t i = 0; i < children_values.size(); ++i) {
+ std::visit(
+ [&](auto&& child_value) {
+ using T = std::decay_t<decltype(child_value)>;
+ if constexpr (std::is_same_v<T, ValueContentT>) {
+ tuple_value[i] = child_value;
+ } else if constexpr (std::is_arithmetic_v<ValueContentT> and
+ std::is_convertible_v<T, ValueContentT>) {
+ tuple_value[i] = static_cast<ValueContentT>(child_value);
+ } else if constexpr (std::is_same_v<std::string, ValueContentT>) {
+ tuple_value[i] = std::move(_stringify(child_value));
+ } else if constexpr (is_tiny_vector_v<ValueContentT>) {
+ if constexpr (std::is_arithmetic_v<T>) {
+ if constexpr (std::is_same_v<ValueContentT, TinyVector<1>>) {
+ tuple_value[i][0] = child_value;
+ } else {
+ // in this case a 0 is given
+ Assert(child_value == 0);
+ tuple_value[i] = ZeroType{};
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected error: unexpected right hand side type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ } else if constexpr (is_tiny_matrix_v<ValueContentT>) {
+ if constexpr (std::is_arithmetic_v<T>) {
+ if constexpr (std::is_same_v<ValueContentT, TinyMatrix<1>>) {
+ tuple_value[i](0, 0) = child_value;
+ } else {
+ // in this case a 0 is given
+ Assert(child_value == 0);
+ tuple_value[i] = ZeroType{};
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected error: unexpected right hand side type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected error: unexpected right hand side type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ },
+ children_values[i]);
+ }
+ } else if constexpr (is_std_vector_v<ValueT>) {
+ using ValueContentT = typename ValueT::value_type;
+ m_lhs.resize(1);
+ auto& tuple_value = m_lhs;
+ std::visit(
+ [&](auto&& child_value) {
+ using T = std::decay_t<decltype(child_value)>;
+ if constexpr (std::is_same_v<T, ValueContentT>) {
+ tuple_value[0] = child_value;
+ } else if constexpr (std::is_arithmetic_v<ValueContentT> and
+ std::is_convertible_v<T, ValueContentT>) {
+ tuple_value[0] = static_cast<ValueContentT>(child_value);
+ } else if constexpr (std::is_same_v<std::string, ValueContentT>) {
+ tuple_value[0] = std::move(_stringify(child_value));
+ } else if constexpr (is_tiny_vector_v<ValueContentT>) {
+ if constexpr (std::is_arithmetic_v<T>) {
+ if constexpr (std::is_same_v<ValueContentT, TinyVector<1>>) {
+ tuple_value[0][0] = child_value;
+ } else {
+ // in this case a 0 is given
+ Assert(child_value == 0);
+ tuple_value[0] = ZeroType{};
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected error: unexpected right hand side type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ } else if constexpr (is_tiny_matrix_v<ValueContentT>) {
+ if constexpr (std::is_arithmetic_v<T>) {
+ if constexpr (std::is_same_v<ValueContentT, TinyMatrix<1>>) {
+ tuple_value[0](0, 0) = child_value;
+ } else {
+ // in this case a 0 is given
+ Assert(child_value == 0);
+ tuple_value[0] = ZeroType{};
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected error: unexpected right hand side type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected error: unexpected right hand side type in affectation");
+ // LCOV_EXCL_STOP
+ }
+ },
+ rhs);
+
} else {
+ // LCOV_EXCL_START
throw UnexpectedError("invalid value type");
+ // LCOV_EXCL_STOP
}
} else {
AffOp<OperatorT>().eval(m_lhs, std::get<DataT>(rhs));
@@ -264,94 +443,21 @@ class AffectationToDataVariantProcessorBase : public INodeProcessor
virtual ~AffectationToDataVariantProcessorBase() = default;
};
-template <typename OperatorT, typename ValueT>
-class AffectationToTinyVectorFromListProcessor final : public AffectationToDataVariantProcessorBase
-{
- private:
- ASTNode& m_rhs_node;
-
- public:
- DataVariant
- execute(ExecutionPolicy& exec_policy)
- {
- AggregateDataVariant children_values = std::get<AggregateDataVariant>(m_rhs_node.execute(exec_policy));
-
- static_assert(std::is_same_v<OperatorT, language::eq_op>, "forbidden affection operator for list to vectors");
-
- ValueT v;
- for (size_t i = 0; i < v.dimension(); ++i) {
- std::visit(
- [&](auto&& child_value) {
- using T = std::decay_t<decltype(child_value)>;
- if constexpr (std::is_same_v<T, bool> or std::is_same_v<T, uint64_t> or std::is_same_v<T, int64_t> or
- std::is_same_v<T, double>) {
- v[i] = child_value;
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: unexpected right hand side type in affectation", m_rhs_node.begin());
- // LCOV_EXCL_STOP
- }
- },
- children_values[i]);
- }
-
- *m_lhs = v;
- return {};
- }
-
- AffectationToTinyVectorFromListProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
- : AffectationToDataVariantProcessorBase(lhs_node), m_rhs_node{rhs_node}
- {}
-};
-
-template <typename OperatorT, typename ValueT>
-class AffectationToTinyMatrixFromListProcessor final : public AffectationToDataVariantProcessorBase
+template <typename ValueT>
+class AffectationToTupleProcessor final : public AffectationToDataVariantProcessorBase
{
private:
ASTNode& m_rhs_node;
- public:
- DataVariant
- execute(ExecutionPolicy& exec_policy)
+ template <typename T>
+ std::string
+ _stringify(const T& value)
{
- AggregateDataVariant children_values = std::get<AggregateDataVariant>(m_rhs_node.execute(exec_policy));
-
- static_assert(std::is_same_v<OperatorT, language::eq_op>, "forbidden affection operator for list to vectors");
-
- ValueT v;
- for (size_t i = 0, l = 0; i < v.numberOfRows(); ++i) {
- for (size_t j = 0; j < v.numberOfColumns(); ++j, ++l) {
- std::visit(
- [&](auto&& child_value) {
- using T = std::decay_t<decltype(child_value)>;
- if constexpr (std::is_same_v<T, bool> or std::is_same_v<T, uint64_t> or std::is_same_v<T, int64_t> or
- std::is_same_v<T, double>) {
- v(i, j) = child_value;
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: unexpected right hand side type in affectation", m_rhs_node.begin());
- // LCOV_EXCL_STOP
- }
- },
- children_values[l]);
- }
- }
-
- *m_lhs = v;
- return {};
+ std::ostringstream os;
+ os << std::boolalpha << value;
+ return os.str();
}
- AffectationToTinyMatrixFromListProcessor(ASTNode& lhs_node, ASTNode& rhs_node)
- : AffectationToDataVariantProcessorBase(lhs_node), m_rhs_node{rhs_node}
- {}
-};
-
-template <typename ValueT>
-class AffectationToTupleProcessor final : public AffectationToDataVariantProcessorBase
-{
- private:
- ASTNode& m_rhs_node;
-
public:
DataVariant
execute(ExecutionPolicy& exec_policy)
@@ -366,13 +472,7 @@ class AffectationToTupleProcessor final : public AffectationToDataVariantProcess
} else if constexpr (std::is_arithmetic_v<ValueT> and std::is_convertible_v<T, ValueT>) {
*m_lhs = std::vector{std::move(static_cast<ValueT>(v))};
} else if constexpr (std::is_same_v<std::string, ValueT>) {
- if constexpr (std::is_arithmetic_v<T>) {
- *m_lhs = std::vector{std::move(std::to_string(v))};
- } else {
- std::ostringstream os;
- os << v;
- *m_lhs = std::vector<std::string>{os.str()};
- }
+ *m_lhs = std::vector{std::move(_stringify(v))};
} else if constexpr (is_tiny_vector_v<ValueT> or is_tiny_matrix_v<ValueT>) {
if constexpr (std::is_same_v<ValueT, TinyVector<1>> and std::is_arithmetic_v<T>) {
*m_lhs = std::vector<TinyVector<1>>{TinyVector<1>{static_cast<double>(v)}};
@@ -408,6 +508,15 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
private:
ASTNode& m_rhs_node;
+ template <typename T>
+ std::string
+ _stringify(const T& value)
+ {
+ std::ostringstream os;
+ os << std::boolalpha << value;
+ return os.str();
+ }
+
void
_copyAggregateDataVariant(const AggregateDataVariant& children_values)
{
@@ -421,33 +530,9 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
} else if constexpr (std::is_arithmetic_v<ValueT> and std::is_convertible_v<T, ValueT>) {
tuple_value[i] = static_cast<ValueT>(child_value);
} else if constexpr (std::is_same_v<std::string, ValueT>) {
- if constexpr (std::is_arithmetic_v<T>) {
- tuple_value[i] = std::to_string(child_value);
- } else {
- std::ostringstream os;
- os << child_value;
- tuple_value[i] = os.str();
- }
+ tuple_value[i] = std::move(_stringify(child_value));
} else if constexpr (is_tiny_vector_v<ValueT>) {
- if constexpr (std::is_same_v<T, AggregateDataVariant>) {
- ValueT& v = tuple_value[i];
- Assert(ValueT::Dimension == child_value.size());
- for (size_t j = 0; j < ValueT::Dimension; ++j) {
- std::visit(
- [&](auto&& vj) {
- using Ti = std::decay_t<decltype(vj)>;
- if constexpr (std::is_convertible_v<Ti, typename ValueT::data_type>) {
- v[j] = vj;
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: unexpected right hand side type in affectation",
- m_rhs_node.children[i]->begin());
- // LCOV_EXCL_STOP
- }
- },
- child_value[j]);
- }
- } else if constexpr (std::is_arithmetic_v<T>) {
+ if constexpr (std::is_arithmetic_v<T>) {
if constexpr (std::is_same_v<ValueT, TinyVector<1>>) {
tuple_value[i][0] = child_value;
} else {
@@ -462,27 +547,7 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
// LCOV_EXCL_STOP
}
} else if constexpr (is_tiny_matrix_v<ValueT>) {
- if constexpr (std::is_same_v<T, AggregateDataVariant>) {
- ValueT& A = tuple_value[i];
- Assert(A.numberOfRows() * A.numberOfColumns() == child_value.size());
- for (size_t j = 0, l = 0; j < A.numberOfRows(); ++j) {
- for (size_t k = 0; k < A.numberOfColumns(); ++k, ++l) {
- std::visit(
- [&](auto&& Ajk) {
- using Ti = std::decay_t<decltype(Ajk)>;
- if constexpr (std::is_convertible_v<Ti, typename ValueT::data_type>) {
- A(j, k) = Ajk;
- } else {
- // LCOV_EXCL_START
- throw ParseError("unexpected error: unexpected right hand side type in affectation",
- m_rhs_node.children[i]->begin());
- // LCOV_EXCL_STOP
- }
- },
- child_value[l]);
- }
- }
- } else if constexpr (std::is_arithmetic_v<T>) {
+ if constexpr (std::is_arithmetic_v<T>) {
if constexpr (std::is_same_v<ValueT, TinyMatrix<1>>) {
tuple_value[i](0, 0) = child_value;
} else {
@@ -522,16 +587,8 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
v[i] = static_cast<DataType>(values[i]);
}
} else if constexpr (std::is_same_v<ValueT, std::string>) {
- if constexpr (std::is_arithmetic_v<DataType>) {
- for (size_t i = 0; i < values.size(); ++i) {
- v[i] = std::to_string(values[i]);
- }
- } else {
- for (size_t i = 0; i < values.size(); ++i) {
- std::ostringstream sout;
- sout << values[i];
- v[i] = sout.str();
- }
+ for (size_t i = 0; i < values.size(); ++i) {
+ v[i] = std::move(_stringify(values[i]));
}
} else {
// LCOV_EXCL_START
diff --git a/src/language/node_processor/FunctionProcessor.hpp b/src/language/node_processor/FunctionProcessor.hpp
index 16e65e6e1e1ca63a7e1fa57e109856b3da25610a..9dd9203275ef91c08742f9f58769e9023e24b852 100644
--- a/src/language/node_processor/FunctionProcessor.hpp
+++ b/src/language/node_processor/FunctionProcessor.hpp
@@ -20,38 +20,6 @@ class FunctionExpressionProcessor final : public INodeProcessor
{
if constexpr (std::is_same_v<ReturnType, ExpressionValueType>) {
return m_function_expression.execute(exec_policy);
- } else if constexpr (std::is_same_v<AggregateDataVariant, ExpressionValueType>) {
- static_assert(is_tiny_vector_v<ReturnType> or is_tiny_matrix_v<ReturnType>, "unexpected return type");
- ReturnType return_value{};
- auto value = std::get<ExpressionValueType>(m_function_expression.execute(exec_policy));
- if constexpr (is_tiny_vector_v<ReturnType>) {
- for (size_t i = 0; i < ReturnType::Dimension; ++i) {
- std::visit(
- [&](auto&& vi) {
- using Vi_T = std::decay_t<decltype(vi)>;
- if constexpr (std::is_convertible_v<Vi_T, double>) {
- return_value[i] = vi;
- }
- },
- value[i]);
- }
- } else {
- static_assert(is_tiny_matrix_v<ReturnType>);
-
- for (size_t i = 0, l = 0; i < return_value.numberOfRows(); ++i) {
- for (size_t j = 0; j < return_value.numberOfColumns(); ++j, ++l) {
- std::visit(
- [&](auto&& Aij) {
- using Vi_T = std::decay_t<decltype(Aij)>;
- if constexpr (std::is_convertible_v<Vi_T, double>) {
- return_value(i, j) = Aij;
- }
- },
- value[l]);
- }
- }
- }
- return return_value;
} else if constexpr (std::is_same_v<ReturnType, std::string>) {
return std::to_string(std::get<ExpressionValueType>(m_function_expression.execute(exec_policy)));
} else if constexpr (std::is_same_v<ExpressionValueType, ZeroType>) {
@@ -63,7 +31,9 @@ class FunctionExpressionProcessor final : public INodeProcessor
static_assert(ReturnType::Dimension == 1, "invalid conversion");
return ReturnType(std::get<ExpressionValueType>(m_function_expression.execute(exec_policy)));
} else {
+ // LCOV_EXCL_START
throw UnexpectedError("invalid conversion");
+ // LCOV_EXCL_STOP
}
}
diff --git a/src/language/node_processor/InnerListToVectorProcessor.hpp b/src/language/node_processor/InnerListToVectorProcessor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ef74daaabe5c0e2f475b1693b7bb9627ed600f40
--- /dev/null
+++ b/src/language/node_processor/InnerListToVectorProcessor.hpp
@@ -0,0 +1,30 @@
+#ifndef INNER_LIST_TO_VECTOR_PROCESSOR_HPP
+#define INNER_LIST_TO_VECTOR_PROCESSOR_HPP
+
+#include <language/ast/ASTNode.hpp>
+#include <language/node_processor/ASTNodeExpressionListProcessor.hpp>
+#include <language/node_processor/INodeProcessor.hpp>
+
+class InnerListToVectorProcessor final : public INodeProcessor
+{
+ private:
+ std::unique_ptr<ASTNodeExpressionListProcessor> m_expression_list_processor;
+
+ public:
+ DataVariant
+ execute(ExecutionPolicy& exec_policy)
+ {
+ AggregateDataVariant v = std::get<AggregateDataVariant>(m_expression_list_processor->execute(exec_policy));
+
+ v.setIsFlattenable(false);
+ return v;
+ }
+
+ InnerListToVectorProcessor(ASTNode& node)
+ : m_expression_list_processor{std::make_unique<ASTNodeExpressionListProcessor>(node)}
+ {}
+
+ ~InnerListToVectorProcessor() = default;
+};
+
+#endif // INNER_LIST_TO_VECTOR_PROCESSOR_HPP
diff --git a/src/language/node_processor/TinyMatrixExpressionProcessor.hpp b/src/language/node_processor/TinyMatrixExpressionProcessor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bcb3e65f35b301c6adbe12eeb02e6024cb9ea0da
--- /dev/null
+++ b/src/language/node_processor/TinyMatrixExpressionProcessor.hpp
@@ -0,0 +1,46 @@
+#ifndef TINY_MATRIX_EXPRESSION_PROCESSOR_HPP
+#define TINY_MATRIX_EXPRESSION_PROCESSOR_HPP
+
+#include <algebra/TinyMatrix.hpp>
+#include <language/PEGGrammar.hpp>
+#include <language/ast/ASTNode.hpp>
+#include <language/node_processor/INodeProcessor.hpp>
+
+template <size_t M, size_t N>
+class TinyMatrixExpressionProcessor final : public INodeProcessor
+{
+ private:
+ ASTNode& m_node;
+
+ public:
+ PUGS_INLINE
+ DataVariant
+ execute(ExecutionPolicy& exec_policy)
+ {
+ TinyMatrix<M, N> A{};
+ Assert(m_node.children.size() == M);
+
+ for (size_t i = 0; i < M; ++i) {
+ for (size_t j = 0; j < N; ++j) {
+ std::visit(
+ [&](auto&& x) {
+ using ValueT = std::decay_t<decltype(x)>;
+ if constexpr (std::is_arithmetic_v<ValueT>) {
+ A(i, j) = x;
+ } else {
+ // LCOV_EXCL_START
+ Assert(false, "unexpected value type");
+ // LCOV_EXCL_STOP
+ }
+ },
+ m_node.children[i]->children[j]->execute(exec_policy));
+ }
+ }
+
+ return A;
+ }
+
+ TinyMatrixExpressionProcessor(ASTNode& node) : m_node{node} {}
+};
+
+#endif // TINY_MATRIX_EXPRESSION_PROCESSOR_HPP
diff --git a/src/language/node_processor/TinyVectorExpressionProcessor.hpp b/src/language/node_processor/TinyVectorExpressionProcessor.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ac86b9025b54f673c3cad636aaf1178a55e436a1
--- /dev/null
+++ b/src/language/node_processor/TinyVectorExpressionProcessor.hpp
@@ -0,0 +1,44 @@
+#ifndef TINY_VECTOR_EXPRESSION_PROCESSOR_HPP
+#define TINY_VECTOR_EXPRESSION_PROCESSOR_HPP
+
+#include <algebra/TinyVector.hpp>
+#include <language/PEGGrammar.hpp>
+#include <language/ast/ASTNode.hpp>
+#include <language/node_processor/INodeProcessor.hpp>
+
+template <size_t Dimension>
+class TinyVectorExpressionProcessor final : public INodeProcessor
+{
+ private:
+ ASTNode& m_node;
+
+ public:
+ PUGS_INLINE
+ DataVariant
+ execute(ExecutionPolicy& exec_policy)
+ {
+ TinyVector<Dimension> v{};
+ Assert(m_node.children.size() == Dimension);
+
+ for (size_t i = 0; i < Dimension; ++i) {
+ std::visit(
+ [&](auto&& x) {
+ using ValueT = std::decay_t<decltype(x)>;
+ if constexpr (std::is_arithmetic_v<ValueT>) {
+ v[i] = x;
+ } else {
+ // LCOV_EXCL_START
+ Assert(false, "unexpected value type");
+ // LCOV_EXCL_STOP
+ }
+ },
+ m_node.children[i]->execute(exec_policy));
+ }
+
+ return v;
+ }
+
+ TinyVectorExpressionProcessor(ASTNode& node) : m_node{node} {}
+};
+
+#endif // TINY_VECTOR_EXPRESSION_PROCESSOR_HPP
diff --git a/src/language/node_processor/TupleToTinyMatrixProcessor.hpp b/src/language/node_processor/TupleToTinyMatrixProcessor.hpp
deleted file mode 100644
index 77bc45e8419f7d2e58447247aef3975c337813c5..0000000000000000000000000000000000000000
--- a/src/language/node_processor/TupleToTinyMatrixProcessor.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#ifndef TUPLE_TO_TINY_MATRIX_PROCESSOR_HPP
-#define TUPLE_TO_TINY_MATRIX_PROCESSOR_HPP
-
-#include <language/ast/ASTNode.hpp>
-#include <language/node_processor/INodeProcessor.hpp>
-
-template <typename TupleProcessorT, size_t N>
-class TupleToTinyMatrixProcessor final : public INodeProcessor
-{
- private:
- ASTNode& m_node;
-
- std::unique_ptr<TupleProcessorT> m_tuple_processor;
-
- public:
- DataVariant
- execute(ExecutionPolicy& exec_policy)
- {
- AggregateDataVariant v = std::get<AggregateDataVariant>(m_tuple_processor->execute(exec_policy));
-
- Assert(v.size() == N * N);
-
- TinyMatrix<N> A;
-
- for (size_t i = 0, l = 0; i < N; ++i) {
- for (size_t j = 0; j < N; ++j, ++l) {
- std::visit(
- [&](auto&& Aij) {
- using ValueT = std::decay_t<decltype(Aij)>;
- if constexpr (std::is_arithmetic_v<ValueT>) {
- A(i, j) = Aij;
- } else {
- // LCOV_EXCL_START
- Assert(false, "unexpected value type");
- // LCOV_EXCL_STOP
- }
- },
- v[l]);
- }
- }
-
- return DataVariant{std::move(A)};
- }
-
- TupleToTinyMatrixProcessor(ASTNode& node) : m_node{node}, m_tuple_processor{std::make_unique<TupleProcessorT>(node)}
- {}
-
- TupleToTinyMatrixProcessor(ASTNode& node, std::unique_ptr<TupleProcessorT>&& tuple_processor)
- : m_node{node}, m_tuple_processor{std::move(tuple_processor)}
- {}
-};
-
-#endif // TUPLE_TO_TINY_MATRIX_PROCESSOR_HPP
diff --git a/src/language/node_processor/TupleToTinyVectorProcessor.hpp b/src/language/node_processor/TupleToTinyVectorProcessor.hpp
deleted file mode 100644
index da4f1e08dc0351e43df185e13415669f1ef26b44..0000000000000000000000000000000000000000
--- a/src/language/node_processor/TupleToTinyVectorProcessor.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef TUPLE_TO_TINY_VECTOR_PROCESSOR_HPP
-#define TUPLE_TO_TINY_VECTOR_PROCESSOR_HPP
-
-#include <language/ast/ASTNode.hpp>
-#include <language/node_processor/INodeProcessor.hpp>
-
-template <typename TupleProcessorT, size_t N>
-class TupleToTinyVectorProcessor final : public INodeProcessor
-{
- private:
- ASTNode& m_node;
-
- std::unique_ptr<TupleProcessorT> m_tuple_processor;
-
- public:
- DataVariant
- execute(ExecutionPolicy& exec_policy)
- {
- AggregateDataVariant v = std::get<AggregateDataVariant>(m_tuple_processor->execute(exec_policy));
-
- Assert(v.size() == N);
-
- TinyVector<N> x;
-
- for (size_t i = 0; i < N; ++i) {
- std::visit(
- [&](auto&& v) {
- using ValueT = std::decay_t<decltype(v)>;
- if constexpr (std::is_arithmetic_v<ValueT>) {
- x[i] = v;
- } else {
- // LCOV_EXCL_START
- Assert(false, "unexpected value type");
- // LCOV_EXCL_STOP
- }
- },
- v[i]);
- }
-
- return DataVariant{std::move(x)};
- }
-
- TupleToTinyVectorProcessor(ASTNode& node) : m_node{node}, m_tuple_processor{std::make_unique<TupleProcessorT>(node)}
- {}
-
- TupleToTinyVectorProcessor(ASTNode& node, std::unique_ptr<TupleProcessorT>&& tuple_processor)
- : m_node{node}, m_tuple_processor{std::move(tuple_processor)}
- {}
-};
-
-#endif // TUPLE_TO_TINY_VECTOR_PROCESSOR_HPP
diff --git a/src/language/node_processor/TupleToVectorProcessor.hpp b/src/language/node_processor/TupleToVectorProcessor.hpp
deleted file mode 100644
index 74ad59acb95e0e853a880fb171e93d77c55dcd74..0000000000000000000000000000000000000000
--- a/src/language/node_processor/TupleToVectorProcessor.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef TUPLE_TO_VECTOR_PROCESSOR_HPP
-#define TUPLE_TO_VECTOR_PROCESSOR_HPP
-
-#include <language/ast/ASTNode.hpp>
-#include <language/node_processor/INodeProcessor.hpp>
-
-template <typename TupleProcessorT>
-class TupleToVectorProcessor final : public INodeProcessor
-{
- private:
- ASTNode& m_node;
-
- std::unique_ptr<TupleProcessorT> m_tuple_processor;
-
- public:
- DataVariant
- execute(ExecutionPolicy& exec_policy)
- {
- AggregateDataVariant v = std::get<AggregateDataVariant>(m_tuple_processor->execute(exec_policy));
-
- v.setIsFlattenable(false);
- return v;
- }
-
- TupleToVectorProcessor(ASTNode& node) : m_node{node}, m_tuple_processor{std::make_unique<TupleProcessorT>(node)} {}
-
- TupleToVectorProcessor(ASTNode& node, std::unique_ptr<TupleProcessorT>&& tuple_processor)
- : m_node{node}, m_tuple_processor{std::move(tuple_processor)}
- {}
-};
-
-#endif // TUPLE_TO_TINY_VECTOR_PROCESSOR_HPP
diff --git a/src/language/utils/ASTNodeDataType.cpp b/src/language/utils/ASTNodeDataType.cpp
index ddea3a6dd9a6a79fda474bb93e05645d55dd7503..3c6d4af0f8be9f4002834fb15548316f301b0159 100644
--- a/src/language/utils/ASTNodeDataType.cpp
+++ b/src/language/utils/ASTNodeDataType.cpp
@@ -2,7 +2,9 @@
#include <language/PEGGrammar.hpp>
#include <language/ast/ASTNode.hpp>
+#include <language/utils/ASTNodeNaturalConversionChecker.hpp>
#include <language/utils/ParseError.hpp>
+#include <language/utils/SymbolTable.hpp>
#include <utils/PugsAssert.hpp>
ASTNodeDataType
@@ -19,6 +21,28 @@ getVectorDataType(const ASTNode& type_node)
if (not(dimension > 0 and dimension <= 3)) {
throw ParseError("invalid dimension (must be 1, 2 or 3)", dimension_node.begin());
}
+
+ return ASTNodeDataType::build<ASTNodeDataType::vector_t>(dimension);
+}
+
+ASTNodeDataType
+getVectorExpressionType(const ASTNode& vector_expression_node)
+{
+ if (not(vector_expression_node.is_type<language::vector_expression>() and
+ (vector_expression_node.children.size() > 0))) {
+ throw ParseError("unexpected node type", vector_expression_node.begin());
+ }
+
+ const size_t dimension = vector_expression_node.children.size();
+ if (not(dimension > 0 and dimension <= 3)) {
+ throw ParseError("invalid dimension (must be 1, 2 or 3)", vector_expression_node.begin());
+ }
+
+ for (size_t i = 0; i < dimension; ++i) {
+ ASTNodeNaturalConversionChecker(*vector_expression_node.children[i],
+ ASTNodeDataType::build<ASTNodeDataType::double_t>());
+ }
+
return ASTNodeDataType::build<ASTNodeDataType::vector_t>(dimension);
}
@@ -52,6 +76,89 @@ getMatrixDataType(const ASTNode& type_node)
return ASTNodeDataType::build<ASTNodeDataType::matrix_t>(dimension0, dimension1);
}
+ASTNodeDataType
+getMatrixExpressionType(const ASTNode& matrix_expression_node)
+{
+ if (not(matrix_expression_node.is_type<language::matrix_expression>() and
+ matrix_expression_node.children.size() > 0)) {
+ throw ParseError("unexpected node type", matrix_expression_node.begin());
+ }
+
+ const size_t dimension0 = matrix_expression_node.children.size();
+ if (not(dimension0 > 0 and dimension0 <= 3)) {
+ throw ParseError("invalid dimension (must be 1, 2 or 3)", matrix_expression_node.begin());
+ }
+ for (size_t i = 0; i < dimension0; ++i) {
+ if (not matrix_expression_node.children[i]->is_type<language::row_expression>()) {
+ throw ParseError("expecting row expression", matrix_expression_node.children[i]->begin());
+ }
+ }
+
+ const size_t dimension1 = matrix_expression_node.children[0]->children.size();
+ if (dimension0 != dimension1) {
+ throw ParseError("only square matrices are supported", matrix_expression_node.begin());
+ }
+
+ for (size_t i = 1; i < dimension0; ++i) {
+ if (matrix_expression_node.children[i]->children.size() != dimension1) {
+ throw ParseError("row must have same sizes", matrix_expression_node.begin());
+ }
+ }
+
+ for (size_t i = 0; i < dimension0; ++i) {
+ for (size_t j = 0; j < dimension1; ++j) {
+ ASTNodeNaturalConversionChecker(*matrix_expression_node.children[i]->children[j],
+ ASTNodeDataType::build<ASTNodeDataType::double_t>());
+ }
+ }
+
+ return ASTNodeDataType::build<ASTNodeDataType::matrix_t>(dimension0, dimension1);
+}
+
+ASTNodeDataType
+getTupleDataType(const ASTNode& type_node)
+{
+ const auto& content_node = type_node.children[0];
+
+ if (content_node->is_type<language::type_name_id>()) {
+ const std::string& type_name_id = content_node->string();
+
+ auto& symbol_table = *type_node.m_symbol_table;
+
+ const auto [i_type_symbol, found] = symbol_table.find(type_name_id, content_node->begin());
+ if (not found) {
+ throw ParseError("undefined type identifier", std::vector{content_node->begin()});
+ } else if (i_type_symbol->attributes().dataType() != ASTNodeDataType::type_name_id_t) {
+ std::ostringstream os;
+ os << "invalid type identifier, '" << type_name_id << "' was previously defined as a '"
+ << dataTypeName(i_type_symbol->attributes().dataType()) << '\'';
+ throw ParseError(os.str(), std::vector{content_node->begin()});
+ }
+
+ content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::type_id_t>(type_name_id);
+ } else if (content_node->is_type<language::B_set>()) {
+ content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ } else if (content_node->is_type<language::Z_set>()) {
+ content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ } else if (content_node->is_type<language::N_set>()) {
+ content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ } else if (content_node->is_type<language::R_set>()) {
+ content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+ } else if (content_node->is_type<language::vector_type>()) {
+ content_node->m_data_type = getVectorDataType(*type_node.children[0]);
+ } else if (content_node->is_type<language::matrix_type>()) {
+ content_node->m_data_type = getMatrixDataType(*type_node.children[0]);
+ } else if (content_node->is_type<language::string_type>()) {
+ content_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::string_t>();
+ } else {
+ // LCOV_EXCL_START
+ throw UnexpectedError("unexpected content type in tuple");
+ // LCOV_EXCL_STOP
+ }
+
+ return ASTNodeDataType::build<ASTNodeDataType::tuple_t>(content_node->m_data_type);
+}
+
std::string
dataTypeName(const ASTNodeDataType& data_type)
{
diff --git a/src/language/utils/ASTNodeDataType.hpp b/src/language/utils/ASTNodeDataType.hpp
index ea744757cf68b5055605111d35acc14564b06b30..b7cc48fefaa6d849cf970641b37279a5a85ca15e 100644
--- a/src/language/utils/ASTNodeDataType.hpp
+++ b/src/language/utils/ASTNodeDataType.hpp
@@ -13,8 +13,12 @@ class ASTNode;
class ASTNodeDataType;
ASTNodeDataType getVectorDataType(const ASTNode& type_node);
+ASTNodeDataType getVectorExpressionType(const ASTNode& vector_expression_node);
ASTNodeDataType getMatrixDataType(const ASTNode& type_node);
+ASTNodeDataType getMatrixExpressionType(const ASTNode& matrix_expression_node);
+
+ASTNodeDataType getTupleDataType(const ASTNode& type_node);
std::string dataTypeName(const std::vector<ASTNodeDataType>& data_type_vector);
diff --git a/src/language/utils/ASTNodeNaturalConversionChecker.cpp b/src/language/utils/ASTNodeNaturalConversionChecker.cpp
index a05c5aa1b4fcc79d531ea51544fb47dc1b40698e..b3ad34eeabdcaa942590fa34a7b1940f7a552834 100644
--- a/src/language/utils/ASTNodeNaturalConversionChecker.cpp
+++ b/src/language/utils/ASTNodeNaturalConversionChecker.cpp
@@ -48,23 +48,9 @@ ASTNodeNaturalConversionChecker<RToR1Conversion>::_checkIsNaturalExpressionConve
} else if (target_data_type == ASTNodeDataType::vector_t) {
switch (data_type) {
case ASTNodeDataType::list_t: {
- const auto& content_type_list = data_type.contentTypeList();
- if (content_type_list.size() != target_data_type.dimension()) {
- std::ostringstream os;
- os << "incompatible dimensions in affectation: expecting " << target_data_type.dimension() << ", but provided "
- << content_type_list.size();
- throw ParseError(os.str(), std::vector{node.begin()});
- }
-
- Assert(content_type_list.size() == node.children.size());
- for (size_t i = 0; i < content_type_list.size(); ++i) {
- const auto& child_type = *content_type_list[i];
- const auto& child_node = *node.children[i];
- Assert(child_type == child_node.m_data_type);
- this->_checkIsNaturalExpressionConversion(child_node, child_type,
- ASTNodeDataType::build<ASTNodeDataType::double_t>());
- }
-
+ std::ostringstream os;
+ os << "cannot convert list to " << dataTypeName(target_data_type);
+ throw ParseError(os.str(), std::vector{node.begin()});
break;
}
case ASTNodeDataType::vector_t: {
@@ -92,24 +78,9 @@ ASTNodeNaturalConversionChecker<RToR1Conversion>::_checkIsNaturalExpressionConve
} else if (target_data_type == ASTNodeDataType::matrix_t) {
switch (data_type) {
case ASTNodeDataType::list_t: {
- const auto& content_type_list = data_type.contentTypeList();
- if (content_type_list.size() != (target_data_type.numberOfRows() * target_data_type.numberOfColumns())) {
- std::ostringstream os;
- os << "incompatible dimensions in affectation: expecting "
- << target_data_type.numberOfRows() * target_data_type.numberOfColumns() << ", but provided "
- << content_type_list.size();
- throw ParseError(os.str(), std::vector{node.begin()});
- }
-
- Assert(content_type_list.size() == node.children.size());
- for (size_t i = 0; i < content_type_list.size(); ++i) {
- const auto& child_type = *content_type_list[i];
- const auto& child_node = *node.children[i];
- Assert(child_type == child_node.m_data_type);
- this->_checkIsNaturalExpressionConversion(child_node, child_type,
- ASTNodeDataType::build<ASTNodeDataType::double_t>());
- }
-
+ std::ostringstream os;
+ os << "cannot convert list to " << dataTypeName(target_data_type);
+ throw ParseError(os.str(), std::vector{node.begin()});
break;
}
case ASTNodeDataType::matrix_t: {
@@ -137,7 +108,7 @@ ASTNodeNaturalConversionChecker<RToR1Conversion>::_checkIsNaturalExpressionConve
}
} else if (target_data_type == ASTNodeDataType::tuple_t) {
const ASTNodeDataType& target_content_type = target_data_type.contentType();
- if (node.m_data_type == ASTNodeDataType::tuple_t) {
+ if ((data_type == ASTNodeDataType::tuple_t) or (node.m_data_type == ASTNodeDataType::tuple_t)) {
this->_checkIsNaturalExpressionConversion(node, data_type.contentType(), target_content_type);
} else if (node.m_data_type == ASTNodeDataType::list_t) {
for (const auto& child : node.children) {
diff --git a/src/language/utils/AffectationProcessorBuilder.hpp b/src/language/utils/AffectationProcessorBuilder.hpp
index 0e4b7ace65654b650989e817dbe2e4a545ae320f..ed1995106225f6c04ce583a4e8ef257fca54b038 100644
--- a/src/language/utils/AffectationProcessorBuilder.hpp
+++ b/src/language/utils/AffectationProcessorBuilder.hpp
@@ -56,30 +56,6 @@ class AffectationToTupleFromListProcessorBuilder final : public IAffectationProc
}
};
-template <typename OperatorT, typename ValueT>
-class AffectationToTinyVectorFromListProcessorBuilder final : public IAffectationProcessorBuilder
-{
- public:
- AffectationToTinyVectorFromListProcessorBuilder() = default;
- std::unique_ptr<INodeProcessor>
- getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
- {
- return std::make_unique<AffectationToTinyVectorFromListProcessor<OperatorT, ValueT>>(lhs_node, rhs_node);
- }
-};
-
-template <typename OperatorT, typename ValueT>
-class AffectationToTinyMatrixFromListProcessorBuilder final : public IAffectationProcessorBuilder
-{
- public:
- AffectationToTinyMatrixFromListProcessorBuilder() = default;
- std::unique_ptr<INodeProcessor>
- getNodeProcessor(ASTNode& lhs_node, ASTNode& rhs_node) const final
- {
- return std::make_unique<AffectationToTinyMatrixFromListProcessor<OperatorT, ValueT>>(lhs_node, rhs_node);
- }
-};
-
template <typename OperatorT, typename ValueT>
class AffectationFromZeroProcessorBuilder final : public IAffectationProcessorBuilder
{
diff --git a/src/language/utils/AffectationRegisterForRn.cpp b/src/language/utils/AffectationRegisterForRn.cpp
index 7d38dc64c1d245d4d6c530e891ffd6eaecd63372..180bd5ebce8d19dd8aa6f4b628a700632ea44ab0 100644
--- a/src/language/utils/AffectationRegisterForRn.cpp
+++ b/src/language/utils/AffectationRegisterForRn.cpp
@@ -16,12 +16,6 @@ AffectationRegisterForRn<Dimension>::_register_eq_op()
language::eq_op>(Rn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationFromZeroProcessorBuilder<language::eq_op, TinyVector<Dimension>>>());
- repository.addAffectation<language::eq_op>(Rn,
- ASTNodeDataType::build<ASTNodeDataType::list_t>(
- std::vector<std::shared_ptr<const ASTNodeDataType>>{}),
- std::make_shared<AffectationToTinyVectorFromListProcessorBuilder<
- language::eq_op, TinyVector<Dimension>>>());
-
repository
.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rn),
ASTNodeDataType::build<ASTNodeDataType::int_t>(),
diff --git a/src/language/utils/AffectationRegisterForRnxn.cpp b/src/language/utils/AffectationRegisterForRnxn.cpp
index efa95d92bbcfd32af37f6c3f69477d7ee985a560..0eaf1c6af2e0caccf0fa143208c774a047d6e550 100644
--- a/src/language/utils/AffectationRegisterForRnxn.cpp
+++ b/src/language/utils/AffectationRegisterForRnxn.cpp
@@ -16,12 +16,6 @@ AffectationRegisterForRnxn<Dimension>::_register_eq_op()
language::eq_op>(Rnxn, ASTNodeDataType::build<ASTNodeDataType::int_t>(),
std::make_shared<AffectationFromZeroProcessorBuilder<language::eq_op, TinyMatrix<Dimension>>>());
- repository.addAffectation<language::eq_op>(Rnxn,
- ASTNodeDataType::build<ASTNodeDataType::list_t>(
- std::vector<std::shared_ptr<const ASTNodeDataType>>{}),
- std::make_shared<AffectationToTinyMatrixFromListProcessorBuilder<
- language::eq_op, TinyMatrix<Dimension>>>());
-
repository
.addAffectation<language::eq_op>(ASTNodeDataType::build<ASTNodeDataType::tuple_t>(Rnxn),
ASTNodeDataType::build<ASTNodeDataType::int_t>(),
diff --git a/src/language/utils/BuiltinFunctionEmbedderUtils.cpp b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
index ba6658ff7b5dc901182c62f7a07c0018ed94bd5a..be3474ef7ae4e657d7553715c8414180ddc15d52 100644
--- a/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
+++ b/src/language/utils/BuiltinFunctionEmbedderUtils.cpp
@@ -82,24 +82,7 @@ getBuiltinFunctionEmbedder(ASTNode& n)
}
bool is_castable = true;
if (target_type.dimension() > 1) {
- switch (arg_type) {
- case ASTNodeDataType::int_t: {
- break;
- }
- case ASTNodeDataType::list_t: {
- if (arg_type.contentTypeList().size() != target_type.dimension()) {
- is_castable = false;
- break;
- }
- for (auto list_arg : arg_type.contentTypeList()) {
- is_castable &= isNaturalConversion(*list_arg, ASTNodeDataType::build<ASTNodeDataType::double_t>());
- }
- break;
- }
- default: {
- is_castable &= false;
- }
- }
+ return (arg_type == ASTNodeDataType::int_t);
} else {
is_castable &= isNaturalConversion(arg_type, ASTNodeDataType::build<ASTNodeDataType::double_t>());
}
@@ -113,24 +96,7 @@ getBuiltinFunctionEmbedder(ASTNode& n)
bool is_castable = true;
if (target_type.numberOfRows() > 1) {
- switch (arg_type) {
- case ASTNodeDataType::int_t: {
- break;
- }
- case ASTNodeDataType::list_t: {
- if (arg_type.contentTypeList().size() != target_type.numberOfRows() * target_type.numberOfColumns()) {
- is_castable = false;
- break;
- }
- for (auto list_arg : arg_type.contentTypeList()) {
- is_castable &= isNaturalConversion(*list_arg, ASTNodeDataType::build<ASTNodeDataType::double_t>());
- }
- break;
- }
- default: {
- is_castable &= false;
- }
- }
+ return (arg_type == ASTNodeDataType::int_t);
} else {
is_castable &= isNaturalConversion(arg_type, ASTNodeDataType::build<ASTNodeDataType::double_t>());
}
diff --git a/src/language/utils/PugsFunctionAdapter.hpp b/src/language/utils/PugsFunctionAdapter.hpp
index d39e0f4233df70709d3d765146447727f7541ae4..de5e884bf63bc0ac3726864c4c4571c0a0fb9f55 100644
--- a/src/language/utils/PugsFunctionAdapter.hpp
+++ b/src/language/utils/PugsFunctionAdapter.hpp
@@ -154,28 +154,6 @@ class PugsFunctionAdapter<OutputType(InputType...)>
{
if constexpr (is_tiny_vector_v<OutputType>) {
switch (data_type) {
- case ASTNodeDataType::list_t: {
- return [](DataVariant&& result) -> OutputType {
- AggregateDataVariant& v = std::get<AggregateDataVariant>(result);
- OutputType x;
-
- for (size_t i = 0; i < x.dimension(); ++i) {
- std::visit(
- [&](auto&& vi) {
- using Vi_T = std::decay_t<decltype(vi)>;
- if constexpr (std::is_arithmetic_v<Vi_T>) {
- x[i] = vi;
- } else {
- // LCOV_EXCL_START
- throw UnexpectedError("expecting arithmetic value");
- // LCOV_EXCL_STOP
- }
- },
- v[i]);
- }
- return x;
- };
- }
case ASTNodeDataType::vector_t: {
return [](DataVariant&& result) -> OutputType { return std::get<OutputType>(result); };
}
@@ -231,30 +209,6 @@ class PugsFunctionAdapter<OutputType(InputType...)>
}
} else if constexpr (is_tiny_matrix_v<OutputType>) {
switch (data_type) {
- case ASTNodeDataType::list_t: {
- return [](DataVariant&& result) -> OutputType {
- AggregateDataVariant& v = std::get<AggregateDataVariant>(result);
- OutputType x;
-
- for (size_t i = 0, l = 0; i < x.numberOfRows(); ++i) {
- for (size_t j = 0; j < x.numberOfColumns(); ++j, ++l) {
- std::visit(
- [&](auto&& Aij) {
- using Aij_T = std::decay_t<decltype(Aij)>;
- if constexpr (std::is_arithmetic_v<Aij_T>) {
- x(i, j) = Aij;
- } else {
- // LCOV_EXCL_START
- throw UnexpectedError("expecting arithmetic value");
- // LCOV_EXCL_STOP
- }
- },
- v[l]);
- }
- }
- return x;
- };
- }
case ASTNodeDataType::matrix_t: {
return [](DataVariant&& result) -> OutputType { return std::get<OutputType>(result); };
}
diff --git a/tests/test_ASTBuilder.cpp b/tests/test_ASTBuilder.cpp
index 262a0cd30b60cee5da070fe6fa8d62d8981e7b1d..2a9bcf4e41c039ac87dd6d3535a47710fb1a86e7 100644
--- a/tests/test_ASTBuilder.cpp
+++ b/tests/test_ASTBuilder.cpp
@@ -636,10 +636,10 @@ let y:(R^2), y=((0));
| | `-(language::integer:2)
| +-(language::name:x)
| `-(language::expression_list)
- | +-(language::tuple_expression)
+ | +-(language::inner_expression_list)
| | +-(language::integer:0)
| | `-(language::integer:0)
- | `-(language::tuple_expression)
+ | `-(language::inner_expression_list)
| +-(language::integer:2)
| `-(language::integer:3)
`-(language::var_declaration)
diff --git a/tests/test_ASTNodeAffectationExpressionBuilder.cpp b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
index 81ff4f95cffb91fe3352ff5560043d75a309e700..edd68ca67131579b980faa728959f854dea2dcf4 100644
--- a/tests/test_ASTNodeAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeAffectationExpressionBuilder.cpp
@@ -486,17 +486,17 @@ let y : R^2, y = x;
CHECK_AST(data, result);
}
- SECTION("R^2 <- (.,.)")
+ SECTION("R^2 <- value")
{
std::string_view data = R"(
-let y : R^2, y = (0,1);
+let y : R^2, y = [0,1];
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ `-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
+-(language::name:y:NameProcessor)
- `-(language::expression_list:ASTNodeExpressionListProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+-(language::integer:0:ValueProcessor)
`-(language::integer:1:ValueProcessor)
)";
@@ -553,17 +553,17 @@ let x : R^3, x = 0;
CHECK_AST(data, result);
}
- SECTION("R^3 <- (.,.)")
+ SECTION("R^3 <- value")
{
std::string_view data = R"(
-let y : R^3, y = (1,2,3);
+let y : R^3, y = [1,2,3];
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ `-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
+-(language::name:y:NameProcessor)
- `-(language::expression_list:ASTNodeExpressionListProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+-(language::integer:1:ValueProcessor)
+-(language::integer:2:ValueProcessor)
`-(language::integer:3:ValueProcessor)
@@ -767,24 +767,24 @@ let t : (R), t = (2, 3.1, 5);
SECTION("R^d tuples")
{
std::string_view data = R"(
-let a : R^2, a = (2,3.1);
-let t1 : (R^2), t1 = (a, (1,2), 0);
+let a : R^2, a = [2,3.1];
+let t1 : (R^2), t1 = (a, [1,2], 0);
let t2 : (R^3), t2 = (0, 0);
let t3 : (R^1), t3 = (1, 2.3, 0);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:a:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::integer:2:ValueProcessor)
| `-(language::real:3.1:ValueProcessor)
+-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<2ul, double> >)
| +-(language::name:t1:NameProcessor)
| `-(language::expression_list:ASTNodeExpressionListProcessor)
| +-(language::name:a:NameProcessor)
- | +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ | +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| | +-(language::integer:1:ValueProcessor)
| | `-(language::integer:2:ValueProcessor)
| `-(language::integer:0:ValueProcessor)
@@ -800,7 +800,6 @@ let t3 : (R^1), t3 = (1, 2.3, 0);
+-(language::real:2.3:ValueProcessor)
`-(language::integer:0:ValueProcessor)
)";
-
CHECK_AST(data, result);
}
@@ -916,7 +915,7 @@ let t : (R), t = 3.1;
SECTION("R^d tuples")
{
std::string_view data = R"(
-let a : R^2, a = (2,3.1);
+let a : R^2, a = [2,3.1];
let t1 : (R^2), t1 = a;
let t2 : (R^3), t2 = 0;
let t3 : (R^1), t3 = 2.3;
@@ -924,9 +923,9 @@ let t3 : (R^1), t3 = 2.3;
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:a:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::integer:2:ValueProcessor)
| `-(language::real:3.1:ValueProcessor)
+-(language::eq_op:AffectationToTupleProcessor<TinyVector<2ul, double> >)
diff --git a/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp b/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp
index 175093d61f214c4bf0d793a5ccf4fea26126f1d4..ee402307f95b0323bd726b0e093a1bb9af6e8f99 100644
--- a/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp
+++ b/tests/test_ASTNodeBinaryOperatorExpressionBuilder.cpp
@@ -169,15 +169,15 @@ let x : R^1, x = 3.7;
SECTION("R^2")
{
std::string_view data = R"(
-let x : R^2, x = (3.2,6);
+let x : R^2, x = [3.2,6];
2*x;
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::real:3.2:ValueProcessor)
| `-(language::integer:6:ValueProcessor)
`-(language::multiply_op:BinaryExpressionProcessor<language::multiply_op, TinyVector<2ul, double>, long, TinyVector<2ul, double> >)
@@ -191,15 +191,15 @@ let x : R^2, x = (3.2,6);
SECTION("R^3")
{
std::string_view data = R"(
-let x : R^3, x = (3.2,6,1.2);
+let x : R^3, x = [3.2,6,1.2];
2*x;
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::real:3.2:ValueProcessor)
| +-(language::integer:6:ValueProcessor)
| `-(language::real:1.2:ValueProcessor)
@@ -381,7 +381,7 @@ a+3+a;
CHECK_AST(data, result);
}
- SECTION("R^1")
+ SECTION("R^1 with variables")
{
std::string_view data = R"(
let x : R^1, x = 1;
@@ -405,24 +405,42 @@ x+y;
CHECK_AST(data, result);
}
- SECTION("R^2")
+ SECTION("R^1 raw")
+ {
+ std::string_view data = R"(
+[1]+[2];
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::plus_op:BinaryExpressionProcessor<language::plus_op, TinyVector<1ul, double>, TinyVector<1ul, double>, TinyVector<1ul, double> >)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ | `-(language::integer:1:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ `-(language::integer:2:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("R^2 with variables")
{
std::string_view data = R"(
-let x : R^2, x = (1,2);
-let y : R^2, y = (0.3,0.7);
+let x : R^2, x = [1,2];
+let y : R^2, y = [0.3,0.7];
x+y;
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::integer:1:ValueProcessor)
| `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:y:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::real:0.3:ValueProcessor)
| `-(language::real:0.7:ValueProcessor)
`-(language::plus_op:BinaryExpressionProcessor<language::plus_op, TinyVector<2ul, double>, TinyVector<2ul, double>, TinyVector<2ul, double> >)
@@ -433,25 +451,45 @@ x+y;
CHECK_AST(data, result);
}
- SECTION("R^3")
+ SECTION("R^2 raw")
+ {
+ std::string_view data = R"(
+[1,2]+[0.3,0.7];
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::plus_op:BinaryExpressionProcessor<language::plus_op, TinyVector<2ul, double>, TinyVector<2ul, double>, TinyVector<2ul, double> >)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ +-(language::real:0.3:ValueProcessor)
+ `-(language::real:0.7:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("R^3 with variables")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
-let y : R^3, y = (4,3,2);
+let x : R^3, x = [1,2,3];
+let y : R^3, y = [4,3,2];
x+y;
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
| +-(language::name:y:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:4:ValueProcessor)
| +-(language::integer:3:ValueProcessor)
| `-(language::integer:2:ValueProcessor)
@@ -463,6 +501,28 @@ x+y;
CHECK_AST(data, result);
}
+ SECTION("R^3 raw")
+ {
+ std::string_view data = R"(
+[1,2,3]+[4,3,2];
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::plus_op:BinaryExpressionProcessor<language::plus_op, TinyVector<3ul, double>, TinyVector<3ul, double>, TinyVector<3ul, double> >)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ +-(language::integer:4:ValueProcessor)
+ +-(language::integer:3:ValueProcessor)
+ `-(language::integer:2:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
SECTION("string concatenate bool")
{
std::string_view data = R"(
@@ -659,24 +719,42 @@ x-y;
CHECK_AST(data, result);
}
- SECTION("R^2")
+ SECTION("R^1 raw")
{
std::string_view data = R"(
-let x : R^2, x = (1,2);
-let y : R^2, y = (0.3,0.7);
+[1]-[2];
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::minus_op:BinaryExpressionProcessor<language::minus_op, TinyVector<1ul, double>, TinyVector<1ul, double>, TinyVector<1ul, double> >)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ | `-(language::integer:1:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ `-(language::integer:2:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("R^2 with variables")
+ {
+ std::string_view data = R"(
+let x : R^2, x = [1,2];
+let y : R^2, y = [0.3,0.7];
x-y;
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::integer:1:ValueProcessor)
| `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:y:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::real:0.3:ValueProcessor)
| `-(language::real:0.7:ValueProcessor)
`-(language::minus_op:BinaryExpressionProcessor<language::minus_op, TinyVector<2ul, double>, TinyVector<2ul, double>, TinyVector<2ul, double> >)
@@ -687,25 +765,45 @@ x-y;
CHECK_AST(data, result);
}
- SECTION("R^3")
+ SECTION("R^2 raw")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
-let y : R^3, y = (4,3,2);
+[1,2]-[0.3,0.7];
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::minus_op:BinaryExpressionProcessor<language::minus_op, TinyVector<2ul, double>, TinyVector<2ul, double>, TinyVector<2ul, double> >)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ +-(language::real:0.3:ValueProcessor)
+ `-(language::real:0.7:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("R^3 with variables")
+ {
+ std::string_view data = R"(
+let x : R^3, x = [1,2,3];
+let y : R^3, y = [4,3,2];
x-y;
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
| +-(language::name:y:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:4:ValueProcessor)
| +-(language::integer:3:ValueProcessor)
| `-(language::integer:2:ValueProcessor)
@@ -716,6 +814,28 @@ x-y;
CHECK_AST(data, result);
}
+
+ SECTION("R^3 raw")
+ {
+ std::string_view data = R"(
+[1,2,3]-[4,3,2];
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::minus_op:BinaryExpressionProcessor<language::minus_op, TinyVector<3ul, double>, TinyVector<3ul, double>, TinyVector<3ul, double> >)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ +-(language::integer:4:ValueProcessor)
+ +-(language::integer:3:ValueProcessor)
+ `-(language::integer:2:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
}
SECTION("or")
@@ -1172,8 +1292,7 @@ a == 3;
{
std::string_view data = R"(
let x : R^1, x = 1;
-let y : R^1, y = 2;
-x==y;
+x==[2];
)";
std::string_view result = R"(
@@ -1181,12 +1300,10 @@ x==y;
+-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<1ul, double>, long>)
| +-(language::name:x:NameProcessor)
| `-(language::integer:1:ValueProcessor)
- +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<1ul, double>, long>)
- | +-(language::name:y:NameProcessor)
- | `-(language::integer:2:ValueProcessor)
`-(language::eqeq_op:BinaryExpressionProcessor<language::eqeq_op, bool, TinyVector<1ul, double>, TinyVector<1ul, double> >)
+-(language::name:x:NameProcessor)
- `-(language::name:y:NameProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ `-(language::integer:2:ValueProcessor)
)";
CHECK_AST(data, result);
@@ -1195,26 +1312,22 @@ x==y;
SECTION("R^2")
{
std::string_view data = R"(
-let x : R^2, x = (1,2);
-let y : R^2, y = (0.3,0.7);
-x==y;
+let x : R^2, x = [1,2];
+x==[0.3,0.7];
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::integer:1:ValueProcessor)
| `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
- | +-(language::name:y:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
- | +-(language::real:0.3:ValueProcessor)
- | `-(language::real:0.7:ValueProcessor)
`-(language::eqeq_op:BinaryExpressionProcessor<language::eqeq_op, bool, TinyVector<2ul, double>, TinyVector<2ul, double> >)
+-(language::name:x:NameProcessor)
- `-(language::name:y:NameProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ +-(language::real:0.3:ValueProcessor)
+ `-(language::real:0.7:ValueProcessor)
)";
CHECK_AST(data, result);
@@ -1223,28 +1336,24 @@ x==y;
SECTION("R^3")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
-let y : R^3, y = (4,3,2);
-x==y;
+let x : R^3, x = [1,2,3];
+x==[4,3,2];
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
- | +-(language::name:y:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
- | +-(language::integer:4:ValueProcessor)
- | +-(language::integer:3:ValueProcessor)
- | `-(language::integer:2:ValueProcessor)
`-(language::eqeq_op:BinaryExpressionProcessor<language::eqeq_op, bool, TinyVector<3ul, double>, TinyVector<3ul, double> >)
+-(language::name:x:NameProcessor)
- `-(language::name:y:NameProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ +-(language::integer:4:ValueProcessor)
+ +-(language::integer:3:ValueProcessor)
+ `-(language::integer:2:ValueProcessor)
)";
CHECK_AST(data, result);
@@ -1325,8 +1434,7 @@ a != 3;
{
std::string_view data = R"(
let x : R^1, x = 1;
-let y : R^1, y = 2;
-x!=y;
+x!=[2];
)";
std::string_view result = R"(
@@ -1334,12 +1442,10 @@ x!=y;
+-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<1ul, double>, long>)
| +-(language::name:x:NameProcessor)
| `-(language::integer:1:ValueProcessor)
- +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<1ul, double>, long>)
- | +-(language::name:y:NameProcessor)
- | `-(language::integer:2:ValueProcessor)
`-(language::not_eq_op:BinaryExpressionProcessor<language::not_eq_op, bool, TinyVector<1ul, double>, TinyVector<1ul, double> >)
+-(language::name:x:NameProcessor)
- `-(language::name:y:NameProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ `-(language::integer:2:ValueProcessor)
)";
CHECK_AST(data, result);
@@ -1348,26 +1454,22 @@ x!=y;
SECTION("R^2")
{
std::string_view data = R"(
-let x : R^2, x = (1,2);
-let y : R^2, y = (0.3,0.7);
-x!=y;
+let x : R^2, x = [1,2];
+x!=[0.3,0.7];
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::integer:1:ValueProcessor)
| `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
- | +-(language::name:y:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
- | +-(language::real:0.3:ValueProcessor)
- | `-(language::real:0.7:ValueProcessor)
`-(language::not_eq_op:BinaryExpressionProcessor<language::not_eq_op, bool, TinyVector<2ul, double>, TinyVector<2ul, double> >)
+-(language::name:x:NameProcessor)
- `-(language::name:y:NameProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ +-(language::real:0.3:ValueProcessor)
+ `-(language::real:0.7:ValueProcessor)
)";
CHECK_AST(data, result);
@@ -1376,28 +1478,24 @@ x!=y;
SECTION("R^3")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
-let y : R^3, y = (4,3,2);
-x!=y;
+let x : R^3, x = [1,2,3];
+x!=[4,3,2];
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
- | +-(language::name:y:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
- | +-(language::integer:4:ValueProcessor)
- | +-(language::integer:3:ValueProcessor)
- | `-(language::integer:2:ValueProcessor)
`-(language::not_eq_op:BinaryExpressionProcessor<language::not_eq_op, bool, TinyVector<3ul, double>, TinyVector<3ul, double> >)
+-(language::name:x:NameProcessor)
- `-(language::name:y:NameProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ +-(language::integer:4:ValueProcessor)
+ +-(language::integer:3:ValueProcessor)
+ `-(language::integer:2:ValueProcessor)
)";
CHECK_AST(data, result);
diff --git a/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp b/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp
index 7fb68cd69c16331c07db8354a40dcb029fcb5c14..05b64ce5127758d9772e297c5d8a2c62bb62119c 100644
--- a/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp
+++ b/tests/test_ASTNodeBuiltinFunctionExpressionBuilder.cpp
@@ -474,10 +474,10 @@ R2toR(0);
CHECK_AST(data, result);
}
- SECTION("from R^2")
+ SECTION("from R^2 variable")
{
std::string_view data = R"(
-let x:R^2, x = (1,2);
+let x:R^2, x = [1,2];
R2toR(x);
)";
@@ -491,17 +491,17 @@ R2toR(x);
CHECK_AST(data, result);
}
- SECTION("from list")
+ SECTION("from R^2 value")
{
std::string_view data = R"(
-R2toR((1,2));
+R2toR([1,2]);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:R2toR:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+-(language::integer:1:ValueProcessor)
`-(language::integer:2:ValueProcessor)
)";
@@ -528,10 +528,10 @@ R22toR(0);
CHECK_AST(data, result);
}
- SECTION("from R^2x2")
+ SECTION("from R^2x2 variable")
{
std::string_view data = R"(
-let x:R^2x2, x = (1,2,3,4);
+let x:R^2x2, x = [[1,2],[3,4]];
R22toR(x);
)";
@@ -545,21 +545,23 @@ R22toR(x);
CHECK_AST(data, result);
}
- SECTION("from list")
+ SECTION("from R^2x2 value")
{
std::string_view data = R"(
-R22toR((1,2,3,4));
+R22toR([[1,2],[3,4]]);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:R22toR:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
- +-(language::integer:1:ValueProcessor)
- +-(language::integer:2:ValueProcessor)
- +-(language::integer:3:ValueProcessor)
- `-(language::integer:4:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::row_expression:FakeProcessor)
+ +-(language::integer:3:ValueProcessor)
+ `-(language::integer:4:ValueProcessor)
)";
CHECK_AST(data, result);
@@ -584,10 +586,10 @@ R3toR(0);
CHECK_AST(data, result);
}
- SECTION("from R^3")
+ SECTION("from R^3 variable")
{
std::string_view data = R"(
-let x:R^3, x = (1,2,4);
+let x:R^3, x = [1,2,4];
R3toR(x);
)";
@@ -601,17 +603,17 @@ R3toR(x);
CHECK_AST(data, result);
}
- SECTION("from list")
+ SECTION("from R^3 value")
{
std::string_view data = R"(
-R3toR((1,2,3));
+R3toR([1,2,3]);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:R3toR:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+-(language::integer:1:ValueProcessor)
+-(language::integer:2:ValueProcessor)
`-(language::integer:3:ValueProcessor)
@@ -639,10 +641,10 @@ R33toR(0);
CHECK_AST(data, result);
}
- SECTION("from R^3x3")
+ SECTION("from R^3x3 variable")
{
std::string_view data = R"(
-let x:R^3x3, x = (1,2,3,4,5,6,7,8,9);
+let x:R^3x3, x = [[1,2,3],[4,5,6],[7,8,9]];
R33toR(x);
)";
@@ -656,26 +658,29 @@ R33toR(x);
CHECK_AST(data, result);
}
- SECTION("from list")
+ SECTION("from R^3x3 value")
{
std::string_view data = R"(
-R33toR((1,2,3,4,5,6,7,8,9));
+R33toR([[1,2,3],[4,5,6],[7,8,9]]);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:R33toR:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
- +-(language::integer:1:ValueProcessor)
- +-(language::integer:2:ValueProcessor)
- +-(language::integer:3:ValueProcessor)
- +-(language::integer:4:ValueProcessor)
- +-(language::integer:5:ValueProcessor)
- +-(language::integer:6:ValueProcessor)
- +-(language::integer:7:ValueProcessor)
- +-(language::integer:8:ValueProcessor)
- `-(language::integer:9:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:4:ValueProcessor)
+ | +-(language::integer:5:ValueProcessor)
+ | `-(language::integer:6:ValueProcessor)
+ `-(language::row_expression:FakeProcessor)
+ +-(language::integer:7:ValueProcessor)
+ +-(language::integer:8:ValueProcessor)
+ `-(language::integer:9:ValueProcessor)
)";
CHECK_AST(data, result);
@@ -828,8 +833,8 @@ RRtoB(1., 0.);
SECTION("from R^3*R^2")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
-let y : R^2, y = (2,3);
+let x : R^3, x = [1,2,3];
+let y : R^2, y = [2,3];
R3R2toR(x,y);
)";
@@ -845,10 +850,10 @@ R3R2toR(x,y);
CHECK_AST(data, result);
}
- SECTION("from (R,R,R)*(R,R)")
+ SECTION("from R^3*R^2 value")
{
std::string_view data = R"(
-R3R2toR((1,2,3),(3,4));
+R3R2toR([1,2,3],[3,4]);
)";
std::string_view result = R"(
@@ -856,11 +861,11 @@ R3R2toR((1,2,3),(3,4));
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:R3R2toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
- +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+-(language::integer:3:ValueProcessor)
`-(language::integer:4:ValueProcessor)
)";
@@ -868,10 +873,10 @@ R3R2toR((1,2,3),(3,4));
CHECK_AST(data, result);
}
- SECTION("from (R,R,R)*(0)")
+ SECTION("from R^3*'0'")
{
std::string_view data = R"(
-R3R2toR((1,2,3),0);
+R3R2toR([1,2,3],0);
)";
std::string_view result = R"(
@@ -879,7 +884,7 @@ R3R2toR((1,2,3),0);
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:R3R2toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
- +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
@@ -895,8 +900,8 @@ R3R2toR((1,2,3),0);
SECTION("from R^3x3*R^2x2")
{
std::string_view data = R"(
-let x : R^3x3, x = (1,2,3,4,5,6,7,8,9);
-let y : R^2x2, y = (1,2,3,4);
+let x : R^3x3, x = [[1,2,3],[4,5,6],[7,8,9]];
+let y : R^2x2, y = [[1,2],[3,4]];
R33R22toR(x,y);
)";
@@ -912,10 +917,10 @@ R33R22toR(x,y);
CHECK_AST(data, result);
}
- SECTION("from (R,R,R,R,R,R,R,R,R)*(R,R,R,R)")
+ SECTION("from R^3x3*R^2x2 value")
{
std::string_view data = R"(
-R33R22toR((1,2,3,4,5,6,7,8,9),(1,2,3,4));
+R33R22toR([[1,2,3],[4,5,6],[7,8,9]],[[1,2],[3,4]]);
)";
std::string_view result = R"(
@@ -923,30 +928,35 @@ R33R22toR((1,2,3,4,5,6,7,8,9),(1,2,3,4));
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:R33R22toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
- +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
- | +-(language::integer:1:ValueProcessor)
- | +-(language::integer:2:ValueProcessor)
- | +-(language::integer:3:ValueProcessor)
- | +-(language::integer:4:ValueProcessor)
- | +-(language::integer:5:ValueProcessor)
- | +-(language::integer:6:ValueProcessor)
- | +-(language::integer:7:ValueProcessor)
- | +-(language::integer:8:ValueProcessor)
- | `-(language::integer:9:ValueProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
- +-(language::integer:1:ValueProcessor)
- +-(language::integer:2:ValueProcessor)
- +-(language::integer:3:ValueProcessor)
- `-(language::integer:4:ValueProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:1:ValueProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::integer:3:ValueProcessor)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:4:ValueProcessor)
+ | | +-(language::integer:5:ValueProcessor)
+ | | `-(language::integer:6:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::integer:7:ValueProcessor)
+ | +-(language::integer:8:ValueProcessor)
+ | `-(language::integer:9:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::row_expression:FakeProcessor)
+ +-(language::integer:3:ValueProcessor)
+ `-(language::integer:4:ValueProcessor)
)";
CHECK_AST(data, result);
}
- SECTION("from (R,R,R,R,R,R,R,R,R)*(0)")
+ SECTION("from R^3x3*'0'")
{
std::string_view data = R"(
-R33R22toR((1,2,3,4,5,6,7,8,9),0);
+R33R22toR([[1,2,3],[4,5,6],[7,8,9]],0);
)";
std::string_view result = R"(
@@ -954,16 +964,19 @@ R33R22toR((1,2,3,4,5,6,7,8,9),0);
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:R33R22toR:FakeProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
- +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
- | +-(language::integer:1:ValueProcessor)
- | +-(language::integer:2:ValueProcessor)
- | +-(language::integer:3:ValueProcessor)
- | +-(language::integer:4:ValueProcessor)
- | +-(language::integer:5:ValueProcessor)
- | +-(language::integer:6:ValueProcessor)
- | +-(language::integer:7:ValueProcessor)
- | +-(language::integer:8:ValueProcessor)
- | `-(language::integer:9:ValueProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:1:ValueProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::integer:3:ValueProcessor)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:4:ValueProcessor)
+ | | +-(language::integer:5:ValueProcessor)
+ | | `-(language::integer:6:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::integer:7:ValueProcessor)
+ | +-(language::integer:8:ValueProcessor)
+ | `-(language::integer:9:ValueProcessor)
`-(language::integer:0:ValueProcessor)
)";
@@ -1216,7 +1229,7 @@ tuple_RtoB((1.2, 2, true, n));
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:tuple_RtoB:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+-(language::real:1.2:ValueProcessor)
+-(language::integer:2:ValueProcessor)
+-(language::true_kw:ValueProcessor)
@@ -1319,7 +1332,7 @@ tuple_stringtoB(("foo",2,"bar"));
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:tuple_stringtoB:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+-(language::literal:"foo":ValueProcessor)
+-(language::integer:2:ValueProcessor)
`-(language::literal:"bar":ValueProcessor)
@@ -1354,7 +1367,7 @@ tuple_builtinToB((a,b,a));
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:tuple_builtinToB:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+-(language::name:a:NameProcessor)
+-(language::name:b:NameProcessor)
`-(language::name:a:NameProcessor)
@@ -1514,7 +1527,7 @@ tuple_R2ToR(r);
SECTION("compound_list -> tuple(R^2)")
{
std::string_view data = R"(
-let r:R^2, r = (1,2);
+let r:R^2, r = [1,2];
tuple_R2ToR((r,r));
)";
@@ -1522,7 +1535,7 @@ tuple_R2ToR((r,r));
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:tuple_R2ToR:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+-(language::name:r:NameProcessor)
`-(language::name:r:NameProcessor)
)";
@@ -1549,7 +1562,7 @@ tuple_R22ToR(0);
SECTION("R^2x2 -> tuple(R^2x2)")
{
std::string_view data = R"(
-let r:R^2x2, r = (1,2,3,4);
+let r:R^2x2, r = [[1,2],[3,4]];
tuple_R22ToR(r);
)";
@@ -1566,7 +1579,7 @@ tuple_R22ToR(r);
SECTION("compound_list -> tuple(R^2x2)")
{
std::string_view data = R"(
-let r:R^2x2, r = (1,2,3,4);
+let r:R^2x2, r = [[1,2],[3,4]];
tuple_R22ToR((r,r));
)";
@@ -1574,7 +1587,7 @@ tuple_R22ToR((r,r));
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:tuple_R22ToR:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+-(language::name:r:NameProcessor)
`-(language::name:r:NameProcessor)
)";
@@ -1601,7 +1614,7 @@ tuple_R3ToR(0);
SECTION("R^3 -> tuple(R^3)")
{
std::string_view data = R"(
-let r:R^3, r = (1,2,3);
+let r:R^3, r = [1,2,3];
tuple_R3ToR(r);
)";
@@ -1634,7 +1647,7 @@ tuple_R33ToR(0);
SECTION("R^3x3 -> tuple(R^3x3)")
{
std::string_view data = R"(
-let r:R^3x3, r = (1,2,3,4,5,6,7,8,9);
+let r:R^3x3, r = [[1,2,3],[4,5,6],[7,8,9]];
tuple_R33ToR(r);
)";
@@ -1676,7 +1689,7 @@ fidTupleToR((f,f));
(root:ASTNodeListProcessor)
`-(language::function_evaluation:BuiltinFunctionProcessor)
+-(language::name:fidTupleToR:FakeProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+-(language::name:f:NameProcessor)
`-(language::name:f:NameProcessor)
)";
diff --git a/tests/test_ASTNodeDataType.cpp b/tests/test_ASTNodeDataType.cpp
index 023ec9963bcd66286c9ffcfcadbc4fb3b2abdbee..29ee313082bd7908699c1227d0486aa31538300f 100644
--- a/tests/test_ASTNodeDataType.cpp
+++ b/tests/test_ASTNodeDataType.cpp
@@ -182,6 +182,68 @@ TEST_CASE("ASTNodeDataType", "[language]")
}
}
+ SECTION("getVectorExpressionType")
+ {
+ std::unique_ptr vector_expression_node = std::make_unique<ASTNode>();
+ vector_expression_node->set_type<language::vector_expression>();
+ vector_expression_node->emplace_back(std::make_unique<ASTNode>());
+
+ SECTION("good nodes")
+ {
+ vector_expression_node->children.resize(1);
+ for (size_t i = 0; i < vector_expression_node->children.size(); ++i) {
+ vector_expression_node->children[i] = std::make_unique<ASTNode>();
+ vector_expression_node->children[i]->m_data_type = ASTNodeDataType::build<ASTNodeDataType::bool_t>();
+ }
+ REQUIRE(getVectorExpressionType(*vector_expression_node) == ASTNodeDataType::build<ASTNodeDataType::vector_t>(1));
+ REQUIRE(getVectorExpressionType(*vector_expression_node).dimension() == 1);
+
+ vector_expression_node->children.resize(2);
+ for (size_t i = 0; i < vector_expression_node->children.size(); ++i) {
+ vector_expression_node->children[i] = std::make_unique<ASTNode>();
+ vector_expression_node->children[i]->m_data_type = ASTNodeDataType::build<ASTNodeDataType::double_t>();
+ }
+ REQUIRE(getVectorExpressionType(*vector_expression_node) == ASTNodeDataType::build<ASTNodeDataType::vector_t>(2));
+ REQUIRE(getVectorExpressionType(*vector_expression_node).dimension() == 2);
+
+ vector_expression_node->children.resize(3);
+ for (size_t i = 0; i < vector_expression_node->children.size(); ++i) {
+ vector_expression_node->children[i] = std::make_unique<ASTNode>();
+ vector_expression_node->children[i]->m_data_type = ASTNodeDataType::build<ASTNodeDataType::unsigned_int_t>();
+ }
+ REQUIRE(getVectorExpressionType(*vector_expression_node) == ASTNodeDataType::build<ASTNodeDataType::vector_t>(3));
+ REQUIRE(getVectorExpressionType(*vector_expression_node).dimension() == 3);
+ }
+
+ SECTION("bad content type")
+ {
+ vector_expression_node->children.resize(3);
+ for (size_t i = 0; i < vector_expression_node->children.size(); ++i) {
+ vector_expression_node->children[i] = std::make_unique<ASTNode>();
+ }
+ REQUIRE_THROWS_WITH(getVectorExpressionType(*vector_expression_node),
+ "unexpected error: invalid implicit conversion: undefined -> R");
+ }
+
+ SECTION("bad node type")
+ {
+ vector_expression_node->set_type<language::real>();
+ REQUIRE_THROWS_WITH(getVectorExpressionType(*vector_expression_node), "unexpected node type");
+ }
+
+ SECTION("bad children size 2")
+ {
+ vector_expression_node->children.resize(4);
+ REQUIRE_THROWS_WITH(getVectorExpressionType(*vector_expression_node), "invalid dimension (must be 1, 2 or 3)");
+ }
+
+ SECTION("bad children size 2")
+ {
+ vector_expression_node->children.clear();
+ REQUIRE_THROWS_WITH(getVectorExpressionType(*vector_expression_node), "unexpected node type");
+ }
+ }
+
SECTION("getMatrixDataType")
{
std::unique_ptr type_node = std::make_unique<ASTNode>();
@@ -229,7 +291,7 @@ TEST_CASE("ASTNodeDataType", "[language]")
REQUIRE_THROWS_WITH(getMatrixDataType(*type_node), "unexpected node type");
}
- SECTION("bad children size 1")
+ SECTION("bad children size 2")
{
type_node->children.emplace_back(std::unique_ptr<ASTNode>());
REQUIRE_THROWS_WITH(getMatrixDataType(*type_node), "unexpected node type");
@@ -298,6 +360,137 @@ TEST_CASE("ASTNodeDataType", "[language]")
}
}
+ SECTION("getMatrixExpressionType")
+ {
+ std::unique_ptr matrix_expression_node = std::make_unique<ASTNode>();
+ matrix_expression_node->set_type<language::matrix_expression>();
+ matrix_expression_node->emplace_back(std::make_unique<ASTNode>());
+
+ SECTION("good nodes")
+ {
+ {
+ const size_t dimension = 1;
+ matrix_expression_node->children.clear();
+ for (size_t i = 0; i < dimension; ++i) {
+ matrix_expression_node->children.emplace_back(std::make_unique<ASTNode>());
+ matrix_expression_node->children[i]->set_type<language::row_expression>();
+ for (size_t j = 0; j < dimension; ++j) {
+ matrix_expression_node->children[i]->children.emplace_back(std::make_unique<ASTNode>());
+ matrix_expression_node->children[i]->children[j]->m_data_type =
+ ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ }
+ }
+ REQUIRE(getMatrixExpressionType(*matrix_expression_node) ==
+ ASTNodeDataType::build<ASTNodeDataType::matrix_t>(dimension, dimension));
+ REQUIRE(getMatrixExpressionType(*matrix_expression_node).numberOfRows() == dimension);
+ REQUIRE(getMatrixExpressionType(*matrix_expression_node).numberOfColumns() == dimension);
+ }
+
+ {
+ const size_t dimension = 2;
+ matrix_expression_node->children.clear();
+ for (size_t i = 0; i < dimension; ++i) {
+ matrix_expression_node->children.emplace_back(std::make_unique<ASTNode>());
+ matrix_expression_node->children[i]->set_type<language::row_expression>();
+ for (size_t j = 0; j < dimension; ++j) {
+ matrix_expression_node->children[i]->children.emplace_back(std::make_unique<ASTNode>());
+ matrix_expression_node->children[i]->children[j]->m_data_type =
+ ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ }
+ }
+ REQUIRE(getMatrixExpressionType(*matrix_expression_node) ==
+ ASTNodeDataType::build<ASTNodeDataType::matrix_t>(dimension, dimension));
+ REQUIRE(getMatrixExpressionType(*matrix_expression_node).numberOfRows() == dimension);
+ REQUIRE(getMatrixExpressionType(*matrix_expression_node).numberOfColumns() == dimension);
+ }
+
+ {
+ const size_t dimension = 3;
+ matrix_expression_node->children.clear();
+ for (size_t i = 0; i < dimension; ++i) {
+ matrix_expression_node->children.emplace_back(std::make_unique<ASTNode>());
+ matrix_expression_node->children[i]->set_type<language::row_expression>();
+ for (size_t j = 0; j < dimension; ++j) {
+ matrix_expression_node->children[i]->children.emplace_back(std::make_unique<ASTNode>());
+ matrix_expression_node->children[i]->children[j]->m_data_type =
+ ASTNodeDataType::build<ASTNodeDataType::int_t>();
+ }
+ }
+ REQUIRE(getMatrixExpressionType(*matrix_expression_node) ==
+ ASTNodeDataType::build<ASTNodeDataType::matrix_t>(dimension, dimension));
+ REQUIRE(getMatrixExpressionType(*matrix_expression_node).numberOfRows() == dimension);
+ REQUIRE(getMatrixExpressionType(*matrix_expression_node).numberOfColumns() == dimension);
+ }
+ }
+
+ SECTION("bad content type")
+ {
+ const size_t dimension = 3;
+ matrix_expression_node->children.clear();
+ for (size_t i = 0; i < dimension; ++i) {
+ matrix_expression_node->children.emplace_back(std::make_unique<ASTNode>());
+ matrix_expression_node->children[i]->set_type<language::row_expression>();
+ for (size_t j = 0; j < dimension; ++j) {
+ matrix_expression_node->children[i]->children.emplace_back(std::make_unique<ASTNode>());
+ }
+ }
+ REQUIRE_THROWS_WITH(getMatrixExpressionType(*matrix_expression_node),
+ "unexpected error: invalid implicit conversion: undefined -> R");
+ }
+
+ SECTION("bad node type")
+ {
+ matrix_expression_node->set_type<language::real>();
+ REQUIRE_THROWS_WITH(getMatrixExpressionType(*matrix_expression_node), "unexpected node type");
+ }
+
+ SECTION("bad content type")
+ {
+ const size_t dimension = 3;
+ matrix_expression_node->children.clear();
+ for (size_t i = 0; i < dimension; ++i) {
+ matrix_expression_node->children.emplace_back(std::make_unique<ASTNode>());
+ }
+ REQUIRE_THROWS_WITH(getMatrixExpressionType(*matrix_expression_node), "expecting row expression");
+ }
+
+ SECTION("bad children size 1")
+ {
+ matrix_expression_node->children.resize(4);
+ REQUIRE_THROWS_WITH(getMatrixExpressionType(*matrix_expression_node), "invalid dimension (must be 1, 2 or 3)");
+ }
+
+ SECTION("bad children size 2")
+ {
+ const size_t dimension = 2;
+ matrix_expression_node->children.clear();
+ for (size_t i = 0; i < dimension; ++i) {
+ matrix_expression_node->children.emplace_back(std::make_unique<ASTNode>());
+ matrix_expression_node->children[i]->set_type<language::row_expression>();
+ for (size_t j = 0; j < dimension + 1; ++j) {
+ matrix_expression_node->children[i]->children.emplace_back(std::make_unique<ASTNode>());
+ }
+ }
+ REQUIRE_THROWS_WITH(getMatrixExpressionType(*matrix_expression_node), "only square matrices are supported");
+ }
+
+ SECTION("bad children size 3")
+ {
+ const size_t dimension = 2;
+ matrix_expression_node->children.clear();
+ for (size_t i = 0; i < dimension; ++i) {
+ matrix_expression_node->children.emplace_back(std::make_unique<ASTNode>());
+ matrix_expression_node->children[i]->set_type<language::row_expression>();
+ for (size_t j = 0; j < dimension; ++j) {
+ matrix_expression_node->children[i]->children.emplace_back(std::make_unique<ASTNode>());
+ }
+ }
+ matrix_expression_node->children[1]->children.emplace_back(std::make_unique<ASTNode>());
+
+ REQUIRE_THROWS_WITH(getMatrixExpressionType(*matrix_expression_node), "row must have same sizes");
+ }
+ }
+
SECTION("isNaturalConversion")
{
SECTION("-> B")
diff --git a/tests/test_ASTNodeDataTypeBuilder.cpp b/tests/test_ASTNodeDataTypeBuilder.cpp
index 5dcd6f57cb77dc3e91b8e2e084f98b9143a75f1c..9ec4f8dabbf448916ca491cc262be1edf5fa412c 100644
--- a/tests/test_ASTNodeDataTypeBuilder.cpp
+++ b/tests/test_ASTNodeDataTypeBuilder.cpp
@@ -520,9 +520,10 @@ let t : (R), t = (2, 3.1, 5);
SECTION("R^d tuples")
{
std::string_view data = R"(
-let a : R^2, a = (2,3.1);
-let t1 : (R^2), t1 = (a, (1,2), 0);
+let a : R^2, a = [2,3.1];
+let t1 : (R^2), t1 = (a, [1,2], 0);
let t2 : (R^3), t2 = (0, 0);
+let t3 : (R^2), t3 = ([1,2], a, 0);
)";
std::string_view result = R"(
@@ -533,7 +534,7 @@ let t2 : (R^3), t2 = (0, 0);
| | +-(language::R_set:R)
| | `-(language::integer:2:Z)
| +-(language::name:a:R^2)
- | `-(language::expression_list:Z*R)
+ | `-(language::vector_expression:R^2)
| +-(language::integer:2:Z)
| `-(language::real:3.1:R)
+-(language::var_declaration:void)
@@ -543,21 +544,34 @@ let t2 : (R^3), t2 = (0, 0);
| | +-(language::R_set:R)
| | `-(language::integer:2:Z)
| +-(language::name:t1:(R^2...))
- | `-(language::expression_list:R^2*(Z*Z)*Z)
+ | `-(language::expression_list:R^2*R^2*Z)
| +-(language::name:a:R^2)
- | +-(language::tuple_expression:Z*Z)
+ | +-(language::vector_expression:R^2)
| | +-(language::integer:1:Z)
| | `-(language::integer:2:Z)
| `-(language::integer:0:Z)
+ +-(language::var_declaration:void)
+ | +-(language::name:t2:(R^3...))
+ | +-(language::tuple_type_specifier:(R^3...))
+ | | `-(language::vector_type:R^3)
+ | | +-(language::R_set:R)
+ | | `-(language::integer:3:Z)
+ | +-(language::name:t2:(R^3...))
+ | `-(language::expression_list:Z*Z)
+ | +-(language::integer:0:Z)
+ | `-(language::integer:0:Z)
`-(language::var_declaration:void)
- +-(language::name:t2:(R^3...))
- +-(language::tuple_type_specifier:(R^3...))
- | `-(language::vector_type:R^3)
+ +-(language::name:t3:(R^2...))
+ +-(language::tuple_type_specifier:(R^2...))
+ | `-(language::vector_type:R^2)
| +-(language::R_set:R)
- | `-(language::integer:3:Z)
- +-(language::name:t2:(R^3...))
- `-(language::expression_list:Z*Z)
- +-(language::integer:0:Z)
+ | `-(language::integer:2:Z)
+ +-(language::name:t3:(R^2...))
+ `-(language::expression_list:R^2*R^2*Z)
+ +-(language::vector_expression:R^2)
+ | +-(language::integer:1:Z)
+ | `-(language::integer:2:Z)
+ +-(language::name:a:R^2)
`-(language::integer:0:Z)
)";
@@ -567,9 +581,10 @@ let t2 : (R^3), t2 = (0, 0);
SECTION("R^dxd tuples")
{
std::string_view data = R"(
-let a : R^2x2, a = (2, 3.1, -1.2, 4);
-let t1 : (R^2x2), t1 = (a, (1,2,1,3), 0);
+let a : R^2x2, a = [[2, 3.1], [-1.2, 4]];
+let t1 : (R^2x2), t1 = (a, [[1,2],[1,3]], 0);
let t2 : (R^3x3), t2 = (0, 0);
+let t3 : (R^2x2), t3 = ([[1,2],[1,3]], a, 0);
)";
std::string_view result = R"(
@@ -581,12 +596,14 @@ let t2 : (R^3x3), t2 = (0, 0);
| | +-(language::integer:2:Z)
| | `-(language::integer:2:Z)
| +-(language::name:a:R^2x2)
- | `-(language::expression_list:Z*R*R*Z)
- | +-(language::integer:2:Z)
- | +-(language::real:3.1:R)
- | +-(language::unary_minus:R)
- | | `-(language::real:1.2:R)
- | `-(language::integer:4:Z)
+ | `-(language::matrix_expression:R^2x2)
+ | +-(language::row_expression:void)
+ | | +-(language::integer:2:Z)
+ | | `-(language::real:3.1:R)
+ | `-(language::row_expression:void)
+ | +-(language::unary_minus:R)
+ | | `-(language::real:1.2:R)
+ | `-(language::integer:4:Z)
+-(language::var_declaration:void)
| +-(language::name:t1:(R^2x2...))
| +-(language::tuple_type_specifier:(R^2x2...))
@@ -595,24 +612,44 @@ let t2 : (R^3x3), t2 = (0, 0);
| | +-(language::integer:2:Z)
| | `-(language::integer:2:Z)
| +-(language::name:t1:(R^2x2...))
- | `-(language::expression_list:R^2x2*(Z*Z*Z*Z)*Z)
+ | `-(language::expression_list:R^2x2*R^2x2*Z)
| +-(language::name:a:R^2x2)
- | +-(language::tuple_expression:Z*Z*Z*Z)
- | | +-(language::integer:1:Z)
- | | +-(language::integer:2:Z)
- | | +-(language::integer:1:Z)
- | | `-(language::integer:3:Z)
+ | +-(language::matrix_expression:R^2x2)
+ | | +-(language::row_expression:void)
+ | | | +-(language::integer:1:Z)
+ | | | `-(language::integer:2:Z)
+ | | `-(language::row_expression:void)
+ | | +-(language::integer:1:Z)
+ | | `-(language::integer:3:Z)
+ | `-(language::integer:0:Z)
+ +-(language::var_declaration:void)
+ | +-(language::name:t2:(R^3x3...))
+ | +-(language::tuple_type_specifier:(R^3x3...))
+ | | `-(language::matrix_type:R^3x3)
+ | | +-(language::R_set:R)
+ | | +-(language::integer:3:Z)
+ | | `-(language::integer:3:Z)
+ | +-(language::name:t2:(R^3x3...))
+ | `-(language::expression_list:Z*Z)
+ | +-(language::integer:0:Z)
| `-(language::integer:0:Z)
`-(language::var_declaration:void)
- +-(language::name:t2:(R^3x3...))
- +-(language::tuple_type_specifier:(R^3x3...))
- | `-(language::matrix_type:R^3x3)
+ +-(language::name:t3:(R^2x2...))
+ +-(language::tuple_type_specifier:(R^2x2...))
+ | `-(language::matrix_type:R^2x2)
| +-(language::R_set:R)
- | +-(language::integer:3:Z)
- | `-(language::integer:3:Z)
- +-(language::name:t2:(R^3x3...))
- `-(language::expression_list:Z*Z)
- +-(language::integer:0:Z)
+ | +-(language::integer:2:Z)
+ | `-(language::integer:2:Z)
+ +-(language::name:t3:(R^2x2...))
+ `-(language::expression_list:R^2x2*R^2x2*Z)
+ +-(language::matrix_expression:R^2x2)
+ | +-(language::row_expression:void)
+ | | +-(language::integer:1:Z)
+ | | `-(language::integer:2:Z)
+ | `-(language::row_expression:void)
+ | +-(language::integer:1:Z)
+ | `-(language::integer:3:Z)
+ +-(language::name:a:R^2x2)
`-(language::integer:0:Z)
)";
@@ -743,7 +780,7 @@ let double : R^2 -> R^2, x -> 2*x;
SECTION("R-list -> R^d")
{
std::string_view data = R"(
-let square : R -> R^2, x -> (x, x*x);
+let square : R -> R^2, x -> [x, x*x];
)";
std::string_view result = R"(
@@ -806,7 +843,7 @@ let det : R^2x2 -> R, x -> x[0,0]*x[1,1]-x[1,0]*x[0,1];
SECTION("R-list -> R^dxd")
{
std::string_view data = R"(
-let f : R -> R^2x2, x -> (x, x*x, 2-x, 0);
+let f : R -> R^2x2, x -> [[x, x*x], [2-x, 0]];
)";
std::string_view result = R"(
@@ -821,7 +858,7 @@ let f : R -> R^2x2, x -> (x, x*x, 2-x, 0);
SECTION("R^d*R^d -> R^dxd")
{
std::string_view data = R"(
-let f : R^2*R^2 -> R^2x2, (x,y) -> (x[0], y[0], x[1], y[1]);
+let f : R^2*R^2 -> R^2x2, (x,y) -> [[x[0], y[0]], [x[1], y[1]]];
)";
std::string_view result = R"(
@@ -1153,8 +1190,8 @@ let f: R -> X, x -> x;
SECTION("single argument")
{
std::string_view data = R"(
-let f : R^2 -> R^2, x -> (x[0]+1, x[1]-2);
-let x : R^2, x = (1,2);
+let f : R^2 -> R^2, x -> [x[0]+1, x[1]-2];
+let x : R^2, x = [1,2];
x = f(x);
)";
@@ -1168,7 +1205,7 @@ x = f(x);
| | +-(language::R_set:R)
| | `-(language::integer:2:Z)
| +-(language::name:x:R^2)
- | `-(language::expression_list:Z*Z)
+ | `-(language::vector_expression:R^2)
| +-(language::integer:1:Z)
| `-(language::integer:2:Z)
`-(language::eq_op:void)
diff --git a/tests/test_ASTNodeExpressionBuilder.cpp b/tests/test_ASTNodeExpressionBuilder.cpp
index 56af1db48dce6019d5cb3fedf93c3e32cfc12e25..127b2e01624a07ba9579494692573106ced0bc9a 100644
--- a/tests/test_ASTNodeExpressionBuilder.cpp
+++ b/tests/test_ASTNodeExpressionBuilder.cpp
@@ -273,7 +273,7 @@ z -= 2;
SECTION("tuple -> R^3")
{
std::string_view data = R"(
-let (t,x): R*R^3, (t,x) = (0,(1,2,3));
+let (t,x): R*R^3, (t,x) = (0,[1,2,3]);
)";
std::string result = R"(
@@ -284,7 +284,7 @@ let (t,x): R*R^3, (t,x) = (0,(1,2,3));
| `-(language::name:x:NameProcessor)
`-(language::expression_list:ASTNodeExpressionListProcessor)
+-(language::integer:0:ValueProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+-(language::integer:1:ValueProcessor)
+-(language::integer:2:ValueProcessor)
`-(language::integer:3:ValueProcessor)
@@ -296,7 +296,7 @@ let (t,x): R*R^3, (t,x) = (0,(1,2,3));
SECTION("tuple -> R^2")
{
std::string_view data = R"(
-let (t,x): R*R^2, (t,x) = (0,(1,2));
+let (t,x): R*R^2, (t,x) = (0,[1,2]);
)";
std::string result = R"(
@@ -307,7 +307,7 @@ let (t,x): R*R^2, (t,x) = (0,(1,2));
| `-(language::name:x:NameProcessor)
`-(language::expression_list:ASTNodeExpressionListProcessor)
+-(language::integer:0:ValueProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+-(language::integer:1:ValueProcessor)
`-(language::integer:2:ValueProcessor)
)";
@@ -466,15 +466,15 @@ a--;
SECTION("array subscript")
{
std::string_view data = R"(
-let x: R^3, x = (1, 2, 3);
+let x: R^3, x = [1, 2, 3];
let y: R, y = x[2];
)";
std::string result = R"(
(root:ASTNodeListProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
| +-(language::name:x:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
diff --git a/tests/test_ASTNodeFunctionExpressionBuilder.cpp b/tests/test_ASTNodeFunctionExpressionBuilder.cpp
index 4bf775a679490306efecc2617547cb424c6a256b..3429ed5bb152725ee667a96247623628284c1159 100644
--- a/tests/test_ASTNodeFunctionExpressionBuilder.cpp
+++ b/tests/test_ASTNodeFunctionExpressionBuilder.cpp
@@ -492,13 +492,13 @@ f(1);
SECTION("Return tuple -> R^2")
{
std::string_view data = R"(
-let f : R*R -> R^2, (x,y) -> (x,y);
+let f : R*R -> R^2, (x,y) -> [x,y];
f(1,2);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::function_evaluation:TupleToTinyVectorProcessor<FunctionProcessor, 2ul>)
+ `-(language::function_evaluation:FunctionProcessor)
+-(language::name:f:NameProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::integer:1:ValueProcessor)
@@ -511,13 +511,13 @@ f(1,2);
SECTION("Return tuple -> R^3")
{
std::string_view data = R"(
-let f : R*R*R -> R^3, (x,y,z) -> (x,y,z);
+let f : R*R*R -> R^3, (x,y,z) -> [x,y,z];
f(1,2,3);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::function_evaluation:TupleToTinyVectorProcessor<FunctionProcessor, 3ul>)
+ `-(language::function_evaluation:FunctionProcessor)
+-(language::name:f:NameProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::integer:1:ValueProcessor)
@@ -548,13 +548,13 @@ f(1);
SECTION("Return tuple -> R^2x2")
{
std::string_view data = R"(
-let f : R*R*R*R -> R^2x2, (x,y,z,t) -> (x,y,z,t);
+let f : R*R*R*R -> R^2x2, (x,y,z,t) -> [[x,y],[z,t]];
f(1,2,3,4);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::function_evaluation:TupleToTinyMatrixProcessor<FunctionProcessor, 2ul>)
+ `-(language::function_evaluation:FunctionProcessor)
+-(language::name:f:NameProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::integer:1:ValueProcessor)
@@ -569,24 +569,24 @@ f(1,2,3,4);
SECTION("Return tuple -> R^3x3")
{
std::string_view data = R"(
-let f : R^3*R^3*R^3 -> R^3x3, (x,y,z) -> (x[0],x[1],x[2],y[0],y[1],y[2],z[0],z[1],z[2]);
-f((1,2,3),(4,5,6),(7,8,9));
+let f : R^3*R^3*R^3 -> R^3x3, (x,y,z) -> [[x[0],x[1],x[2]],[y[0],y[1],y[2]],[z[0],z[1],z[2]]];
+f([1,2,3],[4,5,6],[7,8,9]);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
- `-(language::function_evaluation:TupleToTinyMatrixProcessor<FunctionProcessor, 3ul>)
+ `-(language::function_evaluation:FunctionProcessor)
+-(language::name:f:NameProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
- +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
- +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:4:ValueProcessor)
| +-(language::integer:5:ValueProcessor)
| `-(language::integer:6:ValueProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+-(language::integer:7:ValueProcessor)
+-(language::integer:8:ValueProcessor)
`-(language::integer:9:ValueProcessor)
@@ -700,7 +700,7 @@ f(1);
SECTION("Return embedded R^d compound")
{
std::string_view data = R"(
-let f : R*R*R*R -> R*R^1*R^2*R^3, (x,y,z,t) -> (t, (x), (x,y), (x,y,z));
+let f : R*R*R*R -> R*R^1*R^2*R^3, (x,y,z,t) -> (t, [x], [x,y], [x,y,z]);
f(1,2,3,4);
)";
@@ -721,7 +721,7 @@ f(1,2,3,4);
SECTION("Return embedded R^dxd compound")
{
std::string_view data = R"(
-let f : R*R*R*R -> R*R^1x1*R^2x2*R^3x3, (x,y,z,t) -> (t, (x), (x,y,z,t), (x,y,z, x,x,x, t,t,t));
+let f : R*R*R*R -> R*R^1x1*R^2x2*R^3x3, (x,y,z,t) -> (t, [[x]], [[x,y],[z,t]], [[x,y,z], [x,x,x], [t,t,t]]);
f(1,2,3,4);
)";
@@ -742,7 +742,7 @@ f(1,2,3,4);
SECTION("Return embedded R^d compound with '0'")
{
std::string_view data = R"(
-let f : R*R*R*R -> R*R^1*R^2*R^3, (x,y,z,t) -> (t, 0, 0, (x,y,z));
+let f : R*R*R*R -> R*R^1*R^2*R^3, (x,y,z,t) -> (t, 0, 0, [x,y,z]);
f(1,2,3,4);
)";
@@ -763,7 +763,7 @@ f(1,2,3,4);
SECTION("Return embedded R^dxd compound with '0'")
{
std::string_view data = R"(
-let f : R*R*R*R -> R*R^1x1*R^2x2*R^3x3, (x,y,z,t) -> (t, 0, 0, (x, y, z, t, x, y, z, t, x));
+let f : R*R*R*R -> R*R^1x1*R^2x2*R^3x3, (x,y,z,t) -> (t, 0, 0, [[x, y, z], [t, x, y], [z, t, x]]);
f(1,2,3,4);
)";
@@ -887,14 +887,14 @@ f(0);
{
std::string_view data = R"(
let f: R^3 -> R, x -> x[0]+x[1]+x[2];
-f((1,2,3));
+f([1,2,3]);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:FunctionProcessor)
+-(language::name:f:NameProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+-(language::integer:1:ValueProcessor)
+-(language::integer:2:ValueProcessor)
`-(language::integer:3:ValueProcessor)
@@ -907,23 +907,26 @@ f((1,2,3));
{
std::string_view data = R"(
let f: R^3x3 -> R, x -> x[0,0]+x[0,1]+x[0,2];
-f((1,2,3,4,5,6,7,8,9));
+f([[1,2,3],[4,5,6],[7,8,9]]);
)";
std::string_view result = R"(
(root:ASTNodeListProcessor)
`-(language::function_evaluation:FunctionProcessor)
+-(language::name:f:NameProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
- +-(language::integer:1:ValueProcessor)
- +-(language::integer:2:ValueProcessor)
- +-(language::integer:3:ValueProcessor)
- +-(language::integer:4:ValueProcessor)
- +-(language::integer:5:ValueProcessor)
- +-(language::integer:6:ValueProcessor)
- +-(language::integer:7:ValueProcessor)
- +-(language::integer:8:ValueProcessor)
- `-(language::integer:9:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:4:ValueProcessor)
+ | +-(language::integer:5:ValueProcessor)
+ | `-(language::integer:6:ValueProcessor)
+ `-(language::row_expression:FakeProcessor)
+ +-(language::integer:7:ValueProcessor)
+ +-(language::integer:8:ValueProcessor)
+ `-(language::integer:9:ValueProcessor)
)";
CHECK_AST(data, result);
@@ -933,7 +936,7 @@ f((1,2,3,4,5,6,7,8,9));
{
std::string_view data = R"(
let f: R*R^3*R^2x2->R, (t,x,y) -> t*(x[0]+x[1]+x[2])*y[0,0]+y[1,1];
-f(2,(1,2,3),(2,3,-1,1.3));
+f(2,[1,2,3],[[2,3],[-1,1.3]]);
)";
std::string_view result = R"(
@@ -942,16 +945,18 @@ f(2,(1,2,3),(2,3,-1,1.3));
+-(language::name:f:NameProcessor)
`-(language::function_argument_list:ASTNodeExpressionListProcessor)
+-(language::integer:2:ValueProcessor)
- +-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
- `-(language::tuple_expression:TupleToVectorProcessor<ASTNodeExpressionListProcessor>)
- +-(language::integer:2:ValueProcessor)
- +-(language::integer:3:ValueProcessor)
- +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
- | `-(language::integer:1:ValueProcessor)
- `-(language::real:1.3:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::row_expression:FakeProcessor)
+ +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+ | `-(language::integer:1:ValueProcessor)
+ `-(language::real:1.3:ValueProcessor)
)";
CHECK_AST(data, result);
@@ -1114,52 +1119,44 @@ prev(3 + .24);
SECTION("arguments invalid tuple -> R^d conversion")
{
- SECTION("tuple[3] -> R^2")
+ SECTION("tuple[2] -> R^2")
{
std::string_view data = R"(
let f : R^2 -> R, x->x[0];
-f((1,2,3));
+f((1,2));
)";
- CHECK_EXPRESSION_BUILDER_THROWS_WITH(data,
- std::string{
- "incompatible dimensions in affectation: expecting 2, but provided 3"});
+ CHECK_EXPRESSION_BUILDER_THROWS_WITH(data, std::string{"cannot convert list to R^2"});
}
- SECTION("tuple[2] -> R^3")
+ SECTION("tuple[3] -> R^3")
{
std::string_view data = R"(
let f : R^3 -> R, x->x[0];
-f((1,2));
+f((1,2,3));
)";
- CHECK_EXPRESSION_BUILDER_THROWS_WITH(data,
- std::string{
- "incompatible dimensions in affectation: expecting 3, but provided 2"});
+ CHECK_EXPRESSION_BUILDER_THROWS_WITH(data, std::string{"cannot convert list to R^3"});
}
- SECTION("compound tuple[3] -> R^2")
+ SECTION("compound tuple[2] -> R^2")
{
std::string_view data = R"(
let f : R*R^2 -> R, (t,x)->x[0];
-f(1,(1,2,3));
+f(1,(1,2));
)";
- CHECK_EXPRESSION_BUILDER_THROWS_WITH(data,
- std::string{
- "incompatible dimensions in affectation: expecting 2, but provided 3"});
+ CHECK_EXPRESSION_BUILDER_THROWS_WITH(data, std::string{"cannot convert list to R^2"});
}
SECTION("compound tuple[2] -> R^3")
{
std::string_view data = R"(
let f : R^3*R^2 -> R, (x,y)->x[0]*y[1];
-f((1,2),(3,4));
+f((1,2,3),[3,4]);
)";
- CHECK_EXPRESSION_BUILDER_THROWS_WITH(data,
- std::string{
- "incompatible dimensions in affectation: expecting 3, but provided 2"});
+ CHECK_EXPRESSION_BUILDER_THROWS_WITH(data, std::string{"cannot convert list to R^3"});
}
SECTION("list instead of tuple -> R^3")
@@ -1176,7 +1173,7 @@ f(1,2,3);
{
std::string_view data = R"(
let f : R^3*R^2 -> R, (x,y) -> x[0]*x[1]-y[0];
-f((1,2,3),2,3);
+f([1,2,3],2,3);
)";
CHECK_EXPRESSION_BUILDER_THROWS_WITH(data, std::string{"bad number of arguments: expecting 2, provided 3"});
diff --git a/tests/test_ASTNodeListAffectationExpressionBuilder.cpp b/tests/test_ASTNodeListAffectationExpressionBuilder.cpp
index 8d495053e0d0e09b67c103a4f387ecf6afc018bf..02aa43085baca268485d48af950cfde2f3485846 100644
--- a/tests/test_ASTNodeListAffectationExpressionBuilder.cpp
+++ b/tests/test_ASTNodeListAffectationExpressionBuilder.cpp
@@ -189,8 +189,8 @@ let (r,b,z,m): R*R*R*R , (r,b,z,m) = (3.2, 1, 6, 2);
{
std::string_view data = R"(
let a:R^1, a = 0;
-let b:R^2, b = (1,2);
-let c:R^3, c = (1,2,3);
+let b:R^2, b = [1,2];
+let c:R^3, c = [1,2,3];
let (x1,x2,x3,x) : R^1*R^2*R^3*R,
(x1,x2,x3,x) = (a, b, c, 2);
)";
@@ -200,14 +200,14 @@ let (x1,x2,x3,x) : R^1*R^2*R^3*R,
+-(language::eq_op:AffectationFromZeroProcessor<TinyVector<1ul, double> >)
| +-(language::name:a:NameProcessor)
| `-(language::integer:0:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<2ul, double>, TinyVector<2ul, double> >)
| +-(language::name:b:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
| +-(language::integer:1:ValueProcessor)
| `-(language::integer:2:ValueProcessor)
- +-(language::eq_op:AffectationToTinyVectorFromListProcessor<language::eq_op, TinyVector<3ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyVector<3ul, double>, TinyVector<3ul, double> >)
| +-(language::name:c:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
| +-(language::integer:1:ValueProcessor)
| +-(language::integer:2:ValueProcessor)
| `-(language::integer:3:ValueProcessor)
@@ -231,8 +231,8 @@ let (x1,x2,x3,x) : R^1*R^2*R^3*R,
{
std::string_view data = R"(
let a:R^1x1, a = 0;
-let b:R^2x2, b = (1, 2, 3, 4);
-let c:R^3x3, c = (9, 8, 7, 6, 5, 4, 3, 2, 1);
+let b:R^2x2, b = [[1, 2], [3, 4]];
+let c:R^3x3, c = [[9, 8, 7], [6, 5, 4], [3, 2, 1]];
let (x1,x2,x3,x) : R^1x1*R^2x2*R^3x3*R,
(x1,x2,x3,x) = (a, b, c, 2);
)";
@@ -242,25 +242,30 @@ let (x1,x2,x3,x) : R^1x1*R^2x2*R^3x3*R,
+-(language::eq_op:AffectationProcessor<language::eq_op, TinyMatrix<1ul, 1ul, double>, long>)
| +-(language::name:a:NameProcessor)
| `-(language::integer:0:ValueProcessor)
- +-(language::eq_op:AffectationToTinyMatrixFromListProcessor<language::eq_op, TinyMatrix<2ul, 2ul, double> >)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyMatrix<2ul, 2ul, double>, TinyMatrix<2ul, 2ul, double> >)
| +-(language::name:b:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
- | +-(language::integer:1:ValueProcessor)
- | +-(language::integer:2:ValueProcessor)
- | +-(language::integer:3:ValueProcessor)
- | `-(language::integer:4:ValueProcessor)
- +-(language::eq_op:AffectationToTinyMatrixFromListProcessor<language::eq_op, TinyMatrix<3ul, 3ul, double> >)
+ | `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:1:ValueProcessor)
+ | | `-(language::integer:2:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, TinyMatrix<3ul, 3ul, double>, TinyMatrix<3ul, 3ul, double> >)
| +-(language::name:c:NameProcessor)
- | `-(language::expression_list:ASTNodeExpressionListProcessor)
- | +-(language::integer:9:ValueProcessor)
- | +-(language::integer:8:ValueProcessor)
- | +-(language::integer:7:ValueProcessor)
- | +-(language::integer:6:ValueProcessor)
- | +-(language::integer:5:ValueProcessor)
- | +-(language::integer:4:ValueProcessor)
- | +-(language::integer:3:ValueProcessor)
- | +-(language::integer:2:ValueProcessor)
- | `-(language::integer:1:ValueProcessor)
+ | `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:9:ValueProcessor)
+ | | +-(language::integer:8:ValueProcessor)
+ | | `-(language::integer:7:ValueProcessor)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:6:ValueProcessor)
+ | | +-(language::integer:5:ValueProcessor)
+ | | `-(language::integer:4:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:1:ValueProcessor)
`-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+-(language::name_list:FakeProcessor)
| +-(language::name:x1:NameProcessor)
@@ -325,6 +330,1019 @@ let (x1,x2,x3,x) : R^1x1*R^2x2*R^3x3*R, (x1,x2,x3,x) = (0, 0, 0, 0);
CHECK_AST(data, result);
}
+ SECTION("with tuples from lists")
+ {
+ std::string_view data = R"(
+let (x,n,s) : (R)*(N)*(string), (x,n,s) = ((1.2,3.4), (1,2,3), (2.1,4,3.3,17.2));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:x:NameProcessor)
+ | +-(language::name:n:NameProcessor)
+ | `-(language::name:s:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::real:1.2:ValueProcessor)
+ | `-(language::real:3.4:ValueProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::real:2.1:ValueProcessor)
+ +-(language::integer:4:ValueProcessor)
+ +-(language::real:3.3:ValueProcessor)
+ `-(language::real:17.2:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("with tuples from tuples")
+ {
+ SECTION("tuple of B")
+ {
+ std::string_view data = R"(
+let b:(B), b = (true, false);
+let (b1,b2,b3) : (B)*(B)*(B), (b1,b2,b3) = (b, false, (true, true, false));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ | +-(language::name:b:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::true_kw:ValueProcessor)
+ | `-(language::false_kw:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:b1:NameProcessor)
+ | +-(language::name:b2:NameProcessor)
+ | `-(language::name:b3:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:b:NameProcessor)
+ +-(language::false_kw:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::true_kw:ValueProcessor)
+ +-(language::true_kw:ValueProcessor)
+ `-(language::false_kw:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of N")
+ {
+ std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (n1,n2,n3,n4,n5,n6,n7,n8) : (N)*(N)*(N)*(N)*(N)*(N)*(N)*(N),
+ (n1,n2,n3,n4,n5,n6,n7,n8) = (b, n, z, false, 2, i1, (2, 3, 2), (i1, i2));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ | +-(language::name:b:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::true_kw:ValueProcessor)
+ | `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ | +-(language::name:n:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ | +-(language::name:z:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i1:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i2:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:n1:NameProcessor)
+ | +-(language::name:n2:NameProcessor)
+ | +-(language::name:n3:NameProcessor)
+ | +-(language::name:n4:NameProcessor)
+ | +-(language::name:n5:NameProcessor)
+ | +-(language::name:n6:NameProcessor)
+ | +-(language::name:n7:NameProcessor)
+ | `-(language::name:n8:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:b:NameProcessor)
+ +-(language::name:n:NameProcessor)
+ +-(language::name:z:NameProcessor)
+ +-(language::false_kw:ValueProcessor)
+ +-(language::integer:2:ValueProcessor)
+ +-(language::name:i1:NameProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::name:i1:NameProcessor)
+ `-(language::name:i2:NameProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of Z")
+ {
+ std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (z1,z2,z3,z4,z5,z6,z7,z8) : (Z)*(Z)*(Z)*(Z)*(Z)*(Z)*(Z)*(Z),
+ (z1,z2,z3,z4,z5,z6,z7,z8) = (b, n, z, false, 2, i1, (2, 3, 2), (i1, i2));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ | +-(language::name:b:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::true_kw:ValueProcessor)
+ | `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ | +-(language::name:n:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ | +-(language::name:z:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i1:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i2:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:z1:NameProcessor)
+ | +-(language::name:z2:NameProcessor)
+ | +-(language::name:z3:NameProcessor)
+ | +-(language::name:z4:NameProcessor)
+ | +-(language::name:z5:NameProcessor)
+ | +-(language::name:z6:NameProcessor)
+ | +-(language::name:z7:NameProcessor)
+ | `-(language::name:z8:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:b:NameProcessor)
+ +-(language::name:n:NameProcessor)
+ +-(language::name:z:NameProcessor)
+ +-(language::false_kw:ValueProcessor)
+ +-(language::integer:2:ValueProcessor)
+ +-(language::name:i1:NameProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::name:i1:NameProcessor)
+ `-(language::name:i2:NameProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of R")
+ {
+ std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let r:(R), r = (1.2, 3.3, 2.4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) : (R)*(R)*(R)*(R)*(R)*(R)*(R)*(R)*(R)*(R)*(R),
+ (r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11) = (b, n, z, r, true, 2, i1, 2.3, (2, 3, 2), (i1, i2), (2.2, 1.4));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ | +-(language::name:b:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::true_kw:ValueProcessor)
+ | `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ | +-(language::name:n:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ | +-(language::name:z:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<double>)
+ | +-(language::name:r:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::real:1.2:ValueProcessor)
+ | +-(language::real:3.3:ValueProcessor)
+ | `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i1:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i2:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:r1:NameProcessor)
+ | +-(language::name:r2:NameProcessor)
+ | +-(language::name:r3:NameProcessor)
+ | +-(language::name:r4:NameProcessor)
+ | +-(language::name:r5:NameProcessor)
+ | +-(language::name:r6:NameProcessor)
+ | +-(language::name:r7:NameProcessor)
+ | +-(language::name:r8:NameProcessor)
+ | +-(language::name:r9:NameProcessor)
+ | +-(language::name:r10:NameProcessor)
+ | `-(language::name:r11:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:b:NameProcessor)
+ +-(language::name:n:NameProcessor)
+ +-(language::name:z:NameProcessor)
+ +-(language::name:r:NameProcessor)
+ +-(language::true_kw:ValueProcessor)
+ +-(language::integer:2:ValueProcessor)
+ +-(language::name:i1:NameProcessor)
+ +-(language::real:2.3:ValueProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::name:i1:NameProcessor)
+ | `-(language::name:i2:NameProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::real:2.2:ValueProcessor)
+ `-(language::real:1.4:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of string")
+ {
+ std::string_view data = R"(
+import utils;
+
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let r:(R), r = (1.2, 3.3, 2.4);
+let s:(string), s = ("foo", "bar");
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13):
+ (string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string),
+ (s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13)
+ = (b, n, z, r, s, 2, i1, 2.3, "foobar", (2, 3, 2), (i1, i2), (2.2, 1.4), ("hello", "world"));
+
+let v1:(R^1), v1 = (2, [3], [5]);
+let v2:(R^2), v2 = ([2,3], [3,5]);
+let v3:(R^3), v3 = ([2,2,3], 0, [1,3,5]);
+let A1:(R^1x1), A1 = (2, [[3]]);
+let A2:(R^2x2), A2 = ([[2,3], [3,5]],0);
+let A3:(R^3x3), A3 = ([[2,2,3], [1,2,7], [1,3,5]], [[1,3,2], [6,3,5], [3,2,-1]]);
+let (t1,t2,t3,t4,t5,t6,t7,t8,t9,t10):
+ (string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string),
+ (t1,t2,t3,t4,t5,t6,t7,t8,t9,t10)
+ = (v1, v2, v3, A1, A2, A3, [[0]], [2,3], [[1,2],[3,4]], ([1,2,3], [2,3,1]));
+
+let (u1,u2,u3,u4): (string)*(string)*(string)*(string),
+ (u1,u2,u3,u4) = (true, [1], [1,2,3], [[1,2,3],[4,5,6],[7,8,9]]);
+)";
+
+ std::string result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ | +-(language::name:b:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::true_kw:ValueProcessor)
+ | `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ | +-(language::name:n:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ | +-(language::name:z:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<double>)
+ | +-(language::name:r:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::real:1.2:ValueProcessor)
+ | +-(language::real:3.3:ValueProcessor)
+ | `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<)" +
+ demangled_stdstring + R"( >)
+ | +-(language::name:s:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::literal:"foo":ValueProcessor)
+ | `-(language::literal:"bar":ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i1:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i2:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ | +-(language::name_list:FakeProcessor)
+ | | +-(language::name:s1:NameProcessor)
+ | | +-(language::name:s2:NameProcessor)
+ | | +-(language::name:s3:NameProcessor)
+ | | +-(language::name:s4:NameProcessor)
+ | | +-(language::name:s5:NameProcessor)
+ | | +-(language::name:s6:NameProcessor)
+ | | +-(language::name:s7:NameProcessor)
+ | | +-(language::name:s8:NameProcessor)
+ | | +-(language::name:s9:NameProcessor)
+ | | +-(language::name:s10:NameProcessor)
+ | | +-(language::name:s11:NameProcessor)
+ | | +-(language::name:s12:NameProcessor)
+ | | `-(language::name:s13:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::name:b:NameProcessor)
+ | +-(language::name:n:NameProcessor)
+ | +-(language::name:z:NameProcessor)
+ | +-(language::name:r:NameProcessor)
+ | +-(language::name:s:NameProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::name:i1:NameProcessor)
+ | +-(language::real:2.3:ValueProcessor)
+ | +-(language::literal:"foobar":ValueProcessor)
+ | +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | +-(language::integer:3:ValueProcessor)
+ | | `-(language::integer:2:ValueProcessor)
+ | +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | | +-(language::name:i1:NameProcessor)
+ | | `-(language::name:i2:NameProcessor)
+ | +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | | +-(language::real:2.2:ValueProcessor)
+ | | `-(language::real:1.4:ValueProcessor)
+ | `-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::literal:"hello":ValueProcessor)
+ | `-(language::literal:"world":ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<1ul, double> >)
+ | +-(language::name:v1:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ | | `-(language::integer:3:ValueProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ | `-(language::integer:5:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<2ul, double> >)
+ | +-(language::name:v2:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::integer:3:ValueProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:5:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<3ul, double> >)
+ | +-(language::name:v3:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | | +-(language::integer:2:ValueProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::integer:3:ValueProcessor)
+ | +-(language::integer:0:ValueProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:5:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<1ul, 1ul, double> >)
+ | +-(language::name:A1:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ | `-(language::row_expression:FakeProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<2ul, 2ul, double> >)
+ | +-(language::name:A2:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ | | +-(language::row_expression:FakeProcessor)
+ | | | +-(language::integer:2:ValueProcessor)
+ | | | `-(language::integer:3:ValueProcessor)
+ | | `-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:3:ValueProcessor)
+ | | `-(language::integer:5:ValueProcessor)
+ | `-(language::integer:0:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<3ul, 3ul, double> >)
+ | +-(language::name:A3:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ | | +-(language::row_expression:FakeProcessor)
+ | | | +-(language::integer:2:ValueProcessor)
+ | | | +-(language::integer:2:ValueProcessor)
+ | | | `-(language::integer:3:ValueProcessor)
+ | | +-(language::row_expression:FakeProcessor)
+ | | | +-(language::integer:1:ValueProcessor)
+ | | | +-(language::integer:2:ValueProcessor)
+ | | | `-(language::integer:7:ValueProcessor)
+ | | `-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:1:ValueProcessor)
+ | | +-(language::integer:3:ValueProcessor)
+ | | `-(language::integer:5:ValueProcessor)
+ | `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:1:ValueProcessor)
+ | | +-(language::integer:3:ValueProcessor)
+ | | `-(language::integer:2:ValueProcessor)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:6:ValueProcessor)
+ | | +-(language::integer:3:ValueProcessor)
+ | | `-(language::integer:5:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+ | `-(language::integer:1:ValueProcessor)
+ +-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ | +-(language::name_list:FakeProcessor)
+ | | +-(language::name:t1:NameProcessor)
+ | | +-(language::name:t2:NameProcessor)
+ | | +-(language::name:t3:NameProcessor)
+ | | +-(language::name:t4:NameProcessor)
+ | | +-(language::name:t5:NameProcessor)
+ | | +-(language::name:t6:NameProcessor)
+ | | +-(language::name:t7:NameProcessor)
+ | | +-(language::name:t8:NameProcessor)
+ | | +-(language::name:t9:NameProcessor)
+ | | `-(language::name:t10:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::name:v1:NameProcessor)
+ | +-(language::name:v2:NameProcessor)
+ | +-(language::name:v3:NameProcessor)
+ | +-(language::name:A1:NameProcessor)
+ | +-(language::name:A2:NameProcessor)
+ | +-(language::name:A3:NameProcessor)
+ | +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ | | `-(language::row_expression:FakeProcessor)
+ | | `-(language::integer:0:ValueProcessor)
+ | +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::integer:3:ValueProcessor)
+ | +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ | | +-(language::row_expression:FakeProcessor)
+ | | | +-(language::integer:1:ValueProcessor)
+ | | | `-(language::integer:2:ValueProcessor)
+ | | `-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:3:ValueProcessor)
+ | | `-(language::integer:4:ValueProcessor)
+ | `-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | | +-(language::integer:1:ValueProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::integer:3:ValueProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:1:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:u1:NameProcessor)
+ | +-(language::name:u2:NameProcessor)
+ | +-(language::name:u3:NameProcessor)
+ | `-(language::name:u4:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::true_kw:ValueProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ | `-(language::integer:1:ValueProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:4:ValueProcessor)
+ | +-(language::integer:5:ValueProcessor)
+ | `-(language::integer:6:ValueProcessor)
+ `-(language::row_expression:FakeProcessor)
+ +-(language::integer:7:ValueProcessor)
+ +-(language::integer:8:ValueProcessor)
+ `-(language::integer:9:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of R^1")
+ {
+ std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let r:(R), r = (1.2, 3.3, 2.4);
+let X:(R^1), X = (1.2, [3.3], 2.4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14) : (R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1)*(R^1),
+ (X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14) = (b, n, z, r, true, 2, i1, 2.3, [1.2], X, (2, 3, 2), (i1, i2), (2.2, 1.4), ([1], [2]));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ | +-(language::name:b:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::true_kw:ValueProcessor)
+ | `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ | +-(language::name:n:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ | +-(language::name:z:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<double>)
+ | +-(language::name:r:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::real:1.2:ValueProcessor)
+ | +-(language::real:3.3:ValueProcessor)
+ | `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<1ul, double> >)
+ | +-(language::name:X:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::real:1.2:ValueProcessor)
+ | +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ | | `-(language::real:3.3:ValueProcessor)
+ | `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i1:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i2:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:X1:NameProcessor)
+ | +-(language::name:X2:NameProcessor)
+ | +-(language::name:X3:NameProcessor)
+ | +-(language::name:X4:NameProcessor)
+ | +-(language::name:X5:NameProcessor)
+ | +-(language::name:X6:NameProcessor)
+ | +-(language::name:X7:NameProcessor)
+ | +-(language::name:X8:NameProcessor)
+ | +-(language::name:X9:NameProcessor)
+ | +-(language::name:X10:NameProcessor)
+ | +-(language::name:X11:NameProcessor)
+ | +-(language::name:X12:NameProcessor)
+ | +-(language::name:X13:NameProcessor)
+ | `-(language::name:X14:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:b:NameProcessor)
+ +-(language::name:n:NameProcessor)
+ +-(language::name:z:NameProcessor)
+ +-(language::name:r:NameProcessor)
+ +-(language::true_kw:ValueProcessor)
+ +-(language::integer:2:ValueProcessor)
+ +-(language::name:i1:NameProcessor)
+ +-(language::real:2.3:ValueProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ | `-(language::real:1.2:ValueProcessor)
+ +-(language::name:X:NameProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::name:i1:NameProcessor)
+ | `-(language::name:i2:NameProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::real:2.2:ValueProcessor)
+ | `-(language::real:1.4:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ | `-(language::integer:1:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ `-(language::integer:2:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of R^2")
+ {
+ std::string_view data = R"(
+let X:(R^2), X = ([1.2,2], 0, [2.4, 2]);
+let (X1,X2,X3) : (R^2)*(R^2)*(R^2), (X1,X2,X3) = (X, [1,2], ([0,2], [1,0]));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<2ul, double> >)
+ | +-(language::name:X:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | | +-(language::real:1.2:ValueProcessor)
+ | | `-(language::integer:2:ValueProcessor)
+ | +-(language::integer:0:ValueProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | +-(language::real:2.4:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:X1:NameProcessor)
+ | +-(language::name:X2:NameProcessor)
+ | `-(language::name:X3:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:X:NameProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | +-(language::integer:0:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ +-(language::integer:1:ValueProcessor)
+ `-(language::integer:0:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of R^3")
+ {
+ std::string_view data = R"(
+let X:(R^3), X = ([1.2,2,4.2], 0, [2.4, 1, 2]);
+let (X1,X2,X3) : (R^3)*(R^3)*(R^3), (X1,X2,X3) = (X, [2,1,4], ([0,2,1.2], [1,2.1,3.1]));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyVector<3ul, double> >)
+ | +-(language::name:X:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | | +-(language::real:1.2:ValueProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::real:4.2:ValueProcessor)
+ | +-(language::integer:0:ValueProcessor)
+ | `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | +-(language::real:2.4:ValueProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:X1:NameProcessor)
+ | +-(language::name:X2:NameProcessor)
+ | `-(language::name:X3:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:X:NameProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:4:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ | +-(language::integer:0:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::real:1.2:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ +-(language::integer:1:ValueProcessor)
+ +-(language::real:2.1:ValueProcessor)
+ `-(language::real:3.1:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of R^1x1")
+ {
+ std::string_view data = R"(
+let b:(B), b = (true, false);
+let n:(N), n = (2, 3, 2);
+let z:(Z), z = (1, 3, 4);
+let r:(R), r = (1.2, 3.3, 2.4);
+let A:(R^1x1), A = (1.2, [[3.3]], 2.4);
+let i1:N, i1 = 3;
+let i2:N, i2 = 3;
+let (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14) : (R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1),
+ (A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14) = (b, n, z, r, true, 2, i1, 2.3, [[1.2]], A, (2, 3, 2), (i1, i2), (2.2, 1.4), ([[1]], [[2]]));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<bool>)
+ | +-(language::name:b:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::true_kw:ValueProcessor)
+ | `-(language::false_kw:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<unsigned long>)
+ | +-(language::name:n:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<long>)
+ | +-(language::name:z:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<double>)
+ | +-(language::name:r:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::real:1.2:ValueProcessor)
+ | +-(language::real:3.3:ValueProcessor)
+ | `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<1ul, 1ul, double> >)
+ | +-(language::name:A:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::real:1.2:ValueProcessor)
+ | +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ | | `-(language::row_expression:FakeProcessor)
+ | | `-(language::real:3.3:ValueProcessor)
+ | `-(language::real:2.4:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i1:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, unsigned long, long>)
+ | +-(language::name:i2:NameProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:A1:NameProcessor)
+ | +-(language::name:A2:NameProcessor)
+ | +-(language::name:A3:NameProcessor)
+ | +-(language::name:A4:NameProcessor)
+ | +-(language::name:A5:NameProcessor)
+ | +-(language::name:A6:NameProcessor)
+ | +-(language::name:A7:NameProcessor)
+ | +-(language::name:A8:NameProcessor)
+ | +-(language::name:A9:NameProcessor)
+ | +-(language::name:A10:NameProcessor)
+ | +-(language::name:A11:NameProcessor)
+ | +-(language::name:A12:NameProcessor)
+ | +-(language::name:A13:NameProcessor)
+ | `-(language::name:A14:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:b:NameProcessor)
+ +-(language::name:n:NameProcessor)
+ +-(language::name:z:NameProcessor)
+ +-(language::name:r:NameProcessor)
+ +-(language::true_kw:ValueProcessor)
+ +-(language::integer:2:ValueProcessor)
+ +-(language::name:i1:NameProcessor)
+ +-(language::real:2.3:ValueProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ | `-(language::row_expression:FakeProcessor)
+ | `-(language::real:1.2:ValueProcessor)
+ +-(language::name:A:NameProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::name:i1:NameProcessor)
+ | `-(language::name:i2:NameProcessor)
+ +-(language::inner_expression_list:InnerListToVectorProcessor)
+ | +-(language::real:2.2:ValueProcessor)
+ | `-(language::real:1.4:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ | `-(language::row_expression:FakeProcessor)
+ | `-(language::integer:1:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ `-(language::row_expression:FakeProcessor)
+ `-(language::integer:2:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of embedded data")
+ {
+ std::string_view data = R"(
+let b: builtin_t, b = b;
+let tb: (builtin_t), tb = (b,b);
+let (tb1,tb2,tb3): (builtin_t)*(builtin_t)*(builtin_t), (tb1,tb2,tb3) = (b,tb, (b,b,b));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationProcessor<language::eq_op, EmbeddedData, EmbeddedData>)
+ | +-(language::name:b:NameProcessor)
+ | `-(language::name:b:NameProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<EmbeddedData>)
+ | +-(language::name:tb:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::name:b:NameProcessor)
+ | `-(language::name:b:NameProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:tb1:NameProcessor)
+ | +-(language::name:tb2:NameProcessor)
+ | `-(language::name:tb3:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:b:NameProcessor)
+ +-(language::name:tb:NameProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::name:b:NameProcessor)
+ +-(language::name:b:NameProcessor)
+ `-(language::name:b:NameProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+ }
+
+ SECTION("tuple of R^2x2")
+ {
+ std::string_view data = R"(
+let A:(R^2x2), A = ([[1.2,2],[2.1,1]], 0, [[1.4, 2],[2.4, 2]]);
+let (A1,A2,A3) : (R^2x2)*(R^2x2)*(R^2x2), (A1,A2,A3) = (A, [[1,2],[4,1]], ([[0,2], [1,0]], [[1.3,2], [3,1]]));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<2ul, 2ul, double> >)
+ | +-(language::name:A:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ | | +-(language::row_expression:FakeProcessor)
+ | | | +-(language::real:1.2:ValueProcessor)
+ | | | `-(language::integer:2:ValueProcessor)
+ | | `-(language::row_expression:FakeProcessor)
+ | | +-(language::real:2.1:ValueProcessor)
+ | | `-(language::integer:1:ValueProcessor)
+ | +-(language::integer:0:ValueProcessor)
+ | `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::real:1.4:ValueProcessor)
+ | | `-(language::integer:2:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::real:2.4:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:A1:NameProcessor)
+ | +-(language::name:A2:NameProcessor)
+ | `-(language::name:A3:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:A:NameProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:1:ValueProcessor)
+ | | `-(language::integer:2:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::integer:4:ValueProcessor)
+ | `-(language::integer:1:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:0:ValueProcessor)
+ | | `-(language::integer:2:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:0:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::real:1.3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ `-(language::row_expression:FakeProcessor)
+ +-(language::integer:3:ValueProcessor)
+ `-(language::integer:1:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("tuple of R^3x3")
+ {
+ std::string_view data = R"(
+let A:(R^3x3), A = ([[1.2,2,1],[2.1,1,3],[1.2,1.2,3.2]], 0, [[1.4, 2, 1],[2.4, 0, 2],[2.1, 0.1, 3.2]]);
+let (A1,A2,A3) : (R^3x3)*(R^3x3)*(R^3x3), (A1,A2,A3) = (A, [[1,2,3],[1.2,3.1,1.8],[2,4,1]], ([[0,2,1], [2,1,0], [0.2,1,3]], [[1.3,2,1], [0.3,3,1], [0.1,2,4.3]]));
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ +-(language::eq_op:AffectationToTupleFromListProcessor<TinyMatrix<3ul, 3ul, double> >)
+ | +-(language::name:A:NameProcessor)
+ | `-(language::expression_list:ASTNodeExpressionListProcessor)
+ | +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ | | +-(language::row_expression:FakeProcessor)
+ | | | +-(language::real:1.2:ValueProcessor)
+ | | | +-(language::integer:2:ValueProcessor)
+ | | | `-(language::integer:1:ValueProcessor)
+ | | +-(language::row_expression:FakeProcessor)
+ | | | +-(language::real:2.1:ValueProcessor)
+ | | | +-(language::integer:1:ValueProcessor)
+ | | | `-(language::integer:3:ValueProcessor)
+ | | `-(language::row_expression:FakeProcessor)
+ | | +-(language::real:1.2:ValueProcessor)
+ | | +-(language::real:1.2:ValueProcessor)
+ | | `-(language::real:3.2:ValueProcessor)
+ | +-(language::integer:0:ValueProcessor)
+ | `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::real:1.4:ValueProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::integer:1:ValueProcessor)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::real:2.4:ValueProcessor)
+ | | +-(language::integer:0:ValueProcessor)
+ | | `-(language::integer:2:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::real:2.1:ValueProcessor)
+ | +-(language::real:0.1:ValueProcessor)
+ | `-(language::real:3.2:ValueProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:A1:NameProcessor)
+ | +-(language::name:A2:NameProcessor)
+ | `-(language::name:A3:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::name:A:NameProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:1:ValueProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::integer:3:ValueProcessor)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::real:1.2:ValueProcessor)
+ | | +-(language::real:3.1:ValueProcessor)
+ | | `-(language::real:1.8:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:4:ValueProcessor)
+ | `-(language::integer:1:ValueProcessor)
+ `-(language::inner_expression_list:InnerListToVectorProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:0:ValueProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | `-(language::integer:1:ValueProcessor)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:2:ValueProcessor)
+ | | +-(language::integer:1:ValueProcessor)
+ | | `-(language::integer:0:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::real:0.2:ValueProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::real:1.3:ValueProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | `-(language::integer:1:ValueProcessor)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::real:0.3:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:1:ValueProcessor)
+ `-(language::row_expression:FakeProcessor)
+ +-(language::real:0.1:ValueProcessor)
+ +-(language::integer:2:ValueProcessor)
+ `-(language::real:4.3:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
SECTION("from function")
{
std::string_view data = R"(
@@ -366,10 +1384,10 @@ let (s,r): string*string, (s,r) = ("foo","bar");
CHECK_AST(data, result);
}
- SECTION("string with conversion")
+ SECTION("string with scalar conversions")
{
std::string_view data = R"(
-let n:N, n =2;
+let n:N, n = 2;
let (r,s,t,u) : string*string*string*string,
(r,s,t,u) = (3.2, -2, true, n);
)";
@@ -396,6 +1414,80 @@ let (r,s,t,u) : string*string*string*string,
CHECK_AST(data, result);
}
+ SECTION("string with vector conversions")
+ {
+ std::string_view data = R"(
+let (r,s,t) : string*string*string,
+ (r,s,t) = ([3.2], [-2, 3], [1,3,2]);
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:r:NameProcessor)
+ | +-(language::name:s:NameProcessor)
+ | `-(language::name:t:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<1ul>)
+ | `-(language::real:3.2:ValueProcessor)
+ +-(language::vector_expression:TinyVectorExpressionProcessor<2ul>)
+ | +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+ | | `-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::vector_expression:TinyVectorExpressionProcessor<3ul>)
+ +-(language::integer:1:ValueProcessor)
+ +-(language::integer:3:ValueProcessor)
+ `-(language::integer:2:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
+ SECTION("string with matrix conversions")
+ {
+ std::string_view data = R"(
+let (r,s,t) : string*string*string,
+ (r,s,t) = ([[3.2]], [[1, 2],[-2, 3]], [[1,3,2],[2,1,3],[4,1,2]]);
+)";
+
+ std::string_view result = R"(
+(root:ASTNodeListProcessor)
+ `-(language::eq_op:ListAffectationProcessor<language::eq_op>)
+ +-(language::name_list:FakeProcessor)
+ | +-(language::name:r:NameProcessor)
+ | +-(language::name:s:NameProcessor)
+ | `-(language::name:t:NameProcessor)
+ `-(language::expression_list:ASTNodeExpressionListProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<1ul, 1ul>)
+ | `-(language::row_expression:FakeProcessor)
+ | `-(language::real:3.2:ValueProcessor)
+ +-(language::matrix_expression:TinyMatrixExpressionProcessor<2ul, 2ul>)
+ | +-(language::row_expression:FakeProcessor)
+ | | +-(language::integer:1:ValueProcessor)
+ | | `-(language::integer:2:ValueProcessor)
+ | `-(language::row_expression:FakeProcessor)
+ | +-(language::unary_minus:UnaryExpressionProcessor<language::unary_minus, long, long>)
+ | | `-(language::integer:2:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::matrix_expression:TinyMatrixExpressionProcessor<3ul, 3ul>)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | +-(language::integer:3:ValueProcessor)
+ | `-(language::integer:2:ValueProcessor)
+ +-(language::row_expression:FakeProcessor)
+ | +-(language::integer:2:ValueProcessor)
+ | +-(language::integer:1:ValueProcessor)
+ | `-(language::integer:3:ValueProcessor)
+ `-(language::row_expression:FakeProcessor)
+ +-(language::integer:4:ValueProcessor)
+ +-(language::integer:1:ValueProcessor)
+ `-(language::integer:2:ValueProcessor)
+)";
+
+ CHECK_AST(data, result);
+ }
+
SECTION("embedded data")
{
std::string_view data = R"(
@@ -503,7 +1595,7 @@ let x:R;
SECTION("invalid R^n -> R^m conversion")
{
std::string_view data = R"(
-let x:R^2, x = (1,2);
+let x:R^2, x = [1,2];
let y:R^3, y = x;
)";
diff --git a/tests/test_ASTNodeNaturalConversionChecker.cpp b/tests/test_ASTNodeNaturalConversionChecker.cpp
index 6852222ae307f2cdac86463ecc2b59fde4536618..7823664a1319f7699c3264805ac4c4fb68085e4a 100644
--- a/tests/test_ASTNodeNaturalConversionChecker.cpp
+++ b/tests/test_ASTNodeNaturalConversionChecker.cpp
@@ -94,19 +94,6 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1, 1)});
}
- SECTION("list -> R^1x1")
- {
- data_node->m_data_type =
- ASTNodeDataType::build<ASTNodeDataType::list_t>({std::make_shared<const ASTNodeDataType>(double_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
- }
- REQUIRE_NOTHROW(
- ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1, 1)});
- }
-
SECTION("'0' -> R^dxd")
{
data_node->m_data_type = int_dt;
@@ -140,88 +127,12 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2, 2)});
}
- SECTION("list -> R^2x2")
- {
- data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::list_t>(
- {std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
- std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
- std::make_shared<const ASTNodeDataType>(unsigned_int_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
-
- std::unique_ptr list1_node = std::make_unique<ASTNode>();
- list1_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list1_node));
-
- std::unique_ptr list2_node = std::make_unique<ASTNode>();
- list2_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list2_node));
-
- std::unique_ptr list3_node = std::make_unique<ASTNode>();
- list3_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list3_node));
- }
- REQUIRE_NOTHROW(
- ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2, 2)});
- }
-
SECTION("R^3x3 -> R^3x3")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3, 3);
REQUIRE_NOTHROW(
ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3, 3)});
}
-
- SECTION("list -> R^3x3")
- {
- data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::list_t>(
- {std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
- std::make_shared<const ASTNodeDataType>(int_dt), std::make_shared<const ASTNodeDataType>(double_dt),
- std::make_shared<const ASTNodeDataType>(unsigned_int_dt), std::make_shared<const ASTNodeDataType>(int_dt),
- std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
- std::make_shared<const ASTNodeDataType>(int_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
-
- std::unique_ptr list1_node = std::make_unique<ASTNode>();
- list1_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list1_node));
-
- std::unique_ptr list2_node = std::make_unique<ASTNode>();
- list2_node->m_data_type = int_dt;
- data_node->emplace_back(std::move(list2_node));
-
- std::unique_ptr list3_node = std::make_unique<ASTNode>();
- list3_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list3_node));
-
- std::unique_ptr list4_node = std::make_unique<ASTNode>();
- list4_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list4_node));
-
- std::unique_ptr list5_node = std::make_unique<ASTNode>();
- list5_node->m_data_type = int_dt;
- data_node->emplace_back(std::move(list5_node));
-
- std::unique_ptr list6_node = std::make_unique<ASTNode>();
- list6_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list6_node));
-
- std::unique_ptr list7_node = std::make_unique<ASTNode>();
- list7_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list7_node));
-
- std::unique_ptr list8_node = std::make_unique<ASTNode>();
- list8_node->m_data_type = int_dt;
- data_node->emplace_back(std::move(list8_node));
- }
- REQUIRE_NOTHROW(
- ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3, 3)});
- }
}
SECTION("-> R^d")
@@ -233,19 +144,6 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::vector_t>(1)});
}
- SECTION("list -> R^1")
- {
- data_node->m_data_type =
- ASTNodeDataType::build<ASTNodeDataType::list_t>({std::make_shared<const ASTNodeDataType>(double_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
- }
- REQUIRE_NOTHROW(
- ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::vector_t>(1)});
- }
-
SECTION("'0' -> R^d")
{
data_node->m_data_type = int_dt;
@@ -279,52 +177,12 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::vector_t>(2)});
}
- SECTION("list -> R^2")
- {
- data_node->m_data_type =
- ASTNodeDataType::build<ASTNodeDataType::list_t>({std::make_shared<const ASTNodeDataType>(double_dt),
- std::make_shared<const ASTNodeDataType>(unsigned_int_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
-
- std::unique_ptr list1_node = std::make_unique<ASTNode>();
- list1_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list1_node));
- }
- REQUIRE_NOTHROW(
- ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::vector_t>(2)});
- }
-
SECTION("R^3 -> R^3")
{
data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::vector_t>(3);
REQUIRE_NOTHROW(
ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::vector_t>(3)});
}
-
- SECTION("list -> R^3")
- {
- data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::list_t>(
- {std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
- std::make_shared<const ASTNodeDataType>(int_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
-
- std::unique_ptr list1_node = std::make_unique<ASTNode>();
- list1_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list1_node));
-
- std::unique_ptr list2_node = std::make_unique<ASTNode>();
- list2_node->m_data_type = int_dt;
- data_node->emplace_back(std::move(list2_node));
- }
- REQUIRE_NOTHROW(
- ASTNodeNaturalConversionChecker{*data_node, ASTNodeDataType::build<ASTNodeDataType::vector_t>(3)});
- }
}
SECTION("-> R")
@@ -908,99 +766,6 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
"invalid implicit conversion: R^2x2 -> R^3x3");
}
- SECTION("list1 -> R^dxd")
- {
- data_node->m_data_type =
- ASTNodeDataType::build<ASTNodeDataType::list_t>({std::make_shared<const ASTNodeDataType>(double_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
- }
-
- SECTION("d=2")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2,
- 2)}),
- "incompatible dimensions in affectation: expecting 4, but provided 1");
- }
-
- SECTION("d=3")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3,
- 3)}),
- "incompatible dimensions in affectation: expecting 9, but provided 1");
- }
- }
-
- SECTION("list2 -> R^dxd")
- {
- data_node->m_data_type = list_dt;
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
-
- std::unique_ptr list1_node = std::make_unique<ASTNode>();
- list1_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list1_node));
- }
-
- SECTION("d=1")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1,
- 1)}),
- "incompatible dimensions in affectation: expecting 1, but provided 2");
- }
-
- SECTION("d=3")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3,
- 3)}),
- "incompatible dimensions in affectation: expecting 9, but provided 2");
- }
- }
-
- SECTION("list3 -> R^dxd")
- {
- data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::list_t>(
- {std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
- std::make_shared<const ASTNodeDataType>(int_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
-
- std::unique_ptr list1_node = std::make_unique<ASTNode>();
- list1_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list1_node));
-
- std::unique_ptr list2_node = std::make_unique<ASTNode>();
- list2_node->m_data_type = int_dt;
- data_node->emplace_back(std::move(list2_node));
- }
-
- SECTION("d=1")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1,
- 1)}),
- "incompatible dimensions in affectation: expecting 1, but provided 3");
- }
-
- SECTION("d=2")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2,
- 2)}),
- "incompatible dimensions in affectation: expecting 4, but provided 3");
- }
- }
-
SECTION("tuple -> R^dxd")
{
SECTION("tuple(N) -> R^1x1")
@@ -1273,6 +1038,98 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
"invalid implicit conversion: string -> R^3x3");
}
}
+
+ SECTION("invalid list -> R^1x1")
+ {
+ data_node->m_data_type =
+ ASTNodeDataType::build<ASTNodeDataType::list_t>({std::make_shared<const ASTNodeDataType>(double_dt)});
+ {
+ std::unique_ptr list0_node = std::make_unique<ASTNode>();
+ list0_node->m_data_type = double_dt;
+ data_node->emplace_back(std::move(list0_node));
+ }
+ REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+ ASTNodeDataType::build<ASTNodeDataType::matrix_t>(1, 1)}),
+ "cannot convert list to R^1x1");
+ }
+
+ SECTION("invalid list -> R^2x2")
+ {
+ data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::list_t>(
+ {std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
+ std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
+ std::make_shared<const ASTNodeDataType>(unsigned_int_dt)});
+ {
+ std::unique_ptr list0_node = std::make_unique<ASTNode>();
+ list0_node->m_data_type = double_dt;
+ data_node->emplace_back(std::move(list0_node));
+
+ std::unique_ptr list1_node = std::make_unique<ASTNode>();
+ list1_node->m_data_type = unsigned_int_dt;
+ data_node->emplace_back(std::move(list1_node));
+
+ std::unique_ptr list2_node = std::make_unique<ASTNode>();
+ list2_node->m_data_type = unsigned_int_dt;
+ data_node->emplace_back(std::move(list2_node));
+
+ std::unique_ptr list3_node = std::make_unique<ASTNode>();
+ list3_node->m_data_type = unsigned_int_dt;
+ data_node->emplace_back(std::move(list3_node));
+ }
+ REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+ ASTNodeDataType::build<ASTNodeDataType::matrix_t>(2, 2)}),
+ "cannot convert list to R^2x2");
+ }
+
+ SECTION("invalid list -> R^3x3")
+ {
+ data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::list_t>(
+ {std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
+ std::make_shared<const ASTNodeDataType>(int_dt), std::make_shared<const ASTNodeDataType>(double_dt),
+ std::make_shared<const ASTNodeDataType>(unsigned_int_dt), std::make_shared<const ASTNodeDataType>(int_dt),
+ std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
+ std::make_shared<const ASTNodeDataType>(int_dt)});
+ {
+ std::unique_ptr list0_node = std::make_unique<ASTNode>();
+ list0_node->m_data_type = double_dt;
+ data_node->emplace_back(std::move(list0_node));
+
+ std::unique_ptr list1_node = std::make_unique<ASTNode>();
+ list1_node->m_data_type = unsigned_int_dt;
+ data_node->emplace_back(std::move(list1_node));
+
+ std::unique_ptr list2_node = std::make_unique<ASTNode>();
+ list2_node->m_data_type = int_dt;
+ data_node->emplace_back(std::move(list2_node));
+
+ std::unique_ptr list3_node = std::make_unique<ASTNode>();
+ list3_node->m_data_type = double_dt;
+ data_node->emplace_back(std::move(list3_node));
+
+ std::unique_ptr list4_node = std::make_unique<ASTNode>();
+ list4_node->m_data_type = unsigned_int_dt;
+ data_node->emplace_back(std::move(list4_node));
+
+ std::unique_ptr list5_node = std::make_unique<ASTNode>();
+ list5_node->m_data_type = int_dt;
+ data_node->emplace_back(std::move(list5_node));
+
+ std::unique_ptr list6_node = std::make_unique<ASTNode>();
+ list6_node->m_data_type = double_dt;
+ data_node->emplace_back(std::move(list6_node));
+
+ std::unique_ptr list7_node = std::make_unique<ASTNode>();
+ list7_node->m_data_type = unsigned_int_dt;
+ data_node->emplace_back(std::move(list7_node));
+
+ std::unique_ptr list8_node = std::make_unique<ASTNode>();
+ list8_node->m_data_type = int_dt;
+ data_node->emplace_back(std::move(list8_node));
+ }
+ REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+ ASTNodeDataType::build<ASTNodeDataType::matrix_t>(3, 3)}),
+ "cannot convert list to R^3x3");
+ }
}
SECTION("-> R^d")
@@ -1325,93 +1182,6 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
"invalid implicit conversion: R^2 -> R^3");
}
- SECTION("list1 -> R^d")
- {
- data_node->m_data_type =
- ASTNodeDataType::build<ASTNodeDataType::list_t>({std::make_shared<const ASTNodeDataType>(double_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
- }
-
- SECTION("d=2")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::vector_t>(2)}),
- "incompatible dimensions in affectation: expecting 2, but provided 1");
- }
-
- SECTION("d=3")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::vector_t>(3)}),
- "incompatible dimensions in affectation: expecting 3, but provided 1");
- }
- }
-
- SECTION("list2 -> R^d")
- {
- data_node->m_data_type = list_dt;
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
-
- std::unique_ptr list1_node = std::make_unique<ASTNode>();
- list1_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list1_node));
- }
-
- SECTION("d=1")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::vector_t>(1)}),
- "incompatible dimensions in affectation: expecting 1, but provided 2");
- }
-
- SECTION("d=3")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::vector_t>(3)}),
- "incompatible dimensions in affectation: expecting 3, but provided 2");
- }
- }
-
- SECTION("list3 -> R^d")
- {
- data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::list_t>(
- {std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
- std::make_shared<const ASTNodeDataType>(int_dt)});
- {
- std::unique_ptr list0_node = std::make_unique<ASTNode>();
- list0_node->m_data_type = double_dt;
- data_node->emplace_back(std::move(list0_node));
-
- std::unique_ptr list1_node = std::make_unique<ASTNode>();
- list1_node->m_data_type = unsigned_int_dt;
- data_node->emplace_back(std::move(list1_node));
-
- std::unique_ptr list2_node = std::make_unique<ASTNode>();
- list2_node->m_data_type = int_dt;
- data_node->emplace_back(std::move(list2_node));
- }
-
- SECTION("d=1")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::vector_t>(1)}),
- "incompatible dimensions in affectation: expecting 1, but provided 3");
- }
-
- SECTION("d=2")
- {
- REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
- ASTNodeDataType::build<ASTNodeDataType::vector_t>(2)}),
- "incompatible dimensions in affectation: expecting 2, but provided 3");
- }
- }
-
SECTION("tuple -> R^d")
{
SECTION("tuple(N) -> R^1")
@@ -1714,6 +1484,62 @@ TEST_CASE("ASTNodeNaturalConversionChecker", "[language]")
"invalid implicit conversion: string -> R^3");
}
}
+
+ SECTION("invalid list -> R^1")
+ {
+ data_node->m_data_type =
+ ASTNodeDataType::build<ASTNodeDataType::list_t>({std::make_shared<const ASTNodeDataType>(double_dt)});
+ {
+ std::unique_ptr list0_node = std::make_unique<ASTNode>();
+ list0_node->m_data_type = double_dt;
+ data_node->emplace_back(std::move(list0_node));
+ }
+ REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+ ASTNodeDataType::build<ASTNodeDataType::vector_t>(1)}),
+ "cannot convert list to R^1");
+ }
+
+ SECTION("invalid list -> R^2")
+ {
+ data_node->m_data_type =
+ ASTNodeDataType::build<ASTNodeDataType::list_t>({std::make_shared<const ASTNodeDataType>(double_dt),
+ std::make_shared<const ASTNodeDataType>(unsigned_int_dt)});
+ {
+ std::unique_ptr list0_node = std::make_unique<ASTNode>();
+ list0_node->m_data_type = double_dt;
+ data_node->emplace_back(std::move(list0_node));
+
+ std::unique_ptr list1_node = std::make_unique<ASTNode>();
+ list1_node->m_data_type = unsigned_int_dt;
+ data_node->emplace_back(std::move(list1_node));
+ }
+ REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+ ASTNodeDataType::build<ASTNodeDataType::vector_t>(2)}),
+ "cannot convert list to R^2");
+ }
+
+ SECTION("invalid list -> R^3")
+ {
+ data_node->m_data_type = ASTNodeDataType::build<ASTNodeDataType::list_t>(
+ {std::make_shared<const ASTNodeDataType>(double_dt), std::make_shared<const ASTNodeDataType>(unsigned_int_dt),
+ std::make_shared<const ASTNodeDataType>(int_dt)});
+ {
+ std::unique_ptr list0_node = std::make_unique<ASTNode>();
+ list0_node->m_data_type = double_dt;
+ data_node->emplace_back(std::move(list0_node));
+
+ std::unique_ptr list1_node = std::make_unique<ASTNode>();
+ list1_node->m_data_type = unsigned_int_dt;
+ data_node->emplace_back(std::move(list1_node));
+
+ std::unique_ptr list2_node = std::make_unique<ASTNode>();
+ list2_node->m_data_type = int_dt;
+ data_node->emplace_back(std::move(list2_node));
+ }
+ REQUIRE_THROWS_WITH((ASTNodeNaturalConversionChecker{*data_node,
+ ASTNodeDataType::build<ASTNodeDataType::vector_t>(3)}),
+ "cannot convert list to R^3");
+ }
}
SECTION("-> R")
diff --git a/tests/test_AffectationProcessor.cpp b/tests/test_AffectationProcessor.cpp
index 42c0514f963d5c452558bf6a8676c8d69395658d..2f8c4bb92067614fe1eb62d527fc1656301c2d87 100644
--- a/tests/test_AffectationProcessor.cpp
+++ b/tests/test_AffectationProcessor.cpp
@@ -108,21 +108,25 @@ TEST_CASE("AffectationProcessor", "[language]")
CHECK_AFFECTATION_RESULT("let x : R^1, x = true;", "x", (TinyVector<1>{true}));
CHECK_AFFECTATION_RESULT("let x : R^1, x = false;", "x", (TinyVector<1>{false}));
CHECK_AFFECTATION_RESULT("let x : R^1, x = -2.3;", "x", (TinyVector<1>{-2.3}));
+ CHECK_AFFECTATION_RESULT("let x : R^1, x = [-1];", "x", (TinyVector<1>{-1}));
+ CHECK_AFFECTATION_RESULT("let x : R^1, x = [true];", "x", (TinyVector<1>{true}));
+ CHECK_AFFECTATION_RESULT("let x : R^1, x = [false];", "x", (TinyVector<1>{false}));
+ CHECK_AFFECTATION_RESULT("let x : R^1, x = [-2.3];", "x", (TinyVector<1>{-2.3}));
CHECK_AFFECTATION_RESULT("let x : R^1, x = 0;", "x", (TinyVector<1>{zero}));
}
SECTION("R^2")
{
- CHECK_AFFECTATION_RESULT("let x : R^2, x = (-1, true);", "x", (TinyVector<2>{-1, true}));
- CHECK_AFFECTATION_RESULT("let x : R^2, x = (true, false);", "x", (TinyVector<2>{true, false}));
- CHECK_AFFECTATION_RESULT("let x : R^2, x = (-0.3, 12);", "x", (TinyVector<2>{-0.3, 12}));
+ CHECK_AFFECTATION_RESULT("let x : R^2, x = [-1, true];", "x", (TinyVector<2>{-1, true}));
+ CHECK_AFFECTATION_RESULT("let x : R^2, x = [true, false];", "x", (TinyVector<2>{true, false}));
+ CHECK_AFFECTATION_RESULT("let x : R^2, x = [-0.3, 12];", "x", (TinyVector<2>{-0.3, 12}));
CHECK_AFFECTATION_RESULT("let x : R^2, x = 0;", "x", (TinyVector<2>{zero}));
}
SECTION("R^3")
{
- CHECK_AFFECTATION_RESULT("let x : R^3, x = (-1, true, false);", "x", (TinyVector<3>{-1, true, false}));
- CHECK_AFFECTATION_RESULT("let x : R^3, x = (-0.3, 12, 6.2);", "x", (TinyVector<3>{-0.3, 12, 6.2}));
+ CHECK_AFFECTATION_RESULT("let x : R^3, x = [-1, true, false];", "x", (TinyVector<3>{-1, true, false}));
+ CHECK_AFFECTATION_RESULT("let x : R^3, x = [-0.3, 12, 6.2];", "x", (TinyVector<3>{-0.3, 12, 6.2}));
CHECK_AFFECTATION_RESULT("let x : R^3; x = 0;", "x", (TinyVector<3>{zero}));
}
@@ -132,23 +136,27 @@ TEST_CASE("AffectationProcessor", "[language]")
CHECK_AFFECTATION_RESULT("let x : R^1x1, x = true;", "x", (TinyMatrix<1>{true}));
CHECK_AFFECTATION_RESULT("let x : R^1x1, x = false;", "x", (TinyMatrix<1>{false}));
CHECK_AFFECTATION_RESULT("let x : R^1x1, x = -2.3;", "x", (TinyMatrix<1>{-2.3}));
+ CHECK_AFFECTATION_RESULT("let x : R^1x1, x = [[-1]];", "x", (TinyMatrix<1>{-1}));
+ CHECK_AFFECTATION_RESULT("let x : R^1x1, x = [[true]];", "x", (TinyMatrix<1>{true}));
+ CHECK_AFFECTATION_RESULT("let x : R^1x1, x = [[false]];", "x", (TinyMatrix<1>{false}));
+ CHECK_AFFECTATION_RESULT("let x : R^1x1, x = [[-2.3]];", "x", (TinyMatrix<1>{-2.3}));
CHECK_AFFECTATION_RESULT("let x : R^1x1; x = 0;", "x", (TinyMatrix<1>{zero}));
}
SECTION("R^2x2")
{
- CHECK_AFFECTATION_RESULT("let x : R^2x2, x = (-1, true, 3, 5);", "x", (TinyMatrix<2>{-1, true, 3, 5}));
- CHECK_AFFECTATION_RESULT("let x : R^2x2, x = (true, false, 1==2, 2==2);", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^2x2, x = [[-1, true], [3, 5]];", "x", (TinyMatrix<2>{-1, true, 3, 5}));
+ CHECK_AFFECTATION_RESULT("let x : R^2x2, x = [[true, false], [1==2, 2==2]];", "x",
(TinyMatrix<2>{true, false, false, true}));
- CHECK_AFFECTATION_RESULT("let x : R^2x2, x = (-0.3, 12, 2, -3);", "x", (TinyMatrix<2>{-0.3, 12, 2, -3}));
+ CHECK_AFFECTATION_RESULT("let x : R^2x2, x = [[-0.3, 12],[2, -3]];", "x", (TinyMatrix<2>{-0.3, 12, 2, -3}));
CHECK_AFFECTATION_RESULT("let x : R^2x2, x = 0;", "x", (TinyMatrix<2>{zero}));
}
SECTION("R^3x3")
{
- CHECK_AFFECTATION_RESULT("let x : R^3x3, x = (-1, true, false, 2, 3.1, 4, -1, true, 2);", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^3x3, x = [[-1, true, false], [2, 3.1, 4], [-1, true, 2]];", "x",
(TinyMatrix<3>{-1, true, false, 2, 3.1, 4, -1, true, 2}));
- CHECK_AFFECTATION_RESULT("let x : R^3x3, x = (-0.3, 12, 6.2, 7.1, 3.2, 2-3, 2, -1, 0);", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^3x3, x = [[-0.3, 12, 6.2], [7.1, 3.2, 2-3], [2, -1, 0]];", "x",
(TinyMatrix<3>{-0.3, 12, 6.2, 7.1, 3.2, 2 - 3, 2, -1, 0}));
CHECK_AFFECTATION_RESULT("let x : R^3x3, x = 0;", "x", (TinyMatrix<3>{zero}));
}
@@ -189,13 +197,13 @@ TEST_CASE("AffectationProcessor", "[language]")
SECTION("R^2")
{
- CHECK_AFFECTATION_RESULT("let x : R^2, x = (-1, true); let y : R^2, y = (1,3); x += y;", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^2, x = [-1, true]; x += [1,3];", "x",
(TinyVector<2>{-1, true} + TinyVector<2>{1, 3}));
}
SECTION("R^3")
{
- CHECK_AFFECTATION_RESULT("let x : R^3, x = (-1, true, false); let y : R^3, y = (1,2,3); x += y;", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^3, x = [-1, true, false]; x += [1,2,3];", "x",
(TinyVector<3>{-1, true, false} + TinyVector<3>{1, 2, 3}));
}
}
@@ -229,19 +237,18 @@ TEST_CASE("AffectationProcessor", "[language]")
SECTION("R^1")
{
- CHECK_AFFECTATION_RESULT("let x : R^1, x = -1; let y : R^1, y = 1; x -= y;", "x",
- (TinyVector<1>{-1} - TinyVector<1>{1}));
+ CHECK_AFFECTATION_RESULT("let x : R^1, x = [-1]; x -= [1];", "x", (TinyVector<1>{-1} - TinyVector<1>{1}));
}
SECTION("R^2")
{
- CHECK_AFFECTATION_RESULT("let x : R^2, x = (-1, true); let y : R^2, y = (1,3); x -= y;", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^2, x = [-1, true]; x -= [1,3];", "x",
(TinyVector<2>{-1, true} - TinyVector<2>{1, 3}));
}
SECTION("R^3")
{
- CHECK_AFFECTATION_RESULT("let x : R^3, x = (-1, true, false); let y : R^3, y = (1,2,3); x-=y;", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^3, x = [-1, true, false]; x-=[1,2,3];", "x",
(TinyVector<3>{-1, true, false} - TinyVector<3>{1, 2, 3}));
}
}
@@ -280,13 +287,13 @@ TEST_CASE("AffectationProcessor", "[language]")
SECTION("R^2")
{
- CHECK_AFFECTATION_RESULT("let x : R^2, x = (-1, true); x *= 3;", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^2, x = [-1, true]; x *= 3;", "x",
(TinyVector<2>{TinyVector<2>{-1, true} *= 3}));
}
SECTION("R^3")
{
- CHECK_AFFECTATION_RESULT("let x : R^3, x = (-1, true, false); x*=5.2;", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^3, x = [-1, true, false]; x*=5.2;", "x",
(TinyVector<3>{TinyVector<3>{-1, true, false} *= 5.2}));
}
@@ -297,13 +304,13 @@ TEST_CASE("AffectationProcessor", "[language]")
SECTION("R^2x2")
{
- CHECK_AFFECTATION_RESULT("let x : R^2x2, x = (-1, true, 3, 6); x *= 3;", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^2x2, x = [[-1, true], [3, 6]]; x *= 3;", "x",
(TinyMatrix<2>{TinyMatrix<2>{-1, true, 3, 6} *= 3}));
}
SECTION("R^3x3")
{
- CHECK_AFFECTATION_RESULT("let x : R^3x3, x = (-1, true, false, 2, -3, 11, 5, -4, 2); x*=5.2;", "x",
+ CHECK_AFFECTATION_RESULT("let x : R^3x3, x = [[-1, true, false], [2, -3, 11], [5, -4, 2]]; x*=5.2;", "x",
(TinyMatrix<3>{TinyMatrix<3>{-1, true, false, 2, -3, 11, 5, -4, 2} *= 5.2}));
}
}
@@ -401,9 +408,9 @@ TEST_CASE("AffectationProcessor", "[language]")
CHECK_AFFECTATION_THROWS_WITH("let x : R^1; let y : R^1x1, y = 1; x = y;",
"undefined affectation type: R^1 = R^1x1");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^2; let y : R^2x2, y = (1,2,4,4); x = y;",
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^2; let y : R^2x2, y = [[1,2],[4,4]]; x = y;",
"undefined affectation type: R^2 = R^2x2");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^3; let y : R^3x3, y = (1,2,3,4,5,6,7,8,9); x = y;",
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^3; let y : R^3x3, y = [[1,2,3],[4,5,6],[7,8,9]]; x = y;",
"undefined affectation type: R^3 = R^3x3");
CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 4;", "invalid integral value (0 is the solely valid value)");
@@ -425,14 +432,8 @@ TEST_CASE("AffectationProcessor", "[language]")
"undefined affectation type: R^2 = R^3");
CHECK_AFFECTATION_THROWS_WITH("let x : R^1, x = (1,2);", "undefined affectation type: R^1 = list");
-
- CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = (1,2,3);",
- "incompatible dimensions in affectation: expecting 2, but provided 3");
-
- CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = (1,2);",
- "incompatible dimensions in affectation: expecting 3, but provided 2");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = (1,2,3,4);",
- "incompatible dimensions in affectation: expecting 3, but provided 4");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = (1,2);", "undefined affectation type: R^2 = list");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = (1,2,3);", "undefined affectation type: R^3 = list");
}
SECTION("-> R^n (affectation of components is forbidden)")
@@ -478,11 +479,9 @@ TEST_CASE("AffectationProcessor", "[language]")
CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 3.2;", "undefined affectation type: R^2 = R");
CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = 2.3;", "undefined affectation type: R^3 = R");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^1; let y : R^1x1, y = 1; x = y;",
- "undefined affectation type: R^1 = R^1x1");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^2; let y : R^2x2, y = (1,2,4,4); x = y;",
- "undefined affectation type: R^2 = R^2x2");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^3; let y : R^3x3, y = (1,2,3,4,5,6,7,8,9); x = y;",
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^1; x = [[1]];", "undefined affectation type: R^1 = R^1x1");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^2; x = [[1,2],[4,4]];", "undefined affectation type: R^2 = R^2x2");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^3; x = [[1,2,3],[4,5,6],[7,8,9]];",
"undefined affectation type: R^3 = R^3x3");
CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = 4;", "invalid integral value (0 is the solely valid value)");
@@ -504,14 +503,8 @@ TEST_CASE("AffectationProcessor", "[language]")
"undefined affectation type: R^2 = R^3");
CHECK_AFFECTATION_THROWS_WITH("let x : R^1, x = (1,2);", "undefined affectation type: R^1 = list");
-
- CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = (1,2,3);",
- "incompatible dimensions in affectation: expecting 2, but provided 3");
-
- CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = (1,2);",
- "incompatible dimensions in affectation: expecting 3, but provided 2");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = (1,2,3,4);",
- "incompatible dimensions in affectation: expecting 3, but provided 4");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^2, x = (1,2);", "undefined affectation type: R^2 = list");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^3, x = (1,2,3);", "undefined affectation type: R^3 = list");
}
SECTION("-> R^nxn")
@@ -557,12 +550,9 @@ TEST_CASE("AffectationProcessor", "[language]")
CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = 3.2;", "undefined affectation type: R^2x2 = R");
CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = 2.3;", "undefined affectation type: R^3x3 = R");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^1x1; let y : R^1, y = 1; x = y;",
- "undefined affectation type: R^1x1 = R^1");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2; let y : R^2, y = (1,2); x = y;",
- "undefined affectation type: R^2x2 = R^2");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3; let y : R^3, y = (1,2,3); x = y;",
- "undefined affectation type: R^3x3 = R^3");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^1x1; x = [1];", "undefined affectation type: R^1x1 = R^1");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2; x = [1,2];", "undefined affectation type: R^2x2 = R^2");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3; x = [1,2,3];", "undefined affectation type: R^3x3 = R^3");
CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2; x = 3.2;", "undefined affectation type: R^2x2 = R");
CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3; x = 2.3;", "undefined affectation type: R^3x3 = R");
@@ -570,10 +560,8 @@ TEST_CASE("AffectationProcessor", "[language]")
CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = 4;", "invalid integral value (0 is the solely valid value)");
CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = 3;", "invalid integral value (0 is the solely valid value)");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^1x1, x = 0; let y : R^2x2, y = x;",
- "undefined affectation type: R^2x2 = R^1x1");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^1x1, x = 0; let y : R^3x3, y = x;",
- "undefined affectation type: R^3x3 = R^1x1");
+ CHECK_AFFECTATION_THROWS_WITH("let y : R^2x2, y = [[0]];", "undefined affectation type: R^2x2 = R^1x1");
+ CHECK_AFFECTATION_THROWS_WITH("let y : R^3x3, y = [[0]];", "undefined affectation type: R^3x3 = R^1x1");
CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = 0; let y : R^1x1, y = x;",
"undefined affectation type: R^1x1 = R^2x2");
@@ -586,16 +574,9 @@ TEST_CASE("AffectationProcessor", "[language]")
"undefined affectation type: R^2x2 = R^3x3");
CHECK_AFFECTATION_THROWS_WITH("let x : R^1x1, x = (1,2);", "undefined affectation type: R^1x1 = list");
-
- CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = (1,2,3);",
- "incompatible dimensions in affectation: expecting 4, but provided 3");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = (1,2,3,4,5);",
- "incompatible dimensions in affectation: expecting 4, but provided 5");
-
- CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = (1,2,3,4,5,6,7,8);",
- "incompatible dimensions in affectation: expecting 9, but provided 8");
- CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = (1,2,3,4,5,6,7,8,9,10);",
- "incompatible dimensions in affectation: expecting 9, but provided 10");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^2x2, x = (1,2,3,4);", "undefined affectation type: R^2x2 = list");
+ CHECK_AFFECTATION_THROWS_WITH("let x : R^3x3, x = (1,2,3,4,5,6,7,8,9);",
+ "undefined affectation type: R^3x3 = list");
}
}
}
diff --git a/tests/test_AffectationToStringProcessor.cpp b/tests/test_AffectationToStringProcessor.cpp
index 01c7ba7b938945dc9f929f602a3fe071b052379c..6b20e7ca84e7c7f80654ed6a053a34068df83889 100644
--- a/tests/test_AffectationToStringProcessor.cpp
+++ b/tests/test_AffectationToStringProcessor.cpp
@@ -51,54 +51,38 @@
TEST_CASE("ASTAffectationToStringProcessor", "[language]")
{
+ auto stringify = [](auto&& value) {
+ std::ostringstream os;
+ os << std::boolalpha << value;
+ return os.str();
+ };
+
SECTION("Affectations")
{
CHECK_AFFECTATION_RESULT(R"(let s : string; s = "foo";)", "s", std::string("foo"));
- CHECK_AFFECTATION_RESULT(R"(let n : N, n = 2; let s : string; s = n;)", "s", std::to_string(2ul));
- CHECK_AFFECTATION_RESULT(R"(let s : string; s = -1;)", "s", std::to_string(-1l));
- CHECK_AFFECTATION_RESULT(R"(let s : string; s = true;)", "s", std::to_string(true));
- CHECK_AFFECTATION_RESULT(R"(let s : string; s = 2.3;)", "s", std::to_string(2.3));
- {
- std::ostringstream os;
- os << TinyVector<1>{13};
- CHECK_AFFECTATION_RESULT(R"(let x : R^1, x = 13; let s : string; s = x;)", "s", os.str());
- }
- {
- std::ostringstream os;
- os << TinyVector<2>{2, 3};
- CHECK_AFFECTATION_RESULT(R"(let x : R^2, x = (2,3); let s : string; s = x;)", "s", os.str());
- }
- {
- std::ostringstream os;
- os << TinyVector<3>{1, 2, 3};
- CHECK_AFFECTATION_RESULT(R"(let x : R^3, x = (1,2,3); let s : string; s = x;)", "s", os.str());
- }
+ CHECK_AFFECTATION_RESULT(R"(let n : N, n = 2; let s : string; s = n;)", "s", stringify(2ul));
+ CHECK_AFFECTATION_RESULT(R"(let s : string; s = -1;)", "s", stringify(-1l));
+ CHECK_AFFECTATION_RESULT(R"(let s : string; s = true;)", "s", stringify(true));
+ CHECK_AFFECTATION_RESULT(R"(let s : string; s = 2.3;)", "s", stringify(2.3));
+ CHECK_AFFECTATION_RESULT(R"(let x : R^1, x = 13; let s : string; s = x;)", "s", stringify(TinyVector<1>{13}));
+ CHECK_AFFECTATION_RESULT(R"(let x : R^2, x = [2,3]; let s : string; s = x;)", "s", stringify(TinyVector<2>{2, 3}));
+ CHECK_AFFECTATION_RESULT(R"(let x : R^3, x = [1,2,3]; let s : string; s = x;)", "s",
+ stringify(TinyVector<3>{1, 2, 3}));
}
SECTION("+=")
{
CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += "bar";)", "s", std::string("foobar"));
CHECK_AFFECTATION_RESULT(R"(let n : N, n = 2; let s : string, s = "foo"; s += n;)", "s",
- (std::string("foo") + std::to_string(2ul)));
- CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += -1;)", "s", (std::string("foo") + std::to_string(-1l)));
- CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += true;)", "s",
- (std::string("foo") + std::to_string(true)));
- CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += 2.3;)", "s",
- (std::string("foo") + std::to_string(2.3)));
- {
- std::ostringstream os;
- os << "foo" << TinyVector<1>{13};
- CHECK_AFFECTATION_RESULT(R"(let x : R^1, x = 13; let s : string, s="foo"; s += x;)", "s", os.str());
- }
- {
- std::ostringstream os;
- os << "foo" << TinyVector<2>{2, 3};
- CHECK_AFFECTATION_RESULT(R"(let x : R^2, x = (2,3); let s : string, s="foo"; s += x;)", "s", os.str());
- }
- {
- std::ostringstream os;
- os << "foo" << TinyVector<3>{1, 2, 3};
- CHECK_AFFECTATION_RESULT(R"(let x : R^3, x = (1,2,3); let s : string, s="foo"; s += x;)", "s", os.str());
- }
+ (std::string("foo") + stringify(2ul)));
+ CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += -1;)", "s", (std::string("foo") + stringify(-1l)));
+ CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += true;)", "s", (std::string("foo") + stringify(true)));
+ CHECK_AFFECTATION_RESULT(R"(let s : string, s = "foo"; s += 2.3;)", "s", (std::string("foo") + stringify(2.3)));
+ CHECK_AFFECTATION_RESULT(R"(let x : R^1, x = 13; let s : string, s="foo"; s += x;)", "s",
+ (std::string("foo") + stringify(TinyVector<1>{13})));
+ CHECK_AFFECTATION_RESULT(R"(let x : R^2, x = [2,3]; let s : string, s="foo"; s += x;)", "s",
+ (std::string("foo") + stringify(TinyVector<2>{2, 3})));
+ CHECK_AFFECTATION_RESULT(R"(let x : R^3, x = [1,2,3]; let s : string, s="foo"; s += x;)", "s",
+ (std::string("foo") + stringify(TinyVector<3>{1, 2, 3})));
}
}
diff --git a/tests/test_AffectationToTupleProcessor.cpp b/tests/test_AffectationToTupleProcessor.cpp
index d832ac2739cb6b8417e6dfd3818e11252639b7b4..47913987007fb5860308530532572625efcf4b5d 100644
--- a/tests/test_AffectationToTupleProcessor.cpp
+++ b/tests/test_AffectationToTupleProcessor.cpp
@@ -51,6 +51,12 @@
TEST_CASE("ASTAffectationToTupleProcessor", "[language]")
{
+ auto stringify = [](auto&& value) {
+ std::ostringstream os;
+ os << std::boolalpha << value;
+ return os.str();
+ };
+
SECTION("Affectations from value")
{
CHECK_AFFECTATION_RESULT(R"(
@@ -66,36 +72,24 @@ let s :(R); s = 2;
CHECK_AFFECTATION_RESULT(R"(
let s :(string); s = 2.;
)",
- "s", (std::vector<std::string>{std::to_string(2.)}));
-
- const std::string x_string = []() -> std::string {
- std::ostringstream os;
- os << TinyVector<3, double>{1, 2, 3};
- return os.str();
- }();
+ "s", (std::vector<std::string>{stringify(2.)}));
CHECK_AFFECTATION_RESULT(R"(
-let x :R^3, x = (1,2,3);
+let x :R^3, x = [1,2,3];
let s :(string); s = x;
)",
- "s", (std::vector<std::string>{x_string}));
+ "s", (std::vector<std::string>{stringify(TinyVector<3, double>{1, 2, 3})}));
CHECK_AFFECTATION_RESULT(R"(
let s :(R^1); s = 1.3;
)",
"s", (std::vector<TinyVector<1>>{TinyVector<1>{1.3}}));
- const std::string A_string = []() -> std::string {
- std::ostringstream os;
- os << TinyMatrix<2>{1, 2, 3, 4};
- return os.str();
- }();
-
CHECK_AFFECTATION_RESULT(R"(
-let A :R^2x2, A = (1,2,3,4);
+let A :R^2x2, A = [[1,2],[3,4]];
let s :(string); s = A;
)",
- "s", (std::vector<std::string>{A_string}));
+ "s", (std::vector<std::string>{stringify(TinyMatrix<2>{1, 2, 3, 4})}));
CHECK_AFFECTATION_RESULT(R"(
let s :(R^1x1); s = 1.3;
@@ -113,34 +107,29 @@ let t :(R); t = (2.,3);
CHECK_AFFECTATION_RESULT(R"(
let s :(string); s = (2.,3);
)",
- "s", (std::vector<std::string>{std::to_string(2.), std::to_string(3)}));
+ "s", (std::vector<std::string>{stringify(2.), stringify(3)}));
CHECK_AFFECTATION_RESULT(R"(
let s :(string); s = (2.,3,"foo");
)",
- "s",
- (std::vector<std::string>{std::to_string(2.), std::to_string(3), std::string{"foo"}}));
-
- const std::string x_string = []() -> std::string {
- std::ostringstream os;
- os << TinyVector<2, double>{1, 2};
- return os.str();
- }();
+ "s", (std::vector<std::string>{stringify(2.), stringify(3), std::string("foo")}));
CHECK_AFFECTATION_RESULT(R"(
-let x : R^2, x = (1,2);
+let x : R^2, x = [1,2];
let s : (string); s = (2.,3, x);
)",
- "s", (std::vector<std::string>{std::to_string(2.), std::to_string(3), x_string}));
+ "s",
+ (std::vector<std::string>{stringify(2.), stringify(3),
+ stringify(TinyVector<2, double>{1, 2})}));
CHECK_AFFECTATION_RESULT(R"(
-let x : R^2, x = (1,2);
+let x : R^2, x = [1,2];
let t :(R^2); t = (x,0);
)",
"t", (std::vector<TinyVector<2>>{TinyVector<2>{1, 2}, TinyVector<2>{0, 0}}));
CHECK_AFFECTATION_RESULT(R"(
-let t :(R^2); t = ((1,2),0);
+let t :(R^2); t = ([1,2],0);
)",
"t", (std::vector<TinyVector<2>>{TinyVector<2>{1, 2}, TinyVector<2>{0, 0}}));
@@ -160,26 +149,22 @@ let t :(R^1); t = (x,2);
)",
"t", (std::vector<TinyVector<1>>{TinyVector<1>{1}, TinyVector<1>{2}}));
- const std::string A_string = []() -> std::string {
- std::ostringstream os;
- os << TinyMatrix<2>{1, 2, 3, 4};
- return os.str();
- }();
-
CHECK_AFFECTATION_RESULT(R"(
-let A : R^2x2, A = (1,2,3,4);
+let A : R^2x2, A = [[1,2],[3,4]];
let s : (string); s = (2.,3, A);
)",
- "s", (std::vector<std::string>{std::to_string(2.), std::to_string(3), A_string}));
+ "s",
+ (std::vector<std::string>{stringify(2.), stringify(3),
+ stringify(TinyMatrix<2>{1, 2, 3, 4})}));
CHECK_AFFECTATION_RESULT(R"(
-let A : R^2x2, A = (1,2,3,4);
+let A : R^2x2, A = [[1,2],[3,4]];
let t :(R^2x2); t = (A,0);
)",
"t", (std::vector<TinyMatrix<2>>{TinyMatrix<2>{1, 2, 3, 4}, TinyMatrix<2>{0, 0, 0, 0}}));
CHECK_AFFECTATION_RESULT(R"(
-let t :(R^2x2); t = ((1,2,3,4),0);
+let t :(R^2x2); t = ([[1,2],[3,4]],0);
)",
"t", (std::vector<TinyMatrix<2>>{TinyMatrix<2>{1, 2, 3, 4}, TinyMatrix<2>{0, 0, 0, 0}}));
@@ -202,36 +187,23 @@ let t :(R^1x1); t = (x,2);
SECTION("Affectations from tuple")
{
- const std::string x_string = []() -> std::string {
- std::ostringstream os;
- os << TinyVector<3, double>{1, 2, 3};
- return os.str();
- }();
-
CHECK_AFFECTATION_RESULT(R"(
-let x :(R^3), x = ((1,2,3));
+let x :(R^3), x = [1,2,3];
let s :(string); s = x;
)",
- "s", (std::vector<std::string>{x_string}));
-
- const std::string A_string = []() -> std::string {
- std::ostringstream os;
- os << TinyMatrix<3>{1, 2, 3, 4, 5, 6, 7, 8, 9};
- return os.str();
- }();
+ "s", (std::vector<std::string>{stringify(TinyVector<3, double>{1, 2, 3})}));
CHECK_AFFECTATION_RESULT(R"(
-let A :(R^3x3), A = ((1,2,3,4,5,6,7,8,9));
+let A :(R^3x3), A = ([[1,2,3],[4,5,6],[7,8,9]]);
let s :(string); s = A;
)",
- "s", (std::vector<std::string>{A_string}));
+ "s", (std::vector<std::string>{stringify(TinyMatrix<3>{1, 2, 3, 4, 5, 6, 7, 8, 9})}));
CHECK_AFFECTATION_RESULT(R"(
let x :(R), x = (1,2,3);
let s :(string); s = x;
)",
- "s",
- (std::vector<std::string>{std::to_string(1.), std::to_string(2.), std::to_string(3.)}));
+ "s", (std::vector<std::string>{stringify(1.), stringify(2.), stringify(3.)}));
CHECK_AFFECTATION_RESULT(R"(
let n :(N), n = (1,2,3);
diff --git a/tests/test_ArraySubscriptProcessor.cpp b/tests/test_ArraySubscriptProcessor.cpp
index cac519c63447a307864a1a8940dfbf3427388317..5b1ac6c1cf0a00f56a4da806b86bb4124c42b317 100644
--- a/tests/test_ArraySubscriptProcessor.cpp
+++ b/tests/test_ArraySubscriptProcessor.cpp
@@ -88,7 +88,7 @@ let x0: R, x0 = x[0];
SECTION("R^2 component access")
{
std::string_view data = R"(
-let x : R^2, x = (1,2);
+let x : R^2, x = [1,2];
let x0: R, x0 = x[0];
let x1: R, x1 = x[1];
)";
@@ -99,7 +99,7 @@ let x1: R, x1 = x[1];
SECTION("R^3 component access")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
+let x : R^3, x = [1,2,3];
let x0 : R, x0 = x[0];
let x1 : R, x1 = x[1];
let x2 : R, x2 = x[2];
@@ -121,7 +121,7 @@ let x00: R, x00 = x[0,0];
SECTION("R^2x2 component access")
{
std::string_view data = R"(
-let x : R^2x2, x = (1,2,3,4);
+let x : R^2x2, x = [[1,2],[3,4]];
let x00: R, x00 = x[0,0];
let x01: R, x01 = x[0,1];
let x10: R, x10 = x[1,0];
@@ -136,7 +136,7 @@ let x11: R, x11 = x[1,1];
SECTION("R^3x3 component access")
{
std::string_view data = R"(
-let x : R^3x3, x = (1,2,3,4,5,6,7,8,9);
+let x : R^3x3, x = [[1,2,3],[4,5,6],[7,8,9]];
let x00 : R, x00 = x[0,0];
let x01 : R, x01 = x[0,1];
let x02 : R, x02 = x[0,2];
@@ -161,10 +161,10 @@ let x22 : R, x22 = x[2,2];
SECTION("R^d component access from integer expression")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
+let x : R^3, x = [1,2,3];
let x0: R, x0 = x[3-2-1];
-let y : R^2, y = (2,7);
+let y : R^2, y = [2,7];
let y1: R, y1 = y[2/2];
let z : R^1, z = 8;
@@ -178,10 +178,10 @@ let z0: R, z0 = z[(2-2)*1];
SECTION("R^dxd component access from integer expression")
{
std::string_view data = R"(
-let x : R^3x3, x = (1,2,3,4,5,6,7,8,9);
+let x : R^3x3, x = [[1,2,3],[4,5,6],[7,8,9]];
let x01: R, x01 = x[3-2-1,2+3-4];
-let y : R^2x2, y = (2,7,6,-2);
+let y : R^2x2, y = [[2,7],[6,-2]];
let y11: R, y11 = y[2/2, 3/1-2];
let z : R^1x1, z = 8;
@@ -197,7 +197,7 @@ let z00: R, z00 = z[(2-2)*1, (3-1)*2-4];
SECTION("R index type")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
+let x : R^3, x = [1,2,3];
let x0: R, x0 = x[2.3];
)";
@@ -207,7 +207,7 @@ let x0: R, x0 = x[2.3];
SECTION("string index type")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
+let x : R^3, x = [1,2,3];
let x0: R, x0 = x["foo"];
)";
@@ -217,7 +217,7 @@ let x0: R, x0 = x["foo"];
SECTION("R^d index type")
{
std::string_view data = R"(
-let x : R^3, x = (1,2,3);
+let x : R^3, x = [1,2,3];
let x0: R, x0 = x[x];
)";
diff --git a/tests/test_BinaryExpressionProcessor_shift.cpp b/tests/test_BinaryExpressionProcessor_shift.cpp
index 127e90161416444f652c16206ddbd8c4f97d5718..010201d122ea543b828a1de7060700aa78313593 100644
--- a/tests/test_BinaryExpressionProcessor_shift.cpp
+++ b/tests/test_BinaryExpressionProcessor_shift.cpp
@@ -30,12 +30,12 @@ fout << createSocketServer(0) << "\n";)";
data << "let n:(N), n = (1,3);\n";
data << "let z:(Z), z = (-1,3);\n";
data << "let r:(R), r = (2.3,4);\n";
- data << "let u1:(R^1), u1 = (2.3,4);\n";
- data << "let u2:(R^2), u2 = ((2.3,4), (3,2));\n";
- data << "let u3:(R^3), u3 = ((2.3,4,-1), (3,2,1));\n";
- data << "let A1:(R^1x1), A1 = (2.3, 4);\n";
- data << "let A2:(R^2x2), A2 = ((2.3,4,2,0.3), (3,2.3,1,-4));\n";
- data << "let A3:(R^3x3), A3 = ((2.3,4,-1,2,7,2.3,6,2,8), (3,2,1,1,2,5,2.1,3,-2.6));\n";
+ data << "let u1:(R^1), u1 = (2.3,[4]);\n";
+ data << "let u2:(R^2), u2 = ([2.3,4], [3,2]);\n";
+ data << "let u3:(R^3), u3 = ([2.3,4,-1], [3,2,1]);\n";
+ data << "let A1:(R^1x1), A1 = (2.3, [[4]]);\n";
+ data << "let A2:(R^2x2), A2 = ([[2.3,4],[2,0.3]], [[3,2.3],[1,-4]]);\n";
+ data << "let A3:(R^3x3), A3 = ([[2.3,4,-1],[2,7,2.3],[6,2,8]], [[3,2,1],[1,2,5],[2.1,3,-2.6]]);\n";
data << R"(let s:(string), s = ("foo", "bar");)";
data << R"(fout << b << "\n";)";
data << R"(fout << n << "\n";)";
@@ -130,22 +130,22 @@ fout << createSocketServer(0) << "\n";)";
REQUIRE(std::string_view(line) == "(2.3, 4)");
fin.getline(line, 1023);
- REQUIRE(std::string_view(line) == "((2.3), (4))");
+ REQUIRE(std::string_view(line) == "([2.3], [4])");
fin.getline(line, 1023);
- REQUIRE(std::string_view(line) == "((2.3,4), (3,2))");
+ REQUIRE(std::string_view(line) == "([2.3,4], [3,2])");
fin.getline(line, 1023);
- REQUIRE(std::string_view(line) == "((2.3,4,-1), (3,2,1))");
+ REQUIRE(std::string_view(line) == "([2.3,4,-1], [3,2,1])");
fin.getline(line, 1023);
- REQUIRE(std::string_view(line) == "([(2.3)], [(4)])");
+ REQUIRE(std::string_view(line) == "([[2.3]], [[4]])");
fin.getline(line, 1023);
- REQUIRE(std::string_view(line) == "([(2.3,4)(2,0.3)], [(3,2.3)(1,-4)])");
+ REQUIRE(std::string_view(line) == "([[2.3,4],[2,0.3]], [[3,2.3],[1,-4]])");
fin.getline(line, 1023);
- REQUIRE(std::string_view(line) == "([(2.3,4,-1)(2,7,2.3)(6,2,8)], [(3,2,1)(1,2,5)(2.1,3,-2.6)])");
+ REQUIRE(std::string_view(line) == "([[2.3,4,-1],[2,7,2.3],[6,2,8]], [[3,2,1],[1,2,5],[2.1,3,-2.6]])");
fin.getline(line, 1023);
REQUIRE(std::string_view(line) == "(foo, bar)");
diff --git a/tests/test_BuiltinFunctionEmbedderUtils.cpp b/tests/test_BuiltinFunctionEmbedderUtils.cpp
index da2fbdd1dc8466377621b077af3ef790ec15e24e..ebb0195dc01ed45a25085b8f3150d71de08005ac 100644
--- a/tests/test_BuiltinFunctionEmbedderUtils.cpp
+++ b/tests/test_BuiltinFunctionEmbedderUtils.cpp
@@ -349,7 +349,7 @@ foo(3,0);
SECTION("builtin function R*R^2 -> R^2 (R^2 from list)")
{
std::string_view data = R"(
-foo(3.1,(1,2.3));
+foo(3.1,[1,2.3]);
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -431,7 +431,7 @@ foo(3,0);
SECTION("builtin function R*R^3 -> R^2 (R^3 from list)")
{
std::string_view data = R"(
-foo(3.1,(1,2.3,4));
+foo(3.1,[1,2.3,4]);
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -621,7 +621,7 @@ foo(3,0);
SECTION("builtin function R*R^2x2 -> R^2x2 (R^2x2 from list)")
{
std::string_view data = R"(
-foo(3.1,(1,2.3,0,3));
+foo(3.1,[[1,2.3],[0,3]]);
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -704,7 +704,7 @@ foo(3,0);
SECTION("builtin function R*R^3x3 -> R^2x2 (R^3x3 from list)")
{
std::string_view data = R"(
-foo(3.1,(1, 2.3, 4, 0.3, 2.5, 4.6, 2.7, 8.1, -9));
+foo(3.1,[[1, 2.3, 4], [0.3, 2.5, 4.6], [2.7, 8.1, -9]]);
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1009,29 +1009,6 @@ foo(0);
REQUIRE(function_embedder->getParameterDataTypes()[0].contentType().dimension() == 2);
}
- SECTION("builtin function (R^2x2...) -> N (from castable list)")
- {
- std::string_view data = R"(
-foo((1,2,3));
-)";
-
- TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
- auto root_node = ASTBuilder::build(input);
- register_functions(root_node,
- FunctionList{std::make_pair("foo", std::make_shared<BuiltinFunctionEmbedder<uint64_t(
- const std::vector<TinyMatrix<2>>&)>>(
- [](const std::vector<TinyMatrix<2>>& x) -> uint64_t {
- return x.size();
- }))});
-
- auto function_embedder = getBuiltinFunctionEmbedder(*root_node->children[0]);
- REQUIRE(function_embedder->getReturnDataType() == ASTNodeDataType::unsigned_int_t);
- REQUIRE(function_embedder->getParameterDataTypes().size() == 1);
- REQUIRE(function_embedder->getParameterDataTypes()[0] == ASTNodeDataType::tuple_t);
- REQUIRE(function_embedder->getParameterDataTypes()[0].contentType() == ASTNodeDataType::matrix_t);
- REQUIRE(function_embedder->getParameterDataTypes()[0].contentType().numberOfRows() == 2);
- }
-
SECTION("builtin function (R^2x2...) -> N (from 0)")
{
std::string_view data = R"(
@@ -1126,10 +1103,10 @@ foo(0);
REQUIRE(function_embedder->getParameterDataTypes()[0].contentType().dimension() == 3);
}
- SECTION("builtin function (R^3x3...) -> N (from castable list)")
+ SECTION("builtin function (R^3x3...) -> N (from 0)")
{
std::string_view data = R"(
-foo((1,2,3));
+foo(0);
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1149,10 +1126,11 @@ foo((1,2,3));
REQUIRE(function_embedder->getParameterDataTypes()[0].contentType().numberOfRows() == 3);
}
- SECTION("builtin function (R^3x3...) -> N (from 0)")
+ SECTION("builtin function (R^3x3...) -> N (from list)")
{
std::string_view data = R"(
-foo(0);
+let x:R^3x3;
+foo((x,2*x));
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1170,68 +1148,89 @@ foo(0);
REQUIRE(function_embedder->getParameterDataTypes()[0] == ASTNodeDataType::tuple_t);
REQUIRE(function_embedder->getParameterDataTypes()[0].contentType() == ASTNodeDataType::matrix_t);
REQUIRE(function_embedder->getParameterDataTypes()[0].contentType().numberOfRows() == 3);
+ REQUIRE(function_embedder->getParameterDataTypes()[0].contentType().numberOfColumns() == 3);
}
+ }
- SECTION("builtin function (R^3x3...) -> N (from list)")
+ SECTION("complete case")
+ {
+ SECTION("tuple first")
{
std::string_view data = R"(
let x:R^3x3;
-foo((x,2*x));
+foo((x,2*x), 1, "bar", [2,3]);
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
auto root_node = ASTBuilder::build(input);
register_functions(root_node,
- FunctionList{std::make_pair("foo", std::make_shared<BuiltinFunctionEmbedder<uint64_t(
- const std::vector<TinyMatrix<3>>&)>>(
- [](const std::vector<TinyMatrix<3>>& x) -> uint64_t {
- return x.size();
- }))});
+ FunctionList{
+ std::make_pair("foo",
+ std::make_shared<BuiltinFunctionEmbedder<
+ std::tuple<uint64_t, double, std::string>(const std::vector<TinyMatrix<3>>&,
+ const double&, const std::string&,
+ const TinyVector<2>&)>>(
+ [](const std::vector<TinyMatrix<3>>& x, const double& a,
+ const std::string& s,
+ const TinyVector<2>& y) -> std::tuple<uint64_t, double, std::string> {
+ return std::make_tuple(x.size(), a * y[0] + y[1], s + "_foo");
+ }))});
auto function_embedder = getBuiltinFunctionEmbedder(*root_node->children[0]);
- REQUIRE(function_embedder->getReturnDataType() == ASTNodeDataType::unsigned_int_t);
- REQUIRE(function_embedder->getParameterDataTypes().size() == 1);
+ REQUIRE(function_embedder->getReturnDataType() == ASTNodeDataType::list_t);
+ REQUIRE(function_embedder->getReturnDataType().contentTypeList().size() == 3);
+ REQUIRE(*function_embedder->getReturnDataType().contentTypeList()[0] == ASTNodeDataType::unsigned_int_t);
+ REQUIRE(*function_embedder->getReturnDataType().contentTypeList()[1] == ASTNodeDataType::double_t);
+ REQUIRE(*function_embedder->getReturnDataType().contentTypeList()[2] == ASTNodeDataType::string_t);
+ REQUIRE(function_embedder->getParameterDataTypes().size() == 4);
REQUIRE(function_embedder->getParameterDataTypes()[0] == ASTNodeDataType::tuple_t);
REQUIRE(function_embedder->getParameterDataTypes()[0].contentType() == ASTNodeDataType::matrix_t);
REQUIRE(function_embedder->getParameterDataTypes()[0].contentType().numberOfRows() == 3);
+ REQUIRE(function_embedder->getParameterDataTypes()[0].contentType().numberOfColumns() == 3);
+ REQUIRE(function_embedder->getParameterDataTypes()[1] == ASTNodeDataType::double_t);
+ REQUIRE(function_embedder->getParameterDataTypes()[2] == ASTNodeDataType::string_t);
+ REQUIRE(function_embedder->getParameterDataTypes()[3] == ASTNodeDataType::vector_t);
+ REQUIRE(function_embedder->getParameterDataTypes()[3].dimension() == 2);
}
- }
- SECTION("complete case")
- {
- std::string_view data = R"(
+ SECTION("tuple not first")
+ {
+ std::string_view data = R"(
let x:R^3x3;
-foo(1, "bar", (x,2*x), (2,3));
+foo(1, "bar", (x,2*x), [2,3]);
)";
- TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
- auto root_node = ASTBuilder::build(input);
- register_functions(root_node,
- FunctionList{
- std::make_pair("foo",
- std::make_shared<BuiltinFunctionEmbedder<
- std::tuple<uint64_t, double, std::string>(const double&, const std::string&,
- const std::vector<TinyMatrix<3>>&,
- const TinyVector<2>&)>>(
- [](const double& a, const std::string& s, const std::vector<TinyMatrix<3>>& x,
- const TinyVector<2>& y) -> std::tuple<uint64_t, double, std::string> {
- return std::make_tuple(x.size(), a * y[0] + y[1], s + "_foo");
- }))});
-
- auto function_embedder = getBuiltinFunctionEmbedder(*root_node->children[0]);
- REQUIRE(function_embedder->getReturnDataType() == ASTNodeDataType::list_t);
- REQUIRE(function_embedder->getReturnDataType().contentTypeList().size() == 3);
- REQUIRE(*function_embedder->getReturnDataType().contentTypeList()[0] == ASTNodeDataType::unsigned_int_t);
- REQUIRE(*function_embedder->getReturnDataType().contentTypeList()[1] == ASTNodeDataType::double_t);
- REQUIRE(*function_embedder->getReturnDataType().contentTypeList()[2] == ASTNodeDataType::string_t);
- REQUIRE(function_embedder->getParameterDataTypes().size() == 4);
- REQUIRE(function_embedder->getParameterDataTypes()[0] == ASTNodeDataType::double_t);
- REQUIRE(function_embedder->getParameterDataTypes()[1] == ASTNodeDataType::string_t);
- REQUIRE(function_embedder->getParameterDataTypes()[2] == ASTNodeDataType::tuple_t);
- REQUIRE(function_embedder->getParameterDataTypes()[2].contentType() == ASTNodeDataType::matrix_t);
- REQUIRE(function_embedder->getParameterDataTypes()[2].contentType().numberOfRows() == 3);
- REQUIRE(function_embedder->getParameterDataTypes()[3] == ASTNodeDataType::vector_t);
- REQUIRE(function_embedder->getParameterDataTypes()[3].dimension() == 2);
+ TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
+ auto root_node = ASTBuilder::build(input);
+ register_functions(root_node,
+ FunctionList{
+ std::make_pair("foo",
+ std::make_shared<BuiltinFunctionEmbedder<
+ std::tuple<uint64_t, double, std::string>(const double&, const std::string&,
+ const std::vector<TinyMatrix<3>>&,
+ const TinyVector<2>&)>>(
+ [](const double& a, const std::string& s,
+ const std::vector<TinyMatrix<3>>& x,
+ const TinyVector<2>& y) -> std::tuple<uint64_t, double, std::string> {
+ return std::make_tuple(x.size(), a * y[0] + y[1], s + "_foo");
+ }))});
+
+ auto function_embedder = getBuiltinFunctionEmbedder(*root_node->children[0]);
+ REQUIRE(function_embedder->getReturnDataType() == ASTNodeDataType::list_t);
+ REQUIRE(function_embedder->getReturnDataType().contentTypeList().size() == 3);
+ REQUIRE(*function_embedder->getReturnDataType().contentTypeList()[0] == ASTNodeDataType::unsigned_int_t);
+ REQUIRE(*function_embedder->getReturnDataType().contentTypeList()[1] == ASTNodeDataType::double_t);
+ REQUIRE(*function_embedder->getReturnDataType().contentTypeList()[2] == ASTNodeDataType::string_t);
+ REQUIRE(function_embedder->getParameterDataTypes().size() == 4);
+ REQUIRE(function_embedder->getParameterDataTypes()[0] == ASTNodeDataType::double_t);
+ REQUIRE(function_embedder->getParameterDataTypes()[1] == ASTNodeDataType::string_t);
+ REQUIRE(function_embedder->getParameterDataTypes()[2] == ASTNodeDataType::tuple_t);
+ REQUIRE(function_embedder->getParameterDataTypes()[2].contentType() == ASTNodeDataType::matrix_t);
+ REQUIRE(function_embedder->getParameterDataTypes()[2].contentType().numberOfRows() == 3);
+ REQUIRE(function_embedder->getParameterDataTypes()[2].contentType().numberOfColumns() == 3);
+ REQUIRE(function_embedder->getParameterDataTypes()[3] == ASTNodeDataType::vector_t);
+ REQUIRE(function_embedder->getParameterDataTypes()[3].dimension() == 2);
+ }
}
SECTION("errors")
@@ -1332,7 +1331,7 @@ foo(x);
SECTION("R^2: invalid argument list size")
{
std::string_view data = R"(
-foo((1,2,3,4));
+foo(1,2,3,4);
)";
std::string error_msg = "no matching function to call foo: Z*Z*Z*Z\n"
@@ -1362,7 +1361,7 @@ foo((1,2,3,4));
SECTION("R^3: invalid argument list size")
{
std::string_view data = R"(
-foo((1,2,3,4));
+foo(1,2,3,4);
)";
std::string error_msg = "no matching function to call foo: Z*Z*Z*Z\n"
@@ -1485,7 +1484,7 @@ foo(x);
SECTION("R^2x2: invalid argument list size")
{
std::string_view data = R"(
-foo((1,2,3));
+foo(1,2,3);
)";
std::string error_msg = "no matching function to call foo: Z*Z*Z\n"
@@ -1515,7 +1514,7 @@ foo((1,2,3));
SECTION("R^3x3: invalid argument list size")
{
std::string_view data = R"(
-foo((1,2,3,4));
+foo(1,2,3,4);
)";
std::string error_msg = "no matching function to call foo: Z*Z*Z*Z\n"
diff --git a/tests/test_BuiltinFunctionProcessor.cpp b/tests/test_BuiltinFunctionProcessor.cpp
index bbc5ac52e1a6e8034b68b591adff83c1d8701ff5..57f5d65ac3b745e65b4d40047db87444b9550b55 100644
--- a/tests/test_BuiltinFunctionProcessor.cpp
+++ b/tests/test_BuiltinFunctionProcessor.cpp
@@ -17,6 +17,8 @@
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"}; \
auto ast = ASTBuilder::build(input); \
\
+ test_only::test_BuiltinFunctionRegister{*ast}; \
+ \
ASTModulesImporter{*ast}; \
ASTNodeTypeCleaner<language::import_instruction>{*ast}; \
\
@@ -329,8 +331,8 @@ let s:R, s = dot(x,y);
tested_function_set.insert("dot:R^2*R^2");
std::string_view data = R"(
import math;
-let x:R^2, x = (-2, 3);
-let y:R^2, y = (4, 3);
+let x:R^2, x = [-2, 3];
+let y:R^2, y = [4, 3];
let s:R, s = dot(x,y);
)";
CHECK_BUILTIN_FUNCTION_EVALUATION_RESULT(data, "s", dot(TinyVector<2>{-2, 3}, TinyVector<2>{4, 3}));
@@ -340,8 +342,8 @@ let s:R, s = dot(x,y);
tested_function_set.insert("dot:R^3*R^3");
std::string_view data = R"(
import math;
-let x:R^3, x = (-2, 3, 4);
-let y:R^3, y = (4, 3, 5);
+let x:R^3, x = [-2, 3, 4];
+let y:R^3, y = [4, 3, 5];
let s:R, s = dot(x,y);
)";
CHECK_BUILTIN_FUNCTION_EVALUATION_RESULT(data, "s", dot(TinyVector<3>{-2, 3, 4}, TinyVector<3>{4, 3, 5}));
@@ -369,4 +371,31 @@ runtimeError();
CHECK_AST_THROWS_WITH(data, error);
}
}
+
+ SECTION("int list -> tuple args evalation")
+ {
+ {
+ std::string_view data = R"(
+let x:R, x = tuple_ZtoR((1,2,3,-4));
+)";
+ CHECK_BUILTIN_FUNCTION_EVALUATION_RESULT(data, "x", 0.5 * (1 + 2 + 3 - 4));
+ }
+
+ {
+ std::string_view data = R"(
+let (X,x):(R)*R, (X,x) = R22ToTupleRxR([[1,1], [2,3]]);
+)";
+ CHECK_BUILTIN_FUNCTION_EVALUATION_RESULT(data, "X", (std::vector<double>{1, 1, 2, 3}));
+ }
+ }
+
+ SECTION("simple N to tuple args evalation")
+ {
+ {
+ std::string_view data = R"(
+let x:R, x = tuple_ZtoR(3);
+)";
+ CHECK_BUILTIN_FUNCTION_EVALUATION_RESULT(data, "x", 0.5 * 3);
+ }
+ }
}
diff --git a/tests/test_BuiltinFunctionRegister.hpp b/tests/test_BuiltinFunctionRegister.hpp
index 49bceabb565ec13b04350f083009c85702886fc2..bcabd3ad49c5933b938eea5bb6f97b46a6bd4cc4 100644
--- a/tests/test_BuiltinFunctionRegister.hpp
+++ b/tests/test_BuiltinFunctionRegister.hpp
@@ -121,7 +121,13 @@ class test_BuiltinFunctionRegister
m_name_builtin_function_map.insert(
std::make_pair("tuple_ZtoR:(Z...)", std::make_shared<BuiltinFunctionEmbedder<double(std::vector<int64_t>)>>(
- [](const std::vector<int64_t>&) -> double { return 0.5; })));
+ [](const std::vector<int64_t>& v) -> double {
+ int64_t sum = 0;
+ for (auto vi : v) {
+ sum += vi;
+ }
+ return 0.5 * sum;
+ })));
m_name_builtin_function_map.insert(
std::make_pair("tuple_RtoB:(R...)", std::make_shared<BuiltinFunctionEmbedder<bool(std::vector<double>)>>(
@@ -162,6 +168,14 @@ class test_BuiltinFunctionRegister
std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyMatrix<2>>&)>>(
[](const std::vector<TinyMatrix<2>>&) -> double { return 1; })));
+ m_name_builtin_function_map.insert(
+ std::make_pair("R22ToTupleRxR:(R^2x2)",
+ std::make_shared<
+ BuiltinFunctionEmbedder<std::tuple<std::vector<double>, double>(const TinyMatrix<2>&)>>(
+ [](const TinyMatrix<2>& A) -> std::tuple<std::vector<double>, double> {
+ return std::make_tuple(std::vector<double>{A(0, 0), A(0, 1), A(1, 0), A(1, 1)}, A(0, 0));
+ })));
+
m_name_builtin_function_map.insert(
std::make_pair("tuple_R33ToR:(R^3x3...)",
std::make_shared<BuiltinFunctionEmbedder<double(const std::vector<TinyMatrix<3>>)>>(
diff --git a/tests/test_ConcatExpressionProcessor.cpp b/tests/test_ConcatExpressionProcessor.cpp
index 4c5e202b71a1b9630683145aa4ffb30863ce9a27..ce6c23ddcbc3719907d43ea2b14cff52337dc655 100644
--- a/tests/test_ConcatExpressionProcessor.cpp
+++ b/tests/test_ConcatExpressionProcessor.cpp
@@ -90,7 +90,7 @@ TEST_CASE("ConcatExpressionProcessor", "[language]")
std::ostringstream os;
os << "foo_" << TinyVector<2>{1, 2};
- CHECK_CONCAT_EXPRESSION_RESULT(R"(let x:R^2, x = (1,2); let s:string, s = "foo_"; s = s+x;)", "s", os.str());
+ CHECK_CONCAT_EXPRESSION_RESULT(R"(let x:R^2, x = [1,2]; let s:string, s = "foo_"; s = s+x;)", "s", os.str());
}
SECTION("string + R^3")
@@ -98,6 +98,6 @@ TEST_CASE("ConcatExpressionProcessor", "[language]")
std::ostringstream os;
os << "foo_" << TinyVector<3>{1, 2, 3};
- CHECK_CONCAT_EXPRESSION_RESULT(R"(let x:R^3, x = (1,2,3); let s:string, s = "foo_"; s = s+x;)", "s", os.str());
+ CHECK_CONCAT_EXPRESSION_RESULT(R"(let s:string, s = "foo_"; s = s+[1,2,3];)", "s", os.str());
}
}
diff --git a/tests/test_DiscreteFunctionIntegrator.cpp b/tests/test_DiscreteFunctionIntegrator.cpp
index 465288f67d4efcd9a7a78eff53ab9649d381e572..031f6c62bd4f123e0a001eacdea0721716325978 100644
--- a/tests/test_DiscreteFunctionIntegrator.cpp
+++ b/tests/test_DiscreteFunctionIntegrator.cpp
@@ -61,11 +61,11 @@ let N_scalar_non_linear_1d: R^1 -> N, x -> floor(3 * x[0] * x[0] + 2);
let Z_scalar_non_linear_1d: R^1 -> Z, x -> floor(exp(2 * x[0]) - 1);
let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
let R1_non_linear_1d: R^1 -> R^1, x -> 2 * exp(x[0]);
-let R2_non_linear_1d: R^1 -> R^2, x -> (2 * exp(x[0]), -3*x[0]);
-let R3_non_linear_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
+let R2_non_linear_1d: R^1 -> R^2, x -> [2 * exp(x[0]), -3*x[0]];
+let R3_non_linear_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
let R1x1_non_linear_1d: R^1 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[0]) + 3);
-let R2x2_non_linear_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
-let R3x3_non_linear_1d: R^1 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0], -4*x[0], 2*x[0]+1, 3, -6*x[0], exp(x[0]));
+let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
+let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3], [x[0] * x[0], -4*x[0], 2*x[0]+1], [3, -6*x[0], exp(x[0])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -307,11 +307,11 @@ let N_scalar_non_linear_2d: R^2 -> N, x -> floor(3 * (x[0] + x[1]) * (x[0] + x[1
let Z_scalar_non_linear_2d: R^2 -> Z, x -> floor(exp(2 * x[0]) - 3 * x[1]);
let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0]) + 3 * x[1];
let R1_non_linear_2d: R^2 -> R^1, x -> 2 * exp(x[0]);
-let R2_non_linear_2d: R^2 -> R^2, x -> (2 * exp(x[0]), -3*x[1]);
-let R3_non_linear_2d: R^2 -> R^3, x -> (2 * exp(x[0]) + 3, x[1] - 2, 3);
-let R1x1_non_linear_2d: R^2 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[1]) + 3);
-let R2x2_non_linear_2d: R^2 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3, x[1] * x[0]);
-let R3x3_non_linear_2d: R^2 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3, x[1] * x[0], -4*x[1], 2*x[0]+1, 3, -6*x[0], exp(x[1]));
+let R2_non_linear_2d: R^2 -> R^2, x -> [2 * exp(x[0]), -3*x[1]];
+let R3_non_linear_2d: R^2 -> R^3, x -> [2 * exp(x[0]) + 3, x[1] - 2, 3];
+let R1x1_non_linear_2d: R^2 -> R^1x1, x -> 2 * exp(x[0]) * sin(x[1]) + 3;
+let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0])], [3, x[1] * x[0]]];
+let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3], [x[1] * x[0], -4*x[1], 2*x[0]+1], [3, -6*x[0], exp(x[1])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -553,11 +553,11 @@ let N_scalar_non_linear_3d: R^3 -> N, x -> floor(3 * (x[0] + x[1]) * (x[0] + x[1
let Z_scalar_non_linear_3d: R^3 -> Z, x -> floor(exp(2 * x[0]) - 3 * x[1] + x[2]);
let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]+x[2]) + 3 * x[1];
let R1_non_linear_3d: R^3 -> R^1, x -> 2 * exp(x[0])+sin(x[1] + x[2]);
-let R2_non_linear_3d: R^3 -> R^2, x -> (2 * exp(x[0]), -3*x[1] * x[2]);
-let R3_non_linear_3d: R^3 -> R^3, x -> (2 * exp(x[0]) + 3, x[1] - 2, 3 * x[2]);
+let R2_non_linear_3d: R^3 -> R^2, x -> [2 * exp(x[0]), -3*x[1] * x[2]];
+let R3_non_linear_3d: R^3 -> R^3, x -> [2 * exp(x[0]) + 3, x[1] - 2, 3 * x[2]];
let R1x1_non_linear_3d: R^3 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * x[2]);
-let R2x2_non_linear_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[2] - 2 * x[0]), 3, x[1] * x[0] - x[2]);
-let R3x3_non_linear_3d: R^3 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[2]), 3, x[1] * x[2], -4*x[1], 2*x[2]+1, 3, -6*x[2], exp(x[1] + x[2]));
+let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[2] - 2 * x[0])], [3, x[1] * x[0] - x[2]]];
+let R3x3_non_linear_3d: R^3 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[2]), 3], [x[1] * x[2], -4*x[1], 2*x[2]+1], [3, -6*x[2], exp(x[1] + x[2])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_DiscreteFunctionIntegratorByZone.cpp b/tests/test_DiscreteFunctionIntegratorByZone.cpp
index 071f8cddb7e9f71e0b102bf361afb8715a7afe87..19c0ac87c1d941e4c5f0026e154087be305c55f2 100644
--- a/tests/test_DiscreteFunctionIntegratorByZone.cpp
+++ b/tests/test_DiscreteFunctionIntegratorByZone.cpp
@@ -64,11 +64,11 @@ let N_scalar_non_linear_1d: R^1 -> N, x -> floor(3 * x[0] * x[0] + 2);
let Z_scalar_non_linear_1d: R^1 -> Z, x -> floor(exp(2 * x[0]) - 1);
let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
let R1_non_linear_1d: R^1 -> R^1, x -> 2 * exp(x[0]);
-let R2_non_linear_1d: R^1 -> R^2, x -> (2 * exp(x[0]), -3*x[0]);
-let R3_non_linear_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
+let R2_non_linear_1d: R^1 -> R^2, x -> [2 * exp(x[0]), -3*x[0]];
+let R3_non_linear_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
let R1x1_non_linear_1d: R^1 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[0]) + 3);
-let R2x2_non_linear_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
-let R3x3_non_linear_1d: R^1 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0], -4*x[0], 2*x[0]+1, 3, -6*x[0], exp(x[0]));
+let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
+let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3], [x[0] * x[0], -4*x[0], 2*x[0]+1], [3, -6*x[0], exp(x[0])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -403,11 +403,11 @@ let N_scalar_non_linear_2d: R^2 -> N, x -> floor(3 * (x[0] + x[1]) * (x[0] + x[1
let Z_scalar_non_linear_2d: R^2 -> Z, x -> floor(exp(2 * x[0]) - 3 * x[1]);
let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0]) + 3 * x[1];
let R1_non_linear_2d: R^2 -> R^1, x -> 2 * exp(x[0]);
-let R2_non_linear_2d: R^2 -> R^2, x -> (2 * exp(x[0]), -3*x[1]);
-let R3_non_linear_2d: R^2 -> R^3, x -> (2 * exp(x[0]) + 3, x[1] - 2, 3);
+let R2_non_linear_2d: R^2 -> R^2, x -> [2 * exp(x[0]), -3*x[1]];
+let R3_non_linear_2d: R^2 -> R^3, x -> [2 * exp(x[0]) + 3, x[1] - 2, 3];
let R1x1_non_linear_2d: R^2 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[1]) + 3);
-let R2x2_non_linear_2d: R^2 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3, x[1] * x[0]);
-let R3x3_non_linear_2d: R^2 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3, x[1] * x[0], -4*x[1], 2*x[0]+1, 3, -6*x[0], exp(x[1]));
+let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0])], [3, x[1] * x[0]]];
+let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3], [x[1] * x[0], -4*x[1], 2*x[0]+1], [3, -6*x[0], exp(x[1])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -742,11 +742,11 @@ let N_scalar_non_linear_3d: R^3 -> N, x -> floor(3 * (x[0] + x[1]) * (x[0] + x[1
let Z_scalar_non_linear_3d: R^3 -> Z, x -> floor(exp(2 * x[0]) - 3 * x[1] + x[2]);
let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]+x[2]) + 3 * x[1];
let R1_non_linear_3d: R^3 -> R^1, x -> 2 * exp(x[0])+sin(x[1] + x[2]);
-let R2_non_linear_3d: R^3 -> R^2, x -> (2 * exp(x[0]), -3*x[1] * x[2]);
-let R3_non_linear_3d: R^3 -> R^3, x -> (2 * exp(x[0]) + 3, x[1] - 2, 3 * x[2]);
+let R2_non_linear_3d: R^3 -> R^2, x -> [2 * exp(x[0]), -3*x[1] * x[2]];
+let R3_non_linear_3d: R^3 -> R^3, x -> [2 * exp(x[0]) + 3, x[1] - 2, 3 * x[2]];
let R1x1_non_linear_3d: R^3 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * x[2]);
-let R2x2_non_linear_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[2] - 2 * x[0]), 3, x[1] * x[0] - x[2]);
-let R3x3_non_linear_3d: R^3 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[2]), 3, x[1] * x[2], -4*x[1], 2*x[2]+1, 3, -6*x[2], exp(x[1] + x[2]));
+let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[2] - 2 * x[0])], [3, x[1] * x[0] - x[2]]];
+let R3x3_non_linear_3d: R^3 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[2]), 3], [x[1] * x[2], -4*x[1], 2*x[2]+1], [3, -6*x[2], exp(x[1] + x[2])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_DiscreteFunctionInterpoler.cpp b/tests/test_DiscreteFunctionInterpoler.cpp
index 809ca559ca254cbbb5d90c63f8dcd943a5df23c8..f9d870d29dbd53f6eef9f49bf114be2566475d0d 100644
--- a/tests/test_DiscreteFunctionInterpoler.cpp
+++ b/tests/test_DiscreteFunctionInterpoler.cpp
@@ -59,11 +59,11 @@ let N_scalar_non_linear_1d: R^1 -> N, x -> floor(3 * x[0] * x[0] + 2);
let Z_scalar_non_linear_1d: R^1 -> Z, x -> floor(exp(2 * x[0]) - 1);
let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
let R1_non_linear_1d: R^1 -> R^1, x -> 2 * exp(x[0]);
-let R2_non_linear_1d: R^1 -> R^2, x -> (2 * exp(x[0]), -3*x[0]);
-let R3_non_linear_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
+let R2_non_linear_1d: R^1 -> R^2, x -> [2 * exp(x[0]), -3*x[0]];
+let R3_non_linear_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
let R1x1_non_linear_1d: R^1 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[0]) + 3);
-let R2x2_non_linear_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
-let R3x3_non_linear_1d: R^1 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0], -4*x[0], 2*x[0]+1, 3, -6*x[0], exp(x[0]));
+let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
+let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3], [x[0] * x[0], -4*x[0], 2*x[0]+1], [3, -6*x[0], exp(x[0])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -358,11 +358,11 @@ let N_scalar_non_linear_2d: R^2 -> N, x -> floor(3 * (x[0] + x[1]) * (x[0] + x[1
let Z_scalar_non_linear_2d: R^2 -> Z, x -> floor(exp(2 * x[0]) - 3 * x[1]);
let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0]) + 3 * x[1];
let R1_non_linear_2d: R^2 -> R^1, x -> 2 * exp(x[0]);
-let R2_non_linear_2d: R^2 -> R^2, x -> (2 * exp(x[0]), -3*x[1]);
-let R3_non_linear_2d: R^2 -> R^3, x -> (2 * exp(x[0]) + 3, x[1] - 2, 3);
-let R1x1_non_linear_2d: R^2 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[1]) + 3);
-let R2x2_non_linear_2d: R^2 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3, x[1] * x[0]);
-let R3x3_non_linear_2d: R^2 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3, x[1] * x[0], -4*x[1], 2*x[0]+1, 3, -6*x[0], exp(x[1]));
+let R2_non_linear_2d: R^2 -> R^2, x -> [2 * exp(x[0]), -3*x[1]];
+let R3_non_linear_2d: R^2 -> R^3, x -> [2 * exp(x[0]) + 3, x[1] - 2, 3];
+let R1x1_non_linear_2d: R^2 -> R^1x1, x -> [[2 * exp(x[0]) * sin(x[1]) + 3]];
+let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0])], [3, x[1] * x[0]]];
+let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3], [x[1] * x[0], -4*x[1], 2*x[0]+1], [3, -6*x[0], exp(x[1])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -658,11 +658,11 @@ let N_scalar_non_linear_3d: R^3 -> N, x -> floor(3 * (x[0] + x[1]) * (x[0] + x[1
let Z_scalar_non_linear_3d: R^3 -> Z, x -> floor(exp(2 * x[0]) - 3 * x[1] + x[2]);
let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]+x[2]) + 3 * x[1];
let R1_non_linear_3d: R^3 -> R^1, x -> 2 * exp(x[0])+sin(x[1] + x[2]);
-let R2_non_linear_3d: R^3 -> R^2, x -> (2 * exp(x[0]), -3*x[1] * x[2]);
-let R3_non_linear_3d: R^3 -> R^3, x -> (2 * exp(x[0]) + 3, x[1] - 2, 3 * x[2]);
-let R1x1_non_linear_3d: R^3 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * x[2]);
-let R2x2_non_linear_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[2] - 2 * x[0]), 3, x[1] * x[0] - x[2]);
-let R3x3_non_linear_3d: R^3 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[2]), 3, x[1] * x[2], -4*x[1], 2*x[2]+1, 3, -6*x[2], exp(x[1] + x[2]));
+let R2_non_linear_3d: R^3 -> R^2, x -> [2 * exp(x[0]), -3*x[1] * x[2]];
+let R3_non_linear_3d: R^3 -> R^3, x -> [2 * exp(x[0]) + 3, x[1] - 2, 3 * x[2]];
+let R1x1_non_linear_3d: R^3 -> R^1x1, x -> 2 * exp(x[0]) * sin(x[1]) + 3 * x[2];
+let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[2] - 2 * x[0])], [3, x[1] * x[0] - x[2]]];
+let R3x3_non_linear_3d: R^3 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[2]), 3], [x[1] * x[2], -4*x[1], 2*x[2]+1], [3, -6*x[2], exp(x[1] + x[2])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_DiscreteFunctionInterpolerByZone.cpp b/tests/test_DiscreteFunctionInterpolerByZone.cpp
index 4ad5f464f5fe276bf489df459cd2cfc90e42a519..dce3b645a7e98ee91b41f8cd5f158edb019d94ed 100644
--- a/tests/test_DiscreteFunctionInterpolerByZone.cpp
+++ b/tests/test_DiscreteFunctionInterpolerByZone.cpp
@@ -67,11 +67,11 @@ let N_scalar_non_linear_1d: R^1 -> N, x -> floor(3 * x[0] * x[0] + 2);
let Z_scalar_non_linear_1d: R^1 -> Z, x -> floor(exp(2 * x[0]) - 1);
let R_scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
let R1_non_linear_1d: R^1 -> R^1, x -> 2 * exp(x[0]);
-let R2_non_linear_1d: R^1 -> R^2, x -> (2 * exp(x[0]), -3*x[0]);
-let R3_non_linear_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
-let R1x1_non_linear_1d: R^1 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[0]) + 3);
-let R2x2_non_linear_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
-let R3x3_non_linear_1d: R^1 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0], -4*x[0], 2*x[0]+1, 3, -6*x[0], exp(x[0]));
+let R2_non_linear_1d: R^1 -> R^2, x -> [2 * exp(x[0]), -3*x[0]];
+let R3_non_linear_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
+let R1x1_non_linear_1d: R^1 -> R^1x1, x -> 2 * exp(x[0]) * sin(x[0]) + 3;
+let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
+let R3x3_non_linear_1d: R^1 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3], [x[0] * x[0], -4*x[0], 2*x[0]+1], [3, -6*x[0], exp(x[0])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -410,11 +410,11 @@ let N_scalar_non_linear_2d: R^2 -> N, x -> floor(3 * (x[0] + x[1]) * (x[0] + x[1
let Z_scalar_non_linear_2d: R^2 -> Z, x -> floor(exp(2 * x[0]) - 3 * x[1]);
let R_scalar_non_linear_2d: R^2 -> R, x -> 2 * exp(x[0]) + 3 * x[1];
let R1_non_linear_2d: R^2 -> R^1, x -> 2 * exp(x[0]);
-let R2_non_linear_2d: R^2 -> R^2, x -> (2 * exp(x[0]), -3*x[1]);
-let R3_non_linear_2d: R^2 -> R^3, x -> (2 * exp(x[0]) + 3, x[1] - 2, 3);
+let R2_non_linear_2d: R^2 -> R^2, x -> [2 * exp(x[0]), -3*x[1]];
+let R3_non_linear_2d: R^2 -> R^3, x -> [2 * exp(x[0]) + 3, x[1] - 2, 3];
let R1x1_non_linear_2d: R^2 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[1]) + 3);
-let R2x2_non_linear_2d: R^2 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3, x[1] * x[0]);
-let R3x3_non_linear_2d: R^2 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3, x[1] * x[0], -4*x[1], 2*x[0]+1, 3, -6*x[0], exp(x[1]));
+let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0])], [3, x[1] * x[0]]];
+let R3x3_non_linear_2d: R^2 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[0]), 3], [x[1] * x[0], -4*x[1], 2*x[0]+1], [3, -6*x[0], exp(x[1])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -754,11 +754,11 @@ let N_scalar_non_linear_3d: R^3 -> N, x -> floor(3 * (x[0] + x[1]) * (x[0] + x[1
let Z_scalar_non_linear_3d: R^3 -> Z, x -> floor(exp(2 * x[0]) - 3 * x[1] + x[2]);
let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]+x[2]) + 3 * x[1];
let R1_non_linear_3d: R^3 -> R^1, x -> 2 * exp(x[0])+sin(x[1] + x[2]);
-let R2_non_linear_3d: R^3 -> R^2, x -> (2 * exp(x[0]), -3*x[1] * x[2]);
-let R3_non_linear_3d: R^3 -> R^3, x -> (2 * exp(x[0]) + 3, x[1] - 2, 3 * x[2]);
+let R2_non_linear_3d: R^3 -> R^2, x -> [2 * exp(x[0]), -3*x[1] * x[2]];
+let R3_non_linear_3d: R^3 -> R^3, x -> [2 * exp(x[0]) + 3, x[1] - 2, 3 * x[2]];
let R1x1_non_linear_3d: R^3 -> R^1x1, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * x[2]);
-let R2x2_non_linear_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[2] - 2 * x[0]), 3, x[1] * x[0] - x[2]);
-let R3x3_non_linear_3d: R^3 -> R^3x3, x -> (2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[2]), 3, x[1] * x[2], -4*x[1], 2*x[2]+1, 3, -6*x[2], exp(x[1] + x[2]));
+let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[2] - 2 * x[0])], [3, x[1] * x[0] - x[2]]];
+let R3x3_non_linear_3d: R^3 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(x[1] - 2 * x[2]), 3], [x[1] * x[2], -4*x[1], 2*x[2]+1], [3, -6*x[2], exp(x[1] + x[2])]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_DiscreteFunctionVectorIntegrator.cpp b/tests/test_DiscreteFunctionVectorIntegrator.cpp
index d0a9d6a78fd260c0b259aa630d9e79f85271ae89..31fd447f525f2b002ead1246219319454c792588 100644
--- a/tests/test_DiscreteFunctionVectorIntegrator.cpp
+++ b/tests/test_DiscreteFunctionVectorIntegrator.cpp
@@ -348,7 +348,7 @@ let B_scalar_non_linear_2d: R^2 -> B, x -> (exp(2 * x[0] + x[1]) + 3 > 4);
let N_scalar_non_linear_1d: R^1 -> N, x -> floor(3 * x[0] * x[0] + 2);
let Z_scalar_non_linear_3d: R^3 -> Z, x -> floor(exp(2 * x[1]) - x[2]);
let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
-let R2_scalar_non_linear_3d: R^3 -> R^2, x -> (2 * exp(x[0] + x[1]) + 3 * x[2], x[0] - x[1]);
+let R2_scalar_non_linear_3d: R^3 -> R^2, x -> [2 * exp(x[0] + x[1]) + 3 * x[2], x[0] - x[1]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_DiscreteFunctionVectorInterpoler.cpp b/tests/test_DiscreteFunctionVectorInterpoler.cpp
index 692dd8c6c18ad85f87f5c85dcc41a6bcb0838312..3c3fefc38aba5b7377a86eb28ce4c6439ed82164 100644
--- a/tests/test_DiscreteFunctionVectorInterpoler.cpp
+++ b/tests/test_DiscreteFunctionVectorInterpoler.cpp
@@ -390,7 +390,7 @@ let B_scalar_non_linear_2d: R^2 -> B, x -> (exp(2 * x[0] + x[1]) + 3 > 4);
let N_scalar_non_linear_1d: R^1 -> N, x -> floor(3 * x[0] * x[0] + 2);
let Z_scalar_non_linear_3d: R^3 -> Z, x -> floor(exp(2 * x[1]) - x[2]);
let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
-let R2_scalar_non_linear_3d: R^3 -> R^2, x -> (2 * exp(x[0] + x[1]) + 3 * x[2], x[0] - x[1]);
+let R2_scalar_non_linear_3d: R^3 -> R^2, x -> [2 * exp(x[0] + x[1]) + 3 * x[2], x[0] - x[1]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp b/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
index 172c68d4f59f318d0f36c315aaf4962e71195dbe..c3605a232c7b032ad4215db72cdf711695818c6e 100644
--- a/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
+++ b/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
@@ -443,7 +443,7 @@ let B_scalar_non_linear_2d: R^2 -> B, x -> (exp(2 * x[0] + x[1]) + 3 > 4);
let N_scalar_non_linear_1d: R^1 -> N, x -> floor(3 * x[0] * x[0] + 2);
let Z_scalar_non_linear_3d: R^3 -> Z, x -> floor(exp(2 * x[1]) - x[2]);
let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
-let R2_scalar_non_linear_3d: R^3 -> R^2, x -> (2 * exp(x[0] + x[1]) + 3 * x[2], x[0] - x[1]);
+let R2_scalar_non_linear_3d: R^3 -> R^2, x -> [2 * exp(x[0] + x[1]) + 3 * x[2], x[0] - x[1]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_FunctionArgumentConverter.cpp b/tests/test_FunctionArgumentConverter.cpp
index 643fbba0b092d337743ea5aeaedb25eb86a5b445..909353f79e3b7a1dcada5bfcaba92d80967420f6 100644
--- a/tests/test_FunctionArgumentConverter.cpp
+++ b/tests/test_FunctionArgumentConverter.cpp
@@ -136,6 +136,34 @@ TEST_CASE("FunctionArgumentConverter", "[language]")
"unexpected error: cannot convert 'unsigned long' to 'TinyVector<3ul, double>'");
}
+ SECTION("FunctionTupleArgumentConverter (string tuple)")
+ {
+ const TinyVector<3> x3{1.7, 2.9, -3};
+ FunctionTupleArgumentConverter<std::string, TinyVector<3>> converter0{0};
+ converter0.convert(execution_policy, TinyVector{x3});
+
+ FunctionTupleArgumentConverter<std::string, std::vector<std::string>> converter1{1};
+ converter1.convert(execution_policy, std::vector<std::string>{"foo"});
+
+ FunctionTupleArgumentConverter<std::string, std::vector<TinyVector<3>>> converter2{2};
+ converter2.convert(execution_policy, std::vector<TinyVector<3>>{TinyVector<3>{1, 2, 3}});
+
+ REQUIRE(std::get<std::vector<std::string>>(execution_policy.currentContext()[0]) ==
+ std::vector<std::string>{[](auto x) {
+ std::ostringstream os;
+ os << x;
+ return os.str();
+ }(x3)});
+ REQUIRE(std::get<std::vector<std::string>>(execution_policy.currentContext()[1]) ==
+ std::vector<std::string>{"foo"});
+
+ REQUIRE(std::get<std::vector<std::string>>(execution_policy.currentContext()[2]) == std::vector<std::string>{[]() {
+ std::ostringstream os;
+ os << TinyVector<3>{1, 2, 3};
+ return os.str();
+ }()});
+ }
+
SECTION("FunctionListArgumentConverter")
{
const uint64_t i = 3;
diff --git a/tests/test_FunctionProcessor.cpp b/tests/test_FunctionProcessor.cpp
index 5c72fd0d7b96a4919490b6707bde1bef03aa0b28..7a1780e900efb31addcab6112ebc6424c5547d52 100644
--- a/tests/test_FunctionProcessor.cpp
+++ b/tests/test_FunctionProcessor.cpp
@@ -358,7 +358,7 @@ let fx:R^1, fx = f(x);
{
std::string_view data = R"(
let f : R^2 -> R^2, x -> 2*x;
-let x:R^2, x = (3, 7);
+let x:R^2, x = [3, 7];
let fx:R^2, fx = f(x);
)";
@@ -369,9 +369,8 @@ let fx:R^2, fx = f(x);
{
std::string_view data = R"(
let f : R^3 -> R^3, x -> 2*x;
-let x:R^3, x = (2, 4, 7);
-let fx:R^3, fx = f(x);
+let fx:R^3, fx = f([2, 4, 7]);
)";
CHECK_FUNCTION_EVALUATION_RESULT(data, "fx", (2 * TinyVector<3>{2, 4, 7}));
}
@@ -390,7 +389,7 @@ let fx:R^1, fx = f(x);
SECTION(" R*R -> R^2")
{
std::string_view data = R"(
-let f : R*R -> R^2, (x,y) -> (2*x, 3*y);
+let f : R*R -> R^2, (x,y) -> [2*x, 3*y];
let fx:R^2, fx = f(2, 3);
)";
CHECK_FUNCTION_EVALUATION_RESULT(data, "fx", (TinyVector<2>{2 * 2, 3 * 3}));
@@ -399,7 +398,7 @@ let fx:R^2, fx = f(2, 3);
SECTION(" R -> R^3")
{
std::string_view data = R"(
-let f : R -> R^3, x -> (x, 2*x, x*x);
+let f : R -> R^3, x -> [x, 2*x, x*x];
let fx:R^3, fx = f(3);
)";
@@ -424,9 +423,8 @@ let fx:R^1x1, fx = f(x);
{
std::string_view data = R"(
let f : R^2x2 -> R^2x2, x -> 2*x;
-let x:R^2x2, x = (3, 7, 6, -2);
-let fx:R^2x2, fx = f(x);
+let fx:R^2x2, fx = f([[3, 7], [6, -2]]);
)";
CHECK_FUNCTION_EVALUATION_RESULT(data, "fx", (2 * TinyMatrix<2>{3, 7, 6, -2}));
}
@@ -435,7 +433,7 @@ let fx:R^2x2, fx = f(x);
{
std::string_view data = R"(
let f : R^3x3 -> R^3x3, x -> 2*x;
-let x:R^3x3, x = (2, 4, 7, 1, 3, 5, -6, 2, -3);
+let x:R^3x3, x = [[2, 4, 7],[1, 3, 5],[-6, 2, -3]];
let fx:R^3x3, fx = f(x);
)";
@@ -456,7 +454,7 @@ let fx:R^1x1, fx = f(x);
SECTION(" R*R -> R^2x2")
{
std::string_view data = R"(
-let f : R*R -> R^2x2, (x,y) -> (2*x, 3*y, 5*(x-y), 2*x-y);
+let f : R*R -> R^2x2, (x,y) -> [[2*x, 3*y], [5*(x-y), 2*x-y]];
let fx:R^2x2, fx = f(2, 3);
)";
@@ -468,7 +466,7 @@ let fx:R^2x2, fx = f(2, 3);
SECTION(" R -> R^3x3")
{
std::string_view data = R"(
-let f : R -> R^3x3, x -> (x, 2*x, x*x, 3*x, 2+x, x-1, x+0.5, 2*x-1, 1/x);
+let f : R -> R^3x3, x -> [[x, 2*x, x*x], [3*x, 2+x, x-1], [x+0.5, 2*x-1, 1/x]];
let fx:R^3x3, fx = f(3);
)";
@@ -485,7 +483,7 @@ let fx:R^3x3, fx = f(3);
SECTION(" R -> R*R^1*R^2*R^3")
{
std::string_view data = R"(
-let f : R -> R*R^1*R^2*R^3, x -> (x+1, 2*x, (x-2, x+2), (1, 0.5*x, x*x));
+let f : R -> R*R^1*R^2*R^3, x -> (x+1, 2*x, [x-2, x+2], [1, 0.5*x, x*x]);
let (x, x1, x2, x3):R*R^1*R^2*R^3, (x, x1, x2, x3) = f(3);
)";
@@ -501,10 +499,10 @@ let (x, x1, x2, x3):R*R^1*R^2*R^3, (x, x1, x2, x3) = f(3);
{
std::string_view data = R"(
let f : R^2*R^3 -> R*R^1*R^2*R^3,
- (x2, x3) -> (x2[0]+x3[2], x3[1], (x3[0], x2[1]), (x3[0], x3[0]+x2[1], x3[2]));
+ (x2, x3) -> (x2[0]+x3[2], [x3[1]], [x3[0], x2[1]], [x3[0], x3[0]+x2[1], x3[2]]);
-let y2:R^2, y2 = (2.3, 4.1);
-let y3:R^3, y3 = (1.2, 1.3, 2.1);
+let y2:R^2, y2 = [2.3, 4.1];
+let y3:R^3, y3 = [1.2, 1.3, 2.1];
let(x, x1, x2, x3) : R*R^1*R^2*R^3, (x, x1, x2, x3) = f(y2, y3);
)";
@@ -520,9 +518,9 @@ let(x, x1, x2, x3) : R*R^1*R^2*R^3, (x, x1, x2, x3) = f(y2, y3);
{
std::string_view data = R"(
let f : R^2*R^3 -> R*R^1*R^2*R^3,
- (x2, x3) -> (x2[0]+x3[2], x3[1], (x3[0], x2[1]), (x3[0], x3[0]+x2[1], x3[2]));
+ (x2, x3) -> (x2[0]+x3[2], [x3[1]], [x3[0], x2[1]], [x3[0], x3[0]+x2[1], x3[2]]);
-let y2:R^2, y2 = (2.3, 4.1);
+let y2:R^2, y2 = [2.3, 4.1];
let (x, x1, x2, x3) : R*R^1*R^2*R^3, (x, x1, x2, x3) = f(y2, 0);
)";
@@ -540,7 +538,7 @@ let (x, x1, x2, x3) : R*R^1*R^2*R^3, (x, x1, x2, x3) = f(y2, 0);
let f : R^2*R^3 -> R*R^1*R^2*R^3,
(x2, x3) -> (x2[0]+x3[2], x3[1], 0, 0);
-let y2:R^2, y2 = (2.3, 4.1);
+let y2:R^2, y2 = [2.3, 4.1];
let (x, x1, x2, x3):R*R^1*R^2*R^3, (x, x1, x2, x3) = f(y2, 0);
)";
@@ -558,7 +556,7 @@ let (x, x1, x2, x3):R*R^1*R^2*R^3, (x, x1, x2, x3) = f(y2, 0);
SECTION(" R -> R*R^1x1*R^2x2*R^3x3")
{
std::string_view data = R"(
-let f : R -> R*R^1x1*R^2x2*R^3x3, x -> (x+1, 2*x, (x-2, x+2, 3, 2), (1, 0.5*x, x*x, x+1, 1/x, 2, x*x, 2*x-1, 3*x));
+let f : R -> R*R^1x1*R^2x2*R^3x3, x -> (x+1, 2*x, [[x-2, x+2], [3, 2]], [[1, 0.5*x, x*x], [x+1, 1/x, 2], [x*x, 2*x-1, 3*x]]);
let (x, x11, x22, x33):R*R^1x1*R^2x2*R^3x3, (x, x11, x22, x33) = f(3);
)";
@@ -575,10 +573,10 @@ let (x, x11, x22, x33):R*R^1x1*R^2x2*R^3x3, (x, x11, x22, x33) = f(3);
{
std::string_view data = R"(
let f : R^2x2*R^3x3 -> R*R^1x1*R^2x2*R^3x3,
- (x22, x33) -> (x22[0,0]+x33[2,0], x33[1,2], (x33[0,1], x22[1,1], x22[0,0], x33[2,2]), x22[0,0]*x33);
+ (x22, x33) -> (x22[0,0]+x33[2,0], x33[1,2], [[x33[0,1], x22[1,1]], [x22[0,0], x33[2,2]]], x22[0,0]*x33);
-let y22:R^2x2, y22 = (2.3, 4.1, 6, -3);
-let y33:R^3x3, y33 = (1.2, 1.3, 2.1, 3.2, -1.5, 2.3, -0.2, 3.1, -2.6);
+let y22:R^2x2, y22 = [[2.3, 4.1], [6, -3]];
+let y33:R^3x3, y33 = [[1.2, 1.3, 2.1], [3.2,-1.5, 2.3],[-0.2, 3.1, -2.6]];
let(x, x11, x22, x33) : R*R^1x1*R^2x2*R^3x3, (x, x11, x22, x33) = f(y22, y33);
)";
@@ -594,15 +592,15 @@ let(x, x11, x22, x33) : R*R^1x1*R^2x2*R^3x3, (x, x11, x22, x33) = f(y22, y33);
{
std::string_view data = R"(
let f : R^2x2*R^3x3 -> R*R^1x1*R^2x2*R^3x3,
- (x22, x33) -> (x22[0,0]+x33[2,1], x33[1,2], (x33[0,1], x22[1,0], x22[0,1], x33[2,2]),
- (x22[1,0], x33[0,2]+x22[1,1], x33[2,2],
- x33[2,0], x33[2,0]+x22[0,0], x33[1,1],
- x33[2,1], x33[1,2]+x22[1,1], x33[0,0]));
-
-let y22:R^2x2, y22 = (2.3, 4.1, 3.1, 1.7);
-let y33:R^3x3, y33 = (2.7, 3.1, 2.1,
- 0.3, 1.2, 1.6,
- 1.7, 2.2, 1.4);
+ (x22, x33) -> (x22[0,0]+x33[2,1], x33[1,2], [[x33[0,1], x22[1,0]], [x22[0,1], x33[2,2]]],
+ [[x22[1,0], x33[0,2]+x22[1,1], x33[2,2]],
+ [x33[2,0], x33[2,0]+x22[0,0], x33[1,1]],
+ [x33[2,1], x33[1,2]+x22[1,1], x33[0,0]]]);
+
+let y22:R^2x2, y22 = [[2.3, 4.1], [3.1, 1.7]];
+let y33:R^3x3, y33 = [[2.7, 3.1, 2.1],
+ [0.3, 1.2, 1.6],
+ [1.7, 2.2, 1.4]];
let (x, x11, x22, x33) : R*R^1x1*R^2x2*R^3x3, (x, x11, x22, x33) = f(y22, y33);
)";
@@ -623,7 +621,7 @@ let (x, x11, x22, x33) : R*R^1x1*R^2x2*R^3x3, (x, x11, x22, x33) = f(y22, y33);
let f : R^2x2*R^3x3 -> R*R^1x1*R^2x2*R^3x3,
(x22, x33) -> (x22[0,0]+x33[2,0], x33[1,1], 0, 0);
-let y22:R^2x2, y22 = (2.3, 4.1, 3.1, 1.7);
+let y22:R^2x2, y22 = [[2.3, 4.1],[3.1, 1.7]];
let (x, x11, x22, x33):R*R^1x1*R^2x2*R^3x3, (x, x11, x22, x33) = f(y22, 0);
)";
@@ -675,7 +673,7 @@ let x:R, x = pow(f(2));
SECTION("R -> R^2 -> R")
{
std::string_view data = R"(
-let f : R -> R^2, x -> (x+1, x*2);
+let f : R -> R^2, x -> [x+1, x*2];
let g : R^2 -> R, x -> x[0] + x[1];
let x:R, x = g(f(3));
@@ -688,7 +686,7 @@ let x:R, x = g(f(3));
SECTION("R -> R^2*R^3 -> R")
{
std::string_view data = R"(
-let f : R -> R^2*R^3, x -> ((x+1, x*2), (6*x, 7-x, x/2.3));
+let f : R -> R^2*R^3, x -> ([x+1, x*2], [6*x, 7-x, x/2.3]);
let g : R^2*R^3 -> R, (x, y) -> x[0]*x[1] + y[0]*y[1]-y[2];
let x:R, x = g(f(3));
@@ -701,7 +699,7 @@ let x:R, x = g(f(3));
SECTION("R -> R^2x2 -> R")
{
std::string_view data = R"(
-let f : R -> R^2x2, x -> (x+1, x*2, x-1, x);
+let f : R -> R^2x2, x -> [[x+1, x*2], [x-1, x]];
let g : R^2x2 -> R, A -> A[0,0] + 2*A[1,1] + 3*A[0,1]+ A[1, 0];
let x:R, x = g(f(3));
@@ -715,7 +713,7 @@ let x:R, x = g(f(3));
SECTION("R -> R^2x2*R^3x3 -> R")
{
std::string_view data = R"(
-let f : R -> R^2x2*R^3x3, x -> ((x+1, x*2, x-1, x), (6*x, 7-x, x/2.3, -x, 2*x, x/2.5, x*x, 2*x, x));
+let f : R -> R^2x2*R^3x3, x -> ([[x+1, x*2], [x-1, x]], [[6*x, 7-x, x/2.3], [-x, 2*x, x/2.5], [x*x, 2*x, x]]);
let g : R^2x2*R^3x3 -> R, (A22, A33) -> A22[0,0]*A22[1,1] + (A33[0,0]*A33[1,0]-A33[2,2])*A22[0,1]-A33[2,0]*A33[0,2]-A22[1,1];
let x:R, x = g(f(3));
diff --git a/tests/test_IntegrateCellValue.cpp b/tests/test_IntegrateCellValue.cpp
index df35a215bea28b236cd2bcd7b243e2f759c4f40b..5df4d0c447c50751db43c0ce2db5345612fc514f 100644
--- a/tests/test_IntegrateCellValue.cpp
+++ b/tests/test_IntegrateCellValue.cpp
@@ -56,7 +56,7 @@ TEST_CASE("IntegrateCellValue", "[language]")
std::string_view data = R"(
import math;
-let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
+let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -113,7 +113,7 @@ let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x
std::string_view data = R"(
import math;
-let R3_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
+let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -325,7 +325,7 @@ let scalar_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
std::string_view data = R"(
import math;
-let R3_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
+let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -404,7 +404,7 @@ let R3_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
std::string_view data = R"(
import math;
-let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]);
+let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2])], [3, x[0] * x[1] * x[2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_IntegrateOnCells.cpp b/tests/test_IntegrateOnCells.cpp
index cf2d770265fd3dbf1812b14606aa7fadda972d05..80463f0831bc21c3c172bb62b0564c261629b7f0 100644
--- a/tests/test_IntegrateOnCells.cpp
+++ b/tests/test_IntegrateOnCells.cpp
@@ -59,8 +59,8 @@ TEST_CASE("IntegrateOnCells", "[language]")
std::string_view data = R"(
import math;
let scalar_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
-let R3_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
-let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
+let R3_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
+let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -159,8 +159,8 @@ let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x
std::string_view data = R"(
import math;
let scalar_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
-let R3_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
-let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x[0]*x[1]);
+let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
+let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3, x[0]*x[1]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -272,8 +272,8 @@ let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x
std::string_view data = R"(
import math;
let scalar_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
-let R3_3d: R^3 -> R^3, x -> (2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3);
-let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]);
+let R3_3d: R^3 -> R^3, x -> [2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3];
+let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2])], [3, x[0] * x[1] * x[2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -400,8 +400,8 @@ let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(
std::string_view data = R"(
import math;
let scalar_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
-let R3_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
-let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
+let R3_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
+let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -510,8 +510,8 @@ let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x
std::string_view data = R"(
import math;
let scalar_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
-let R3_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
-let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x[0]*x[1]);
+let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
+let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3, x[0]*x[1]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -633,8 +633,8 @@ let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x
std::string_view data = R"(
import math;
let scalar_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
-let R3_3d: R^3 -> R^3, x -> (2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3);
-let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]);
+let R3_3d: R^3 -> R^3, x -> [2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3];
+let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2])], [3, x[0] * x[1] * x[2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -755,8 +755,8 @@ let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(
std::string_view data = R"(
import math;
let scalar_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
-let R3_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
-let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
+let R3_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
+let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -855,8 +855,8 @@ let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x
std::string_view data = R"(
import math;
let scalar_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
-let R3_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
-let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x[0]*x[1]);
+let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
+let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3, x[0]*x[1]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -968,8 +968,8 @@ let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x
std::string_view data = R"(
import math;
let scalar_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
-let R3_3d: R^3 -> R^3, x -> (2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3);
-let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]);
+let R3_3d: R^3 -> R^3, x -> [2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3];
+let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2])], [3, x[0] * x[1] * x[2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1096,8 +1096,8 @@ let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(
std::string_view data = R"(
import math;
let scalar_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
-let R3_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
-let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
+let R3_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
+let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1206,8 +1206,8 @@ let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x
std::string_view data = R"(
import math;
let scalar_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
-let R3_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
-let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x[0]*x[1]);
+let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
+let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3, x[0]*x[1]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1329,8 +1329,8 @@ let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x
std::string_view data = R"(
import math;
let scalar_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
-let R3_3d: R^3 -> R^3, x -> (2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3);
-let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]);
+let R3_3d: R^3 -> R^3, x -> [2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3];
+let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2])], [3, x[0] * x[1] * x[2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1451,8 +1451,8 @@ let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(
std::string_view data = R"(
import math;
let scalar_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
-let R3_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
-let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
+let R3_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
+let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1551,8 +1551,8 @@ let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x
std::string_view data = R"(
import math;
let scalar_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
-let R3_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
-let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x[0]*x[1]);
+let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
+let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3, x[0]*x[1]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1664,8 +1664,8 @@ let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x
std::string_view data = R"(
import math;
let scalar_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
-let R3_3d: R^3 -> R^3, x -> (2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3);
-let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]);
+let R3_3d: R^3 -> R^3, x -> [2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3];
+let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2])], [3, x[0] * x[1] * x[2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1792,8 +1792,8 @@ let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(
std::string_view data = R"(
import math;
let scalar_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
-let R3_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
-let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
+let R3_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
+let R2x2_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -1902,8 +1902,8 @@ let R2x2_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x
std::string_view data = R"(
import math;
let scalar_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
-let R3_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
-let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x[0]*x[1]);
+let R3_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
+let R2x2_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3, x[0]*x[1]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -2025,8 +2025,8 @@ let R2x2_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x
std::string_view data = R"(
import math;
let scalar_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
-let R3_3d: R^3 -> R^3, x -> (2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3);
-let R2x2_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]);
+let R3_3d: R^3 -> R^3, x -> [2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3];
+let R2x2_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2])], [3, x[0] * x[1] * x[2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_InterpolateItemValue.cpp b/tests/test_InterpolateItemValue.cpp
index 1d7032c660ee001d652339abc0d2daee8a825fff..45832349fd50410aa70cadfb6df74ad59156c045 100644
--- a/tests/test_InterpolateItemValue.cpp
+++ b/tests/test_InterpolateItemValue.cpp
@@ -56,10 +56,10 @@ TEST_CASE("InterpolateItemValue", "[language]")
import math;
let scalar_affine_1d: R^1 -> R, x -> 2*x[0] + 2;
let scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
-let R3_affine_1d: R^1 -> R^3, x -> (2 * x[0] + 2, 3 * x[0], 2);
-let R3_non_linear_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
-let R2x2_affine_1d: R^1 -> R^2x2, x -> (2 * x[0] + 3 + 2, 3 * x[0], 2 * x[0], 2);
-let R2x2_non_linear_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
+let R3_affine_1d: R^1 -> R^3, x -> [2 * x[0] + 2, 3 * x[0], 2];
+let R3_non_linear_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
+let R2x2_affine_1d: R^1 -> R^2x2, x -> [[2 * x[0] + 3 + 2, 3 * x[0]], [2 * x[0], 2]];
+let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -227,10 +227,10 @@ let R2x2_non_linear_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x
import math;
let scalar_affine_2d: R^2 -> R, x -> 2*x[0] + 3*x[1] + 2;
let scalar_non_linear_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
-let R3_affine_2d: R^2 -> R^3, x -> (2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1], 2 * x[1]);
-let R3_non_linear_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
-let R2x2_affine_2d: R^2 -> R^2x2, x -> (2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1], 2 * x[0] + x[1], 2);
-let R2x2_non_linear_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x[0]*x[1]);
+let R3_affine_2d: R^2 -> R^3, x -> [2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1], 2 * x[1]];
+let R3_non_linear_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
+let R2x2_affine_2d: R^2 -> R^2x2, x -> [[2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1]], [2 * x[0] + x[1], 2]];
+let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3, x[0]*x[1]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -392,10 +392,10 @@ let R2x2_non_linear_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*
import math;
let scalar_affine_3d: R^3 -> R, x -> 2 * x[0] + 3 * x[1] + 2 * x[2] - 1;
let scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
-let R3_affine_3d: R^3 -> R^3, x -> (2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1] + 2 * x[2], 2 * x[2]);
-let R3_non_linear_3d: R^3 -> R^3, x -> (2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3);
-let R2x2_affine_3d: R^3 -> R^2x2, x -> (2 * x[0] + 3 * x[1] + 2 * x[2] + 1, 3 * x[0] + x[1] + 2 * x[2], 2 * x[0] + x[1] + x[2], 2);
-let R2x2_non_linear_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]);
+let R3_affine_3d: R^3 -> R^3, x -> [2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1] + 2 * x[2], 2 * x[2]];
+let R3_non_linear_3d: R^3 -> R^3, x -> [2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3];
+let R2x2_affine_3d: R^3 -> R^2x2, x -> [[2 * x[0] + 3 * x[1] + 2 * x[2] + 1, 3 * x[0] + x[1] + 2 * x[2]], [2 * x[0] + x[1] + x[2], 2]];
+let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2])], [3, x[0] * x[1] * x[2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -579,10 +579,10 @@ let R2x2_non_linear_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(
import math;
let scalar_affine_1d: R^1 -> R, x -> 2*x[0] + 2;
let scalar_non_linear_1d: R^1 -> R, x -> 2 * exp(x[0]) + 3;
-let R3_affine_1d: R^1 -> R^3, x -> (2 * x[0] + 2, 3 * x[0], 2);
-let R3_non_linear_1d: R^1 -> R^3, x -> (2 * exp(x[0]) + 3, x[0] - 2, 3);
-let R2x2_affine_1d: R^1 -> R^2x2, x -> (2 * x[0] + 3 + 2, 3 * x[0], 2 * x[0], 2);
-let R2x2_non_linear_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0]), 3, x[0] * x[0]);
+let R3_affine_1d: R^1 -> R^3, x -> [2 * x[0] + 2, 3 * x[0], 2];
+let R3_non_linear_1d: R^1 -> R^3, x -> [2 * exp(x[0]) + 3, x[0] - 2, 3];
+let R2x2_affine_1d: R^1 -> R^2x2, x -> [[2 * x[0] + 3 + 2, 3 * x[0]], [2 * x[0], 2]];
+let R2x2_non_linear_1d: R^1 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[0]) + 3, sin(x[0] - 2 * x[0])], [3, x[0] * x[0]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -758,10 +758,10 @@ let R2x2_non_linear_1d: R^1 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[0]) + 3, sin(x
import math;
let scalar_affine_2d: R^2 -> R, x -> 2*x[0] + 3*x[1] + 2;
let scalar_non_linear_2d: R^2 -> R, x -> 2*exp(x[0])*sin(x[1])+3;
-let R3_affine_2d: R^2 -> R^3, x -> (2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1], 2 * x[1]);
-let R3_non_linear_2d: R^2 -> R^3, x -> (2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3);
-let R2x2_affine_2d: R^2 -> R^2x2, x -> (2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1], 2 * x[0] + x[1], 2);
-let R2x2_non_linear_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1]), 3, x[0]*x[1]);
+let R3_affine_2d: R^2 -> R^3, x -> [2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1], 2 * x[1]];
+let R3_non_linear_2d: R^2 -> R^3, x -> [2*exp(x[0])*sin(x[1])+3, x[0]-2*x[1], 3];
+let R2x2_affine_2d: R^2 -> R^2x2, x -> [[2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1]], [2 * x[0] + x[1], 2]];
+let R2x2_non_linear_2d: R^2 -> R^2x2, x -> [[2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*x[1])], [3, x[0]*x[1]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
@@ -932,10 +932,10 @@ let R2x2_non_linear_2d: R^2 -> R^2x2, x -> (2*exp(x[0])*sin(x[1])+3, sin(x[0]-2*
import math;
let scalar_affine_3d: R^3 -> R, x -> 2 * x[0] + 3 * x[1] + 2 * x[2] - 1;
let scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0]) * sin(x[1]) * x[2] + 3;
-let R3_affine_3d: R^3 -> R^3, x -> (2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1] + 2 * x[2], 2 * x[2]);
-let R3_non_linear_3d: R^3 -> R^3, x -> (2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3);
-let R2x2_affine_3d: R^3 -> R^2x2, x -> (2 * x[0] + 3 * x[1] + 2 * x[2] + 1, 3 * x[0] + x[1] + 2 * x[2], 2 * x[0] + x[1] + x[2], 2);
-let R2x2_non_linear_3d: R^3 -> R^2x2, x -> (2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2]), 3, x[0] * x[1] * x[2]);
+let R3_affine_3d: R^3 -> R^3, x -> [2 * x[0] + 3 * x[1] + 2, 3 * x[0] + x[1] + 2 * x[2], 2 * x[2]];
+let R3_non_linear_3d: R^3 -> R^3, x -> [2 * exp(x[0]) * sin(x[1]) + x[2] + 3, x[0] * x[2] - 2 * x[1], 3];
+let R2x2_affine_3d: R^3 -> R^2x2, x -> [[2 * x[0] + 3 * x[1] + 2 * x[2] + 1, 3 * x[0] + x[1] + 2 * x[2]], [2 * x[0] + x[1] + x[2], 2]];
+let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos(x[2]), sin(x[0] - 2 * x[1] * x[2])], [3, x[0] * x[1] * x[2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_ListAffectationProcessor.cpp b/tests/test_ListAffectationProcessor.cpp
index f84ee471a7b2b4621ca4ef45d7c9a07610484a38..219b9a2f16907f3d6010d3144b7d2b903455d6fa 100644
--- a/tests/test_ListAffectationProcessor.cpp
+++ b/tests/test_ListAffectationProcessor.cpp
@@ -49,42 +49,36 @@
TEST_CASE("ListAffectationProcessor", "[language]")
{
- SECTION("ListAffectations")
+ auto stringify = [](auto&& value) {
+ std::ostringstream os;
+ os << std::boolalpha << value;
+ return os.str();
+ };
+
+ SECTION("basic types list affectations")
{
SECTION("R*R^2*R^2x2*string")
{
- CHECK_AFFECTATION_RESULT(R"(let (x,u,A,s): R*R^2*R^2x2*string, (x,u,A,s) = (1.2, (2,3), (4,3,2,1), "foo");)", "x",
- double{1.2});
- CHECK_AFFECTATION_RESULT(R"(let (x,u,A,s): R*R^2*R^2x2*string, (x,u,A,s) = (1.2, (2,3), (4,3,2,1), "foo");)", "u",
- (TinyVector<2>{2, 3}));
- CHECK_AFFECTATION_RESULT(R"(let (x,u,A,s): R*R^2*R^2x2*string, (x,u,A,s) = (1.2, (2,3), (4,3,2,1), "foo");)", "A",
- (TinyMatrix<2>{4, 3, 2, 1}));
- CHECK_AFFECTATION_RESULT(R"(let (x,u,A,s): R*R^2*R^2x2*string, (x,u,A,s) = (1.2, (2,3), (4,3,2,1), "foo");)", "s",
- std::string{"foo"});
+ CHECK_AFFECTATION_RESULT(R"(let (x,u,A,s): R*R^2*R^2x2*string, (x,u,A,s) = (1.2, [2,3], [[4,3],[2,1]], "foo");)",
+ "x", double{1.2});
+ CHECK_AFFECTATION_RESULT(R"(let (x,u,A,s): R*R^2*R^2x2*string, (x,u,A,s) = (1.2, [2,3], [[4,3],[2,1]], "foo");)",
+ "u", (TinyVector<2>{2, 3}));
+ CHECK_AFFECTATION_RESULT(R"(let (x,u,A,s): R*R^2*R^2x2*string, (x,u,A,s) = (1.2, [2,3], [[4,3],[2,1]], "foo");)",
+ "A", (TinyMatrix<2>{4, 3, 2, 1}));
+ CHECK_AFFECTATION_RESULT(R"(let (x,u,A,s): R*R^2*R^2x2*string, (x,u,A,s) = (1.2, [2,3], [[4,3],[2,1]], "foo");)",
+ "s", std::string{"foo"});
}
SECTION("compound with string conversion")
{
- CHECK_AFFECTATION_RESULT(R"(let z:R, z = 3; let (x,u,s):R*R^2*string, (x,u,s) = (1.2, (2,3), z);)", "s",
- std::to_string(double{3}));
- {
- std::ostringstream os;
- os << TinyVector<1>{7};
- CHECK_AFFECTATION_RESULT(R"(let v:R^1, v = 7; let (x,u,s):R*R^2*string, (x,u,s) = (1.2, (2,3), v);)", "s",
- os.str());
- }
- {
- std::ostringstream os;
- os << TinyVector<2>{6, 3};
- CHECK_AFFECTATION_RESULT(R"(let v: R^2, v = (6,3); let (x,u,s):R*R^2*string, (x,u,s) = (1.2, (2,3), v);)", "s",
- os.str());
- }
- {
- std::ostringstream os;
- os << TinyVector<3>{1, 2, 3};
- CHECK_AFFECTATION_RESULT(R"(let v:R^3, v = (1,2,3); let (x,u,s):R*R^2*string, (x,u,s) = (1.2, (2,3), v);)", "s",
- os.str());
- }
+ CHECK_AFFECTATION_RESULT(R"(let z:R, z = 3; let (x,u,s):R*R^2*string, (x,u,s) = (1.2, [2,3], z);)", "s",
+ stringify(double{3}));
+ CHECK_AFFECTATION_RESULT(R"(let v:R^1, v = 7; let (x,u,s):R*R^2*string, (x,u,s) = (1.2, [2,3], v);)", "s",
+ stringify(TinyVector<1>{7}));
+ CHECK_AFFECTATION_RESULT(R"(let v: R^2, v = [6,3]; let (x,u,s):R*R^2*string, (x,u,s) = (1.2, [2,3], v);)", "s",
+ stringify(TinyVector<2>{6, 3}));
+ CHECK_AFFECTATION_RESULT(R"(let v:R^3, v = [1,2,3]; let (x,u,s):R*R^2*string, (x,u,s) = (1.2, [2,3], v);)", "s",
+ stringify(TinyVector<3>{1, 2, 3}));
}
SECTION("compound R^d from '0'")
@@ -101,4 +95,647 @@ TEST_CASE("ListAffectationProcessor", "[language]")
CHECK_AFFECTATION_RESULT(R"(let (x,y,z):R^3x3*R^2x2*R^1x1, (x,y,z) = (0,0,0);)", "z", (TinyMatrix<1>{zero}));
}
}
+
+ SECTION("lists with tuples affectation")
+ {
+ auto stringify = [](auto&& value) {
+ std::ostringstream os;
+ os << std::boolalpha << value;
+ return os.str();
+ };
+
+ SECTION("with (B)")
+ {
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let (b1,b2): (B)*(B), (b1,b2) = (false, true);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "b1", (std::vector<bool>{false}));
+ CHECK_AFFECTATION_RESULT(data, "b2", (std::vector<bool>{true}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (b1,b2): (B)*B, (b1,b2) = ((true,false), true);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "b1", (std::vector<bool>{true, false}));
+ CHECK_AFFECTATION_RESULT(data, "b2", true);
+ }
+
+ SECTION("from (B)")
+ {
+ std::string_view data = R"(
+let b : (B), b = (true, false);
+let (b1,b2) : (B)*B, (b1,b2) = (b, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "b1", (std::vector<bool>{true, false}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+ }
+
+ SECTION("(N)")
+ {
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let n:N, n = 9;
+let (n1,n2,n3): (N)*(N)*(N), (n1,n2,n3) = (false, 1, n);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "n1", (std::vector<uint64_t>{false}));
+ CHECK_AFFECTATION_RESULT(data, "n2", (std::vector<uint64_t>{1}));
+ CHECK_AFFECTATION_RESULT(data, "n3", (std::vector<uint64_t>{9}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (n,m) :(N)*N, (n,m) = ((1,2,3), 7);
+)";
+ CHECK_AFFECTATION_RESULT(data, "n", (std::vector<uint64_t>{1, 2, 3}));
+ CHECK_AFFECTATION_RESULT(data, "m", 7ul);
+ }
+
+ SECTION("from (B)")
+ {
+ std::string_view data = R"(
+let b :(B), b = (true,false,true);
+let (n,m) :(N)*(N), (n,m) = (b, (false,true));
+)";
+ CHECK_AFFECTATION_RESULT(data, "n", (std::vector<uint64_t>{1, 0, 1}));
+ CHECK_AFFECTATION_RESULT(data, "m", (std::vector<uint64_t>{0, 1}));
+ }
+
+ SECTION("from (N)")
+ {
+ std::string_view data = R"(
+let l:(N), l = (1,2,3);
+let (n,m):(N)*(N), (n,m) = (l,(2,3,1));
+)";
+ CHECK_AFFECTATION_RESULT(data, "n", (std::vector<uint64_t>{1, 2, 3}));
+ CHECK_AFFECTATION_RESULT(data, "m", (std::vector<uint64_t>{2, 3, 1}));
+ }
+
+ SECTION("from (Z)")
+ {
+ std::string_view data = R"(
+let z:(Z), z = (1,2,3);
+let (n,x):(N)*R, (n,x) = (z,2.3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "n", (std::vector<uint64_t>{1, 2, 3}));
+ CHECK_AFFECTATION_RESULT(data, "x", double{2.3});
+ }
+ }
+
+ SECTION("(Z)")
+ {
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let n:N, n = 9;
+let (z1,z2,z3): (Z)*(Z)*(Z), (z1,z2,z3) = (false, -1, n);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "z1", (std::vector<int64_t>{false}));
+ CHECK_AFFECTATION_RESULT(data, "z2", (std::vector<int64_t>{-1}));
+ CHECK_AFFECTATION_RESULT(data, "z3", (std::vector<int64_t>{9}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (z1,z2):(Z)*(Z), (z1,z2) = ((1,2,3),(2,1,3));
+)";
+ CHECK_AFFECTATION_RESULT(data, "z1", (std::vector<int64_t>{1, 2, 3}));
+ CHECK_AFFECTATION_RESULT(data, "z2", (std::vector<int64_t>{2, 1, 3}));
+ }
+
+ SECTION("from (N)")
+ {
+ std::string_view data = R"(
+let m : (N), m = (1,2,3);
+let (z,n) : (Z)*N, (z,n) = (m,2);
+)";
+ CHECK_AFFECTATION_RESULT(data, "z", (std::vector<int64_t>{1, 2, 3}));
+ CHECK_AFFECTATION_RESULT(data, "n", 2ul);
+ }
+
+ SECTION("from (Z)")
+ {
+ std::string_view data = R"(
+let z0:(Z), z0 = (1,2,3);
+let (z,a): (Z)*Z, (z,a) = (z0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "z", (std::vector<int64_t>{1, 2, 3}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+ }
+
+ SECTION("(R)")
+ {
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let n:N, n = 9;
+let (r1,r2,r3,r4): (R)*(R)*(R)*(R), (r1,r2,r3,r4) = (false, -1, n, 2.3);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "r1", (std::vector<double>{false}));
+ CHECK_AFFECTATION_RESULT(data, "r2", (std::vector<double>{-1}));
+ CHECK_AFFECTATION_RESULT(data, "r3", (std::vector<double>{9}));
+ CHECK_AFFECTATION_RESULT(data, "r4", (std::vector<double>{2.3}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (r1,r2):(R)*(R), (r1,r2) = ((1.2,2,3.1),(2.4,1,1.3));
+)";
+ CHECK_AFFECTATION_RESULT(data, "r1", (std::vector<double>{1.2, 2, 3.1}));
+ CHECK_AFFECTATION_RESULT(data, "r2", (std::vector<double>{2.4, 1, 1.3}));
+ }
+
+ SECTION("from (N)")
+ {
+ std::string_view data = R"(
+let m : (N), m = (1,2,3);
+let (r,n) : (R)*N, (r,n) = (m,2);
+)";
+ CHECK_AFFECTATION_RESULT(data, "r", (std::vector<double>{1, 2, 3}));
+ CHECK_AFFECTATION_RESULT(data, "n", 2ul);
+ }
+
+ SECTION("from (Z)")
+ {
+ std::string_view data = R"(
+let z0:(Z), z0 = (1,2,3);
+let (r,a): (R)*Z, (r,a) = (z0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "r", (std::vector<double>{1, 2, 3}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+
+ SECTION("from (R)")
+ {
+ std::string_view data = R"(
+let r0:(R), r0 = (1.2,2,3);
+let (r,a): (R)*Z, (r,a) = (r0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "r", (std::vector<double>{1.2, 2, 3}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+ }
+
+ SECTION("(R^1)")
+ {
+ using R1 = TinyVector<1>;
+
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let n:N, n = 9;
+let (X1,X2,X3,X4,X5): (R^1)*(R^1)*(R^1)*(R^1)*(R^1), (X1,X2,X3,X4,X5) = (false, -1, n, 2.3, [7.2]);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R1>{R1(false)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R1>{R1(-1)}));
+ CHECK_AFFECTATION_RESULT(data, "X3", (std::vector<R1>{R1(9)}));
+ CHECK_AFFECTATION_RESULT(data, "X4", (std::vector<R1>{R1(2.3)}));
+ CHECK_AFFECTATION_RESULT(data, "X5", (std::vector<R1>{R1(7.2)}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (X1,X2):(R^1)*(R^1), (X1,X2) = (([1.2],2,3.1),([2.4],1, true,1.3));
+)";
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R1>{R1(1.2), R1(2), R1(3.1)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R1>{R1(2.4), R1(1), R1(true), R1(1.3)}));
+ }
+
+ SECTION("from (N)")
+ {
+ std::string_view data = R"(
+let m : (N), m = (1,2,3);
+let (X,n) : (R^1)*N, (X,n) = (m,2);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1>{R1(1), R1(2), R1(3)}));
+ CHECK_AFFECTATION_RESULT(data, "n", 2ul);
+ }
+
+ SECTION("from (Z)")
+ {
+ std::string_view data = R"(
+let z0:(Z), z0 = (1,2,3);
+let (X,a): (R^1)*Z, (X,a) = (z0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1>{R1(1), R1(2), R1(3)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+
+ SECTION("from (R)")
+ {
+ std::string_view data = R"(
+let r0:(R), r0 = (1.2,2,3);
+let (X,a): (R^1)*Z, (X,a) = (r0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1>{R1(1.2), R1(2), R1(3)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+
+ SECTION("from (R^1)")
+ {
+ std::string_view data = R"(
+let X0:(R^1), X0 = (1.2,2,3);
+let (X,a): (R^1)*Z, (X,a) = (X0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1>{R1(1.2), R1(2), R1(3)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+ }
+
+ SECTION("R^2")
+ {
+ using R2 = TinyVector<2>;
+
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let (X1,X2): (R^2)*(R^2), (X1,X2) = ([1,2], 0);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R2>{R2(1, 2)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R2>{R2(0, 0)}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (X1,X2):(R^2)*(R^2), (X1,X2) = (([1.2, 2],0,[3,1]),([2.4,1],[true,1.3]));
+)";
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R2>{R2(1.2, 2), R2(0, 0), R2(3, 1)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R2>{R2(2.4, 1), R2(true, 1.3)}));
+ }
+
+ SECTION("from (R^2)")
+ {
+ std::string_view data = R"(
+let X0:(R^2), X0 = ([1.2,2],[3,1],0);
+let (X,a): (R^2)*Z, (X,a) = (X0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R2>{R2(1.2, 2), R2(3, 1), R2(0, 0)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+ }
+
+ SECTION("R^3")
+ {
+ using R3 = TinyVector<3>;
+
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let (X1,X2): (R^3)*(R^3), (X1,X2) = ([1,2,3], 0);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R3>{R3(1, 2, 3)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R3>{R3(0, 0, 0)}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (X1,X2):(R^3)*(R^3), (X1,X2) = (([5, 1.2, 2],0,[3,6,1]),([2.4,1,1.3],[true,1.3,2]));
+)";
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R3>{R3(5, 1.2, 2), R3(0, 0, 0), R3(3, 6, 1)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R3>{R3(2.4, 1, 1.3), R3(true, 1.3, 2)}));
+ }
+
+ SECTION("from (R^3)")
+ {
+ std::string_view data = R"(
+let X0:(R^3), X0 = ([1.2,-1.3,2],[3,1,5],0);
+let (X,a): (R^3)*Z, (X,a) = (X0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R3>{R3(1.2, -1.3, 2), R3(3, 1, 5), R3(0, 0, 0)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+ }
+
+ SECTION("R^1x1")
+ {
+ using R1x1 = TinyMatrix<1>;
+
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let n:N, n = 9;
+let (X1,X2,X3,X4,X5): (R^1x1)*(R^1x1)*(R^1x1)*(R^1x1)*(R^1x1), (X1,X2,X3,X4,X5) = (false, -1, n, 2.3, [[7.2]]);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R1x1>{R1x1(false)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R1x1>{R1x1(-1)}));
+ CHECK_AFFECTATION_RESULT(data, "X3", (std::vector<R1x1>{R1x1(9)}));
+ CHECK_AFFECTATION_RESULT(data, "X4", (std::vector<R1x1>{R1x1(2.3)}));
+ CHECK_AFFECTATION_RESULT(data, "X5", (std::vector<R1x1>{R1x1(7.2)}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (X1,X2):(R^1x1)*(R^1x1), (X1,X2) = (([[1.2]],2,3.1),([[2.4]],1, true,1.3));
+)";
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R1x1>{R1x1(1.2), R1x1(2), R1x1(3.1)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R1x1>{R1x1(2.4), R1x1(1), R1x1(true), R1x1(1.3)}));
+ }
+
+ SECTION("from (N)")
+ {
+ std::string_view data = R"(
+let m : (N), m = (1,2,3);
+let (X,n) : (R^1x1)*N, (X,n) = (m,2);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1x1>{R1x1(1), R1x1(2), R1x1(3)}));
+ CHECK_AFFECTATION_RESULT(data, "n", 2ul);
+ }
+
+ SECTION("from (Z)")
+ {
+ std::string_view data = R"(
+let z0:(Z), z0 = (1,2,3);
+let (X,a): (R^1x1)*Z, (X,a) = (z0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1x1>{R1x1(1), R1x1(2), R1x1(3)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+
+ SECTION("from (R)")
+ {
+ std::string_view data = R"(
+let r0:(R), r0 = (1.2,2,3);
+let (X,a): (R^1x1)*Z, (X,a) = (r0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1x1>{R1x1(1.2), R1x1(2), R1x1(3)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+
+ SECTION("from (R^1x1)")
+ {
+ std::string_view data = R"(
+let X0:(R^1x1), X0 = (1.2,2,3);
+let (X,a): (R^1x1)*Z, (X,a) = (X0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X", (std::vector<R1x1>{R1x1(1.2), R1x1(2), R1x1(3)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+ }
+
+ SECTION("R^2x2")
+ {
+ using R2x2 = TinyMatrix<2>;
+
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let (X1,X2): (R^2x2)*(R^2x2), (X1,X2) = ([[1,2],[3,4]], 0);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R2x2>{R2x2(1, 2, 3, 4)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R2x2>{R2x2(0, 0, 0, 0)}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (X1,X2):(R^2x2)*(R^2x2), (X1,X2) = (([[1.2, 2],[7,4]],0,[[3,1],[5,2]]),([[2.4,1],[1,3]],[[true,1.3],[2,2]]));
+)";
+ CHECK_AFFECTATION_RESULT(data, "X1",
+ (std::vector<R2x2>{R2x2(1.2, 2, 7, 4), R2x2(0, 0, 0, 0), R2x2(3, 1, 5, 2)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R2x2>{R2x2(2.4, 1, 1, 3), R2x2(true, 1.3, 2, 2)}));
+ }
+
+ SECTION("from (R^2x2)")
+ {
+ std::string_view data = R"(
+let X0:(R^2x2), X0 = ([[1.2,2],[3,1]],[[3,1],[5,8]],0);
+let (X,a): (R^2x2)*Z, (X,a) = (X0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X",
+ (std::vector<R2x2>{R2x2(1.2, 2, 3, 1), R2x2(3, 1, 5, 8), R2x2(0, 0, 0, 0)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+ }
+
+ SECTION("R^3x3")
+ {
+ using R3x3 = TinyMatrix<3>;
+
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let (X1,X2): (R^3x3)*(R^3x3), (X1,X2) = ([[1,2,3],[4,5,6],[7,8,9]], 0);
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "X1", (std::vector<R3x3>{R3x3(1, 2, 3, 4, 5, 6, 7, 8, 9)}));
+ CHECK_AFFECTATION_RESULT(data, "X2", (std::vector<R3x3>{R3x3(0, 0, 0, 0, 0, 0, 0, 0, 0)}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let (X1,X2):(R^3x3)*(R^3x3), (X1,X2) = (([[1.2, 2, 1],[3,1,9],[7,5,4]],0,[[3,0.3,1],[5,7,2],[2,1,8]]),([[3,2.4,1],[2,1,3],[2.2,1.8,3]],[[true,2,1.3],[2.1,4,2],[1.2,2.4,1.2]]));
+)";
+ CHECK_AFFECTATION_RESULT(data, "X1",
+ (std::vector<R3x3>{R3x3(1.2, 2, 1, 3, 1, 9, 7, 5, 4), R3x3(0, 0, 0, 0, 0, 0, 0, 0, 0),
+ R3x3(3, 0.3, 1, 5, 7, 2, 2, 1, 8)}));
+ CHECK_AFFECTATION_RESULT(data, "X2",
+ (std::vector<R3x3>{R3x3(3, 2.4, 1, 2, 1, 3, 2.2, 1.8, 3),
+ R3x3(true, 2, 1.3, 2.1, 4, 2, 1.2, 2.4, 1.2)}));
+ }
+
+ SECTION("from (R^3x3)")
+ {
+ std::string_view data = R"(
+let X0:(R^3x3), X0 = ([[1.2,7,2],[2,1,6],[1,3,1]],[[3,1,6],[2,7,1],[1,5,8]]);
+let (X,a): (R^3x3)*Z, (X,a) = (X0,3);
+)";
+ CHECK_AFFECTATION_RESULT(data, "X",
+ (std::vector<R3x3>{R3x3(1.2, 7, 2, 2, 1, 6, 1, 3, 1),
+ R3x3(3, 1, 6, 2, 7, 1, 1, 5, 8)}));
+ CHECK_AFFECTATION_RESULT(data, "a", 3l);
+ }
+ }
+
+ SECTION("with (string)")
+ {
+ SECTION("from value")
+ {
+ std::string_view data = R"(
+let n: N, n = 3;
+let (s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11)
+ : (string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string)*(string),
+ (s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11) = (false, n, 1, 1.3, [1], [1,2], [1,2,3], [[1]], [[1,2],[3,4]], [[1,2,3],[4,5,6],[7,8,9]], "foo");
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "s1", (std::vector<std::string>{stringify(false)}));
+ CHECK_AFFECTATION_RESULT(data, "s2", (std::vector<std::string>{stringify(3ul)}));
+ CHECK_AFFECTATION_RESULT(data, "s3", (std::vector<std::string>{stringify(1l)}));
+ CHECK_AFFECTATION_RESULT(data, "s4", (std::vector<std::string>{stringify(double{1.3})}));
+ CHECK_AFFECTATION_RESULT(data, "s5", (std::vector<std::string>{stringify(TinyVector<1>{1})}));
+ CHECK_AFFECTATION_RESULT(data, "s6", (std::vector<std::string>{stringify(TinyVector<2>{1, 2})}));
+ CHECK_AFFECTATION_RESULT(data, "s7", (std::vector<std::string>{stringify(TinyVector<3>{1, 2, 3})}));
+ CHECK_AFFECTATION_RESULT(data, "s8", (std::vector<std::string>{stringify(TinyMatrix<1>{1})}));
+ CHECK_AFFECTATION_RESULT(data, "s9", (std::vector<std::string>{stringify(TinyMatrix<2>{1, 2, 3, 4})}));
+ CHECK_AFFECTATION_RESULT(data, "s10",
+ (std::vector<std::string>{stringify(TinyMatrix<3>{1, 2, 3, 4, 5, 6, 7, 8, 9})}));
+ CHECK_AFFECTATION_RESULT(data, "s11", (std::vector<std::string>{stringify("foo")}));
+ }
+
+ SECTION("from list")
+ {
+ std::string_view data = R"(
+let n: N, n = 3;
+let (s1,s2): (string)*string,
+ (s1,s2) = ((false, n, 1, 1.3, [1], [1,2], [1,2,3], [[1]], [[1,2],[3,4]], [[1,2,3],[4,5,6],[7,8,9]], "foo"), "bar");
+)";
+
+ CHECK_AFFECTATION_RESULT(data, "s1",
+ (std::vector<std::string>{stringify(false), stringify(3ul), stringify(1l),
+ stringify(double{1.3}), stringify(TinyVector<1>{1}),
+ stringify(TinyVector<2>{1, 2}),
+ stringify(TinyVector<3>{1, 2, 3}),
+ stringify(TinyMatrix<1>{1}),
+ stringify(TinyMatrix<2>{1, 2, 3, 4}),
+ stringify(TinyMatrix<3>{1, 2, 3, 4, 5, 6, 7, 8, 9}),
+ stringify("foo")}));
+ CHECK_AFFECTATION_RESULT(data, "s2", std::string("bar"));
+ }
+
+ SECTION("from (B)")
+ {
+ std::string_view data = R"(
+let b : (B), b = (true, false);
+let (s1,b2) : (string)*B, (s1,b2) = (b, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1", (std::vector<std::string>{stringify(true), stringify(false)}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (N)")
+ {
+ std::string_view data = R"(
+let n : (N), n = (1, 2);
+let (s1,b2) : (string)*B, (s1,b2) = (n, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1", (std::vector<std::string>{stringify(1ul), stringify(2ul)}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (Z)")
+ {
+ std::string_view data = R"(
+let z : (Z), z = (1, -2);
+let (s1,b2) : (string)*B, (s1,b2) = (z, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1", (std::vector<std::string>{stringify(1l), stringify(-2l)}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (R)")
+ {
+ std::string_view data = R"(
+let r : (R), r = (1, -2.3);
+let (s1,b2) : (string)*B, (s1,b2) = (r, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1", (std::vector<std::string>{stringify(double{1}), stringify(double{-2.3})}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (R^1)")
+ {
+ std::string_view data = R"(
+let r : (R^1), r = (1, -2.3);
+let (s1,b2) : (string)*B, (s1,b2) = (r, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1",
+ (std::vector<std::string>{stringify(TinyVector<1>{1}),
+ stringify(TinyVector<1>{-2.3})}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (R^2)")
+ {
+ std::string_view data = R"(
+let r : (R^2), r = ([1,2],[-2.3,4]);
+let (s1,b2) : (string)*B, (s1,b2) = (r, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1",
+ (std::vector<std::string>{stringify(TinyVector<2>{1, 2}),
+ stringify(TinyVector<2>{-2.3, 4})}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (R^3)")
+ {
+ std::string_view data = R"(
+let r : (R^3), r = ([1,2,3],[-2.3,4,7]);
+let (s1,b2) : (string)*B, (s1,b2) = (r, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1",
+ (std::vector<std::string>{stringify(TinyVector<3>{1, 2, 3}),
+ stringify(TinyVector<3>{-2.3, 4, 7})}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (R^1x1)")
+ {
+ std::string_view data = R"(
+let r : (R^1x1), r = (1, -2.3);
+let (s1,b2) : (string)*B, (s1,b2) = (r, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1",
+ (std::vector<std::string>{stringify(TinyMatrix<1>{1}),
+ stringify(TinyMatrix<1>{-2.3})}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (R^2x2)")
+ {
+ std::string_view data = R"(
+let r : (R^2x2), r = ([[1,2],[3,4]], [[-2.3,4],[7,2]]);
+let (s1,b2) : (string)*B, (s1,b2) = (r, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1",
+ (std::vector<std::string>{stringify(TinyMatrix<2>{1, 2, 3, 4}),
+ stringify(TinyMatrix<2>{-2.3, 4, 7, 2})}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (R^3)")
+ {
+ std::string_view data = R"(
+let r : (R^3x3), r = ([[1,2,3],[4,5,6],[7,8,9]], [[-2.3,4,7],[6,2,1],[8,3,4]]);
+let (s1,b2) : (string)*B, (s1,b2) = (r, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1",
+ (std::vector<std::string>{stringify(TinyMatrix<3>{1, 2, 3, 4, 5, 6, 7, 8, 9}),
+ stringify(TinyMatrix<3>{-2.3, 4, 7, 6, 2, 1, 8, 3, 4})}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+
+ SECTION("from (string)")
+ {
+ std::string_view data = R"(
+let s : (string), s = ("foo", "bar", "foobar");
+let (s1,b2) : (string)*B, (s1,b2) = (s, false);
+)";
+ CHECK_AFFECTATION_RESULT(data, "s1", (std::vector<std::string>{"foo", "bar", "foobar"}));
+ CHECK_AFFECTATION_RESULT(data, "b2", false);
+ }
+ }
+ }
}
diff --git a/tests/test_PugsFunctionAdapter.cpp b/tests/test_PugsFunctionAdapter.cpp
index d8708c49a9601d38602251a5179cad939382f291..9e645802fde6e286abfeb57e7c4c35dd584583c4 100644
--- a/tests/test_PugsFunctionAdapter.cpp
+++ b/tests/test_PugsFunctionAdapter.cpp
@@ -72,7 +72,7 @@ let BandB: B*B -> B, (a,b) -> a and b;
let NplusN: N*N -> N, (x,y) -> x+y;
let ZplusZ: Z*Z -> Z, (x,y) -> x+y;
let RplusR: R*R -> R, (x,y) -> x+y;
-let RRtoR2: R*R -> R^2, (x,y) -> (x+y, x-y);
+let RRtoR2: R*R -> R^2, (x,y) -> [x+y, x-y];
let R3times2: R^3 -> R^3, x -> 2*x;
let R33times2: R^3x3 -> R^3x3, x -> 2*x;
let BtoR1: B -> R^1, b -> not b;
@@ -368,11 +368,11 @@ let R33toR33zero: R^3x3 -> R^3x3, x -> 0;
std::string_view data = R"(
let R1toR1: R^1 -> R^1, x -> x;
let R3toR3: R^3 -> R^3, x -> 0;
-let RRRtoR3: R*R*R -> R^3, (x,y,z) -> (x,y,z);
-let R3toR2: R^3 -> R^2, x -> (x[0],x[1]+x[2]);
+let RRRtoR3: R*R*R -> R^3, (x,y,z) -> [x,y,z];
+let R3toR2: R^3 -> R^2, x -> [x[0],x[1]+x[2]];
let RtoNS: R -> N*string, x -> (1, "foo");
let RtoR: R -> R, x -> 2*x;
-let R33toR22: R^3x3 -> R^2x2, x -> (x[0,0], x[0,1]+x[0,2], x[2,0]*x[1,1], x[2,1]+x[2,2]);
+let R33toR22: R^3x3 -> R^2x2, x -> [[x[0,0], x[0,1]+x[0,2]], [x[2,0]*x[1,1], x[2,1]+x[2,2]]];
)";
TAO_PEGTL_NAMESPACE::string_input input{data, "test.pgs"};
diff --git a/tests/test_TinyMatrix.cpp b/tests/test_TinyMatrix.cpp
index 81c187dc2f5c7663fb7491cfa5c68fc2fc2d7eb6..2f4c09d4ad9ce1dbb5e3d856d8737d27344459f2 100644
--- a/tests/test_TinyMatrix.cpp
+++ b/tests/test_TinyMatrix.cpp
@@ -272,8 +272,8 @@ TEST_CASE("TinyMatrix", "[algebra]")
SECTION("checking for matrices output")
{
- REQUIRE(Catch::Detail::stringify(A) == "[(1,2,3,4)(5,6,7,8)(9,10,11,12)]");
- REQUIRE(Catch::Detail::stringify(TinyMatrix<1, 1, int>(7)) == "[(7)]");
+ REQUIRE(Catch::Detail::stringify(A) == "[[1,2,3,4],[5,6,7,8],[9,10,11,12]]");
+ REQUIRE(Catch::Detail::stringify(TinyMatrix<1, 1, int>(7)) == "[[7]]");
}
#ifndef NDEBUG
@@ -287,7 +287,7 @@ TEST_CASE("TinyMatrix", "[algebra]")
A_ost << A;
std::ostringstream ref_ost;
- ref_ost << "[(1,nan,3)(2,nan,nan)]";
+ ref_ost << "[[1,nan,3],[2,nan,nan]]";
REQUIRE(A_ost.str() == ref_ost.str());
}
diff --git a/tests/test_TinyVector.cpp b/tests/test_TinyVector.cpp
index 0613e721cbce46386e6b1c86c3bc3e1123fdd1aa..9c4dc2e5a2c4b185904fcf04a706fa70b572a197 100644
--- a/tests/test_TinyVector.cpp
+++ b/tests/test_TinyVector.cpp
@@ -30,7 +30,7 @@ TEST_CASE("TinyVector", "[algebra]")
REQUIRE(((z[0] == 0) and (z[1] == 0) and (z[2] == 0)));
v = TinyVector<3, int>(3, 2, 4);
- REQUIRE(Catch::Detail::stringify(v) == "(3,2,4)");
+ REQUIRE(Catch::Detail::stringify(v) == "[3,2,4]");
TinyVector<3, int> w(1, 2, 6);
REQUIRE(dot(v, w) == 31);
@@ -96,7 +96,7 @@ TEST_CASE("TinyVector", "[algebra]")
x_ost << x;
std::ostringstream ref_ost;
- ref_ost << "(nan,1,nan)";
+ ref_ost << "[nan,1,nan]";
REQUIRE(x_ost.str() == ref_ost.str());
}
diff --git a/tests/test_TupleToVectorProcessor.cpp b/tests/test_TupleToVectorProcessor.cpp
index 817e5c9ba54af0664a34045d5de528f80c59db4a..74865d2ce1019e19e2474f059fde4708a2e5e735 100644
--- a/tests/test_TupleToVectorProcessor.cpp
+++ b/tests/test_TupleToVectorProcessor.cpp
@@ -77,17 +77,17 @@ TEST_CASE("TupleToVectorProcessor", "[language]")
SECTION("Return tuple -> R^3")
{
std::string_view data = R"(
-let f: R*R*R->R^3, (x,y,z) -> (x,y,z);
+let f: R*R*R->R^3, (x,y,z) -> [y,z,x];
let x:R^3, x = f(1,2,3);
)";
- CHECK_EVALUATION_RESULT(data, "x", (TinyVector<3>{1, 2, 3}));
+ CHECK_EVALUATION_RESULT(data, "x", (TinyVector<3>{2, 3, 1}));
}
SECTION("Return tuple -> R^2")
{
std::string_view data = R"(
-let f: R^3->R^2, x -> (x[2],x[1]);
-let x:R^3, x = (1,2,3);
+let f: R^3->R^2, x -> [x[2],x[1]];
+let x:R^3, x = [1,2,3];
let y:R^2, y = f(x);
)";
CHECK_EVALUATION_RESULT(data, "y", (TinyVector<2>{3, 2}));