Fixes for array op vector:

Author: Pencilcaseman

CMakeLists.txt

@@ -435,6 +435,9 @@ add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/librapid/vendor/xsimd")
 target_compile_definitions(fmt PUBLIC FMT_HEADER_ONLY)
 target_link_libraries(${module_name} PUBLIC fmt xsimd)
 
+# Disable "parameter passing for argument of type ... changed to match ..." for xsimd
+target_compile_options(xsimd INTERFACE -Wno-psabi)
+
 if (${LIBRAPID_USE_MULTIPREC})
     # Load MPIR
     find_package(MPIR QUIET)

librapid/include/librapid/array/arrayContainer.hpp

@@ -56,7 +56,13 @@ namespace librapid {
 			static constexpr bool supportsArithmetic   = TypeInfo<Scalar>::supportsArithmetic;
 			static constexpr bool supportsLogical	   = TypeInfo<Scalar>::supportsLogical;
 			static constexpr bool supportsBinary	   = TypeInfo<Scalar>::supportsBinary;
-			static constexpr bool allowVectorisation   = TypeInfo<Scalar>::packetWidth > 1;
+			static constexpr bool allowVectorisation   = []() {
+				  if constexpr (typetraits::HasAllowVectorisation<TypeInfo<Scalar>>::value) {
+					  return TypeInfo<Scalar>::allowVectorisation;
+				  } else {
+					  return TypeInfo<Scalar>::packetWidth > 1;
+				  }
+			}();
 
 #if defined(LIBRAPID_HAS_CUDA)
 			static constexpr cudaDataType_t CudaType = TypeInfo<Scalar>::CudaType;
@@ -67,15 +73,6 @@ namespace librapid {
 			static constexpr int64_t canMemcpy = false;
 		};
 
-		/// Evaluates as true if the input type is an ArrayContainer instance
-		/// \tparam T Input type
-		template<typename T>
-		struct IsArrayContainer : std::false_type {};
-
-		template<typename ShapeType, typename StorageScalar>
-		struct IsArrayContainer<array::ArrayContainer<ShapeType, StorageScalar>> : std::true_type {
-		};
-
 		LIBRAPID_DEFINE_AS_TYPE(typename StorageScalar,
 								array::ArrayContainer<Shape COMMA StorageScalar>);
 
@@ -686,7 +683,7 @@ namespace librapid {
 			  sizeof...(Indices),
 			  m_shape.ndim());
 
-			int dim = 0;
+			int dim		  = 0;
 			int64_t index = 0;
 			for (int64_t i : {indices...}) {
 				LIBRAPID_ASSERT(

librapid/include/librapid/array/assignOps.hpp

@@ -24,11 +24,18 @@ namespace librapid {
 			using Function = detail::Function<descriptor::Trivial, Functor_, Args...>;
 			using Scalar =
 			  typename array::ArrayContainer<ShapeType_, Storage<StorageScalar>>::Scalar;
-			constexpr int64_t packetWidth = typetraits::TypeInfo<Scalar>::packetWidth;
 			constexpr bool allowVectorisation =
 			  typetraits::TypeInfo<
 				detail::Function<descriptor::Trivial, Functor_, Args...>>::allowVectorisation &&
 			  Function::argsAreSameType;
+			// constexpr int64_t packetWidth = typetraits::TypeInfo<Scalar>::packetWidth;
+			constexpr int64_t packetWidth = []() {
+				if constexpr (allowVectorisation) {
+					return typetraits::TypeInfo<Scalar>::packetWidth;
+				} else {
+					return 1;
+				}
+			}();
 
 			const int64_t size		 = function.shape().size();
 			const int64_t vectorSize = size - (size % packetWidth);

librapid/include/librapid/array/function.hpp

@@ -35,13 +35,60 @@ namespace librapid {
 			}
 		}
 
+		// Normally, we want to use the scalar type of the input. This said, there are a few edge
+		// cases where it is necessary to use the type itself.
+
+		// Default
+		template<typename T>
+		struct ScalarTypeHelper {
+			using Type = typename TypeInfo<std::decay_t<T>>::Scalar;
+		};
+
+		// Vectors
+		template<typename T, uint64_t NumDims>
+		struct ScalarTypeHelper<Vector<T, NumDims>> {
+			using Type = Vector<T, NumDims>;
+		};
+
+		// Once we have the correct scalar types, we need to check if the result is a lazy-evaluated
+		// function. If so, we need to extract the actual return type from the function.
+
+		// Default
+		template<typename T>
+		struct ReturnTypeHelper {
+			using Type = T;
+		};
+
+		// Binary vector operation
+		template<typename LHS, typename RHS, typename Op>
+		struct ReturnTypeHelper<vectorDetail::BinaryVecOp<LHS, RHS, Op>> {
+			using IntermediateType = vectorDetail::BinaryVecOp<LHS, RHS, Op>;
+			using Type			   = decltype(std::declval<IntermediateType>().eval());
+		};
+
+		// Unary vector operation
+		template<typename Val, typename Op>
+		struct ReturnTypeHelper<vectorDetail::UnaryVecOp<Val, Op>> {
+			using IntermediateType = vectorDetail::UnaryVecOp<Val, Op>;
+			using Type			   = decltype(std::declval<IntermediateType>().eval());
+		};
+
 		template<typename desc, typename Functor_, typename... Args>
 		struct TypeInfo<::librapid::detail::Function<desc, Functor_, Args...>> {
 			static constexpr detail::LibRapidType type = detail::LibRapidType::ArrayFunction;
-			using Scalar							   = decltype(std::declval<Functor_>()(
-				std::declval<typename TypeInfo<std::decay_t<Args>>::Scalar>()...));
-			using Packet							   = typename TypeInfo<Scalar>::Packet;
-			using Backend							   = decltype(commonBackend<Args...>());
+			// using Scalar	= decltype(std::declval<Functor_>()(
+			// 		std::declval<typename TypeInfo<std::decay_t<Args>>::Scalar>()...));
+
+			// using Scalar = decltype(std::declval<Functor_>()(
+			//   std::declval<typename ScalarTypeHelper<Args>::Type>()...));
+
+			using TempScalar = decltype(std::declval<Functor_>()(
+			  std::declval<typename ScalarTypeHelper<Args>::Type>()...));
+
+			using Scalar = typename ReturnTypeHelper<TempScalar>::Type;
+
+			using Packet  = typename TypeInfo<Scalar>::Packet;
+			using Backend = decltype(commonBackend<Args...>());
 			using ShapeType =
 			  typename detail::ShapeTypeHelper<typename TypeInfo<Args>::ShapeType...>::Type;
 
@@ -88,9 +135,11 @@ namespace librapid {
 			return obj.scalar(index);
 		}
 
-		template<typename T, typename std::enable_if_t<typetraits::TypeInfo<T>::type ==
-														 ::librapid::detail::LibRapidType::Scalar,
-													   int> = 0>
+		template<typename T,
+				 typename std::enable_if_t<
+				   typetraits::TypeInfo<T>::type == ::librapid::detail::LibRapidType::Scalar ||
+					 typetraits::TypeInfo<T>::type == ::librapid::detail::LibRapidType::Vector,
+				   int> = 0>
 		LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto scalarExtractor(const T &obj, size_t) {
 			return obj;
 		}

librapid/include/librapid/array/operations.hpp

@@ -523,6 +523,12 @@ namespace librapid {
 	} // namespace typetraits
 
 	namespace detail {
+		template<typename T, LibRapidType... ValidTypes>
+		constexpr bool isType() {
+		  constexpr LibRapidType t = typetraits::TypeInfo<std::decay_t<T>>::type;
+		  return ((t == ValidTypes) || ...);
+		}
+
 		template<typename VAL>
 		constexpr bool isArrayOp() {
 			return (typetraits::IsArrayContainer<std::decay_t<VAL>>::value ||
@@ -531,18 +537,63 @@ namespace librapid {
 
 		template<typename LHS, typename RHS>
 		constexpr bool isArrayOpArray() {
-			return (typetraits::TypeInfo<std::decay_t<LHS>>::type != LibRapidType::Scalar) &&
-				   (typetraits::TypeInfo<std::decay_t<RHS>>::type != LibRapidType::Scalar) &&
-				   typetraits::IsLibRapidType<std::decay_t<LHS>>::value &&
-				   typetraits::IsLibRapidType<std::decay_t<RHS>>::value;
+			// return (typetraits::TypeInfo<std::decay_t<LHS>>::type != LibRapidType::Scalar) &&
+			// 	   (typetraits::TypeInfo<std::decay_t<RHS>>::type != LibRapidType::Scalar) &&
+			// 	   typetraits::IsLibRapidType<std::decay_t<LHS>>::value &&
+			// 	   typetraits::IsLibRapidType<std::decay_t<RHS>>::value;
+
+			// ArrayContainer,
+			// ArrayFunction,
+			// GeneralArrayView
+
+			constexpr bool lhsIsValid = isType<LHS,
+												LibRapidType::ArrayContainer,
+												LibRapidType::ArrayFunction,
+												LibRapidType::GeneralArrayView>();
+
+			constexpr bool rhsIsValid = isType<RHS,
+												LibRapidType::ArrayContainer,
+												LibRapidType::ArrayFunction,
+												LibRapidType::GeneralArrayView>();
+
+			return lhsIsValid && rhsIsValid;						
 		}
 
 		template<typename LHS, typename RHS>
 		constexpr bool isArrayOpWithScalar() {
-			return (typetraits::IsLibRapidType<std::decay_t<LHS>>::value &&
-					typetraits::TypeInfo<std::decay_t<RHS>>::type == LibRapidType::Scalar) ||
-				   (typetraits::TypeInfo<std::decay_t<LHS>>::type == LibRapidType::Scalar &&
-					typetraits::IsLibRapidType<std::decay_t<RHS>>::value);
+			// // We allow operations with vectors here
+			// return (typetraits::IsLibRapidType<std::decay_t<LHS>>::value &&
+			// 		(
+			// 			(typetraits::TypeInfo<std::decay_t<RHS>>::type == LibRapidType::Scalar) ||
+			// 			(typetraits::TypeInfo<std::decay_t<RHS>>::type == LibRapidType::Vector)
+			// 		)
+			// 	   ) ||
+			// 	   (
+			// 	   	(
+			// 	   		(typetraits::TypeInfo<std::decay_t<LHS>>::type == LibRapidType::Scalar) ||
+			// 	   		(typetraits::TypeInfo<std::decay_t<LHS>>::type == LibRapidType::Vector)
+			// 	   	) &&
+			// 		typetraits::IsLibRapidType<std::decay_t<RHS>>::value);
+
+			constexpr bool lhsIsArray = isType<LHS,
+												LibRapidType::ArrayContainer,
+												LibRapidType::ArrayFunction,
+												LibRapidType::GeneralArrayView>();
+
+			constexpr bool rhsIsArray = isType<RHS,
+												LibRapidType::ArrayContainer,
+												LibRapidType::ArrayFunction,
+												LibRapidType::GeneralArrayView>();
+
+			constexpr bool lhsIsScalar = isType<LHS,
+													LibRapidType::Scalar,
+													LibRapidType::Vector>();
+
+			constexpr bool rhsIsScalar = isType<RHS,
+													LibRapidType::Scalar,
+													LibRapidType::Vector>();
+
+			return (lhsIsArray ^ rhsIsArray) && (lhsIsScalar ^ rhsIsScalar);
 		}
 	} // namespace detail
 

librapid/include/librapid/array/shape.hpp

@@ -776,34 +776,19 @@ namespace librapid {
 			using Type = VectorShape;
 		};
 
-		template<>
-		struct ShapeTypeHelperImpl<Shape, std::false_type> {
-			using Type = Shape;
+		template<typename NonFalseType>
+		struct ShapeTypeHelperImpl<NonFalseType, std::false_type> {
+			using Type = NonFalseType;
 		};
 
-		template<>
-		struct ShapeTypeHelperImpl<std::false_type, Shape> {
+		template<typename NonFalseType>
+		struct ShapeTypeHelperImpl<std::false_type, NonFalseType> {
 			using Type = Shape;
 		};
 
 		template<>
-		struct ShapeTypeHelperImpl<MatrixShape, std::false_type> {
-			using Type = MatrixShape;
-		};
-
-		template<>
-		struct ShapeTypeHelperImpl<std::false_type, MatrixShape> {
-			using Type = MatrixShape;
-		};
-
-		template<>
-		struct ShapeTypeHelperImpl<VectorShape, std::false_type> {
-			using Type = VectorShape;
-		};
-
-		template<>
-		struct ShapeTypeHelperImpl<std::false_type, VectorShape> {
-			using Type = VectorShape;
+		struct ShapeTypeHelperImpl<std::false_type, std::false_type> {
+			using Type = VectorShape; // Fastest
 		};
 
 		template<typename... Args>

librapid/include/librapid/core/forward.hpp

@@ -28,6 +28,17 @@ namespace librapid {
         class ArrayContainer;
     }
 
+    namespace typetraits {
+        /// Evaluates as true if the input type is an ArrayContainer instance
+        /// \tparam T Input type
+        template<typename T>
+        struct IsArrayContainer : std::false_type {};
+
+        template<typename ShapeType, typename StorageScalar>
+        struct IsArrayContainer<array::ArrayContainer<ShapeType, StorageScalar>> : std::true_type {
+        };
+    }
+
     namespace detail {
         /// \brief Identifies which type of function is being used
         namespace descriptor {

librapid/include/librapid/core/typetraits.hpp

@@ -46,6 +46,12 @@ namespace librapid::typetraits {
         std::true_type testCast(int);
         template<typename From, typename To>
         std::false_type testCast(float);
+
+		// Test for T::allowVectorisation (static constexpr bool)
+		template<typename T, typename = decltype(T::allowVectorisation)>
+		std::true_type testAllowVectorisation(int);
+		template<typename T>
+		std::false_type testAllowVectorisation(float);
     } // namespace impl
 
     template<typename T, typename Index = int64_t>
@@ -63,6 +69,10 @@ namespace librapid::typetraits {
     // Detect whether a class can be default constructed
     template<class T>
     using TriviallyDefaultConstructible = std::is_trivially_default_constructible<T>;
+
+	// Detect whether a class has a static constexpr bool member called allowVectorization
+	template<typename T>
+	struct HasAllowVectorisation : public decltype(impl::testAllowVectorisation<T>(1)) {};
 } // namespace librapid::typetraits
 
 #endif // LIBRAPID_CORE_TYPETRAITS_HPP

librapid/include/librapid/math/vectorForward.hpp

@@ -17,11 +17,16 @@ namespace librapid {
 
 		template<typename Storage0, typename Storage1>
 		auto vectorStorageTypeMerger() {
-			using Scalar0						 = typename typetraits::TypeInfo<Storage0>::Scalar;
-			using Scalar1						 = typename typetraits::TypeInfo<Storage1>::Scalar;
+			using Scalar0 = typename typetraits::TypeInfo<Storage0>::Scalar;
+			using Scalar1 = typename typetraits::TypeInfo<Storage1>::Scalar;
 			static constexpr uint64_t packetWidth0 = typetraits::TypeInfo<Scalar0>::packetWidth;
 			static constexpr uint64_t packetWidth1 = typetraits::TypeInfo<Scalar1>::packetWidth;
-			if constexpr (packetWidth0 > 1 && packetWidth1 > 1) {
+			if constexpr (typetraits::TypeInfo<Storage0>::type == detail::LibRapidType::Scalar) {
+				return Storage1 {};
+			} else if constexpr (typetraits::TypeInfo<Storage1>::type ==
+								 detail::LibRapidType::Scalar) {
+				return Storage0 {};
+			} else if constexpr (packetWidth0 > 1 && packetWidth1 > 1) {
 				return SimdVectorStorage<typename Storage0::Scalar, Storage0::dims> {};
 			} else {
 				return GenericVectorStorage<typename Storage0::Scalar, Storage0::dims> {};
@@ -50,7 +55,9 @@ namespace librapid {
 				return static_cast<Derived &>(*this);
 			}
 
-			LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE auto eval() const { return derived(); }
+//			LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE virtual Derived eval() const {
+//				return derived();
+//			}
 
 			LIBRAPID_NODISCARD LIBRAPID_ALWAYS_INLINE virtual IndexTypeConst
 			operator[](int64_t index) const {
@@ -119,8 +126,16 @@ namespace librapid {
 		LIBRAPID_ALWAYS_INLINE void assign(Vector<Scalar, N> &dst, const UnaryVecOp<Val, Op> &src);
 	} // namespace vectorDetail
 
-	template<typename ScalarType, uint64_t NumDims>
-	class Vector;
+	namespace typetraits {
+		LIBRAPID_DEFINE_AS_TYPE(typename ScalarType COMMA uint64_t NumDims,
+								Vector<ScalarType COMMA NumDims>);
+
+		LIBRAPID_DEFINE_AS_TYPE(typename LHS COMMA typename RHS COMMA typename Op,
+								vectorDetail::BinaryVecOp<LHS COMMA RHS COMMA Op>);
+
+		LIBRAPID_DEFINE_AS_TYPE(typename Val COMMA typename Op,
+								vectorDetail::UnaryVecOp<Val COMMA Op>);
+	} // namespace typetraits
 } // namespace librapid
 
 #endif // LIBRAPID_MATH_VECTOR_FORWARD_HPP