Allow conversion of scalars to R^1 for builtin functions arguments

src/language/ast/ASTNodeBuiltinFunctionExpressionBuilder.cpp

@@ -39,6 +39,39 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
   auto get_function_argument_converter_for_vector =
     [&](const auto& parameter_v) -> std::unique_ptr<IFunctionArgumentConverter> {
     using ParameterT = std::decay_t<decltype(parameter_v)>;
+
+    if constexpr (std::is_same_v<ParameterT, TinyVector<1>>) {
+      switch (argument_node_sub_data_type.m_data_type) {
+      case ASTNodeDataType::vector_t: {
+        if (argument_node_sub_data_type.m_data_type.dimension() == 1) {
+          return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, ParameterT>>(argument_number);
+        } else {
+          // LCOV_EXCL_START
+          throw parse_error("unexpected error: invalid argument dimension",
+                            std::vector{argument_node_sub_data_type.m_parent_node.begin()});
+          // LCOV_EXCL_STOP
+        }
+      }
+      case ASTNodeDataType::bool_t: {
+        return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, bool>>(argument_number);
+      }
+      case ASTNodeDataType::int_t: {
+        return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, int64_t>>(argument_number);
+      }
+      case ASTNodeDataType::unsigned_int_t: {
+        return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, uint64_t>>(argument_number);
+      }
+      case ASTNodeDataType::double_t: {
+        return std::make_unique<FunctionTinyVectorArgumentConverter<ParameterT, double>>(argument_number);
+      }
+        // LCOV_EXCL_START
+      default: {
+        throw parse_error("unexpected error: invalid argument type",
+                          std::vector{argument_node_sub_data_type.m_parent_node.begin()});
+      }
+        // LCOV_EXCL_STOP
+      }
+    } else {
       switch (argument_node_sub_data_type.m_data_type) {
       case ASTNodeDataType::vector_t: {
         if (argument_node_sub_data_type.m_data_type.dimension() == parameter_v.dimension()) {
@@ -75,6 +108,7 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
       }
         // LCOV_EXCL_STOP
       }
+    }
   };
 
   auto get_function_argument_to_string_converter = [&]() -> std::unique_ptr<IFunctionArgumentConverter> {
@@ -318,7 +352,11 @@ ASTNodeBuiltinFunctionExpressionBuilder::_getArgumentConverter(const ASTNodeData
     }
   };
 
+  if (parameter_type == ASTNodeDataType::vector_t and parameter_type.dimension() == 1) {
+    ASTNodeNaturalConversionChecker{argument_node_sub_data_type, ASTNodeDataType::double_t};
+  } else {
     ASTNodeNaturalConversionChecker{argument_node_sub_data_type, parameter_type};
+  }
 
   return get_function_argument_converter_for_argument_type();
 }

src/language/ast/ASTNodeNaturalConversionChecker.cpp

@@ -28,7 +28,6 @@ ASTNodeNaturalConversionChecker::_checkIsNaturalExpressionConversion(const ASTNo
                                                                      const ASTNodeDataType& target_data_type) const
 {
   if (target_data_type == ASTNodeDataType::vector_t) {
-    // Only R^d data is considered
     switch (node.m_data_type) {
     case ASTNodeDataType::list_t: {
       if (node.children.size() != target_data_type.dimension()) {