Add binary operators for vectors: '+','-','==' and '!='

src/language/ASTNodeBinaryOperatorExpressionBuilder.cpp

@@ -49,6 +49,19 @@ ASTNodeBinaryOperatorExpressionBuilder::ASTNodeBinaryOperatorExpressionBuilder(A
         } else {
           throw parse_error("undefined operand type for binary operator", std::vector{n.begin()});
         }
+      } else if constexpr (std::is_same_v<DataTA, TinyVector<1>> or std::is_same_v<DataTA, TinyVector<2>> or
+                           std::is_same_v<DataTA, TinyVector<3>>) {
+        if ((data_type_b == ASTNodeDataType::vector_t) and (data_a.dimension() == data_type_b.dimension())) {
+          if constexpr (std::is_same_v<OperatorT, language::plus_op> or std::is_same_v<OperatorT, language::minus_op> or
+                        std::is_same_v<OperatorT, language::eqeq_op> or
+                        std::is_same_v<OperatorT, language::not_eq_op>) {
+            n.m_node_processor = std::make_unique<BinaryExpressionProcessor<OperatorT, DataTA, DataTA>>(n);
+          } else {
+            throw parse_error("invalid binary operator", std::vector{n.begin()});
+          }
+        } else {
+          throw parse_error("invalid operand type for binary operator", std::vector{n.children[1]->begin()});
+        }
       } else {
         switch (data_type_b) {
         case ASTNodeDataType::bool_t: {
@@ -97,6 +110,26 @@ ASTNodeBinaryOperatorExpressionBuilder::ASTNodeBinaryOperatorExpressionBuilder(A
         set_binary_operator_processor_for_data_b(std::string{}, data_type_b);
         break;
       }
+      case ASTNodeDataType::vector_t: {
+        switch (data_type_a.dimension()) {
+        case 1: {
+          set_binary_operator_processor_for_data_b(TinyVector<1>{}, data_type_b);
+          break;
+        }
+        case 2: {
+          set_binary_operator_processor_for_data_b(TinyVector<2>{}, data_type_b);
+          break;
+        }
+        case 3: {
+          set_binary_operator_processor_for_data_b(TinyVector<3>{}, data_type_b);
+          break;
+        }
+        default: {
+          throw parse_error("unexpected error invalid dimension", std::vector{n.children[0]->begin()});
+        }
+        }
+        break;
+      }
       default: {
         throw parse_error("undefined operand type for binary operator", std::vector{n.children[0]->begin()});
       }