Implementing a more comprehensive wrapper for basic arithmetic

CMakeLists.txt

@@ -5,10 +5,10 @@ set (CMAKE_CXX_STANDARD 23)
 add_subdirectory (Catch2)
 
 if (APPLE)
-    add_executable (accelerate_DSP  VectorisationWrappers/Accelerate/AccelerateWrapper.h
+    add_executable (accelerate_DSP VectorisationWrappers/Accelerate/AccelerateArithmetic.h
                                     VectorisationWrappers/Accelerate/AccelerateRange.h
                                     VectorisationWrappers/Accelerate/AccelerateUtilities.h
-                                    VectorisationWrappers/AccelerateWrapperUnitTests.cpp
+                                    VectorisationWrappers/AccelerateArithmeticUnitTests.cpp
                                     VectorisationWrappers/AccelerateUtilitiesUnitTests.cpp
                                     VectorisationWrappers/AccelerateRangeUnitTests.cpp)
 

VectorisationWrappers/Accelerate/AccelerateWrapper.h → VectorisationWrappers/Accelerate/AccelerateArithmetic.h

@@ -7,47 +7,47 @@ namespace Vectorised
 {
     // Vectorised Addition function for VDSP
     template <typename T>
-    static void additionVectorised (T* BufferA, const T* BufferB, const int BufferSize)
+    static void additionVectorised (const T* BufferA, const T* BufferB, T* OutputBuffer, const int BufferSize, const int BufferAStride = 1, const int BufferBStride = 1, const int OutputStride = 1)
     {
         if constexpr (std::is_same_v<T, float>)
-            vDSP_vadd (BufferA, 1, BufferB, 1, BufferA, 1, BufferSize);
+            vDSP_vadd (BufferA, BufferAStride, BufferB, BufferBStride, OutputBuffer, OutputStride, BufferSize);
         else if constexpr (std::is_same_v<T, double>)
-            vDSP_vaddD (BufferA, 1, BufferB, 1, BufferA, 1, BufferSize);
+            vDSP_vaddD (BufferA, BufferAStride, BufferB, BufferBStride, OutputBuffer, OutputStride, BufferSize);
         else
             static_assert (sizeof(T) == 0, "Unsupported type for addition");
     }
 
     // Vectorised Addition function for VDSP
     template <typename T>
-    static void subtractionVectorised (T* BufferA, const T* BufferB, const int BufferSize)
+    static void subtractionVectorised (const T* BufferA, const T* BufferB, T* OutputBuffer, const int BufferSize, const int BufferAStride = 1, const int BufferBStride = 1, const int OutputStride = 1)
     {
         if constexpr (std::is_same_v<T, float>)
-            vDSP_vsub (BufferA, 1, BufferB, 1, BufferA, 1, BufferSize);
+            vDSP_vsub (BufferA, BufferAStride, BufferB, BufferBStride, OutputBuffer, OutputStride, BufferSize);
         else if constexpr (std::is_same_v<T, double>)
-            vDSP_vsubD (BufferA, 1, BufferB, 1, BufferA, 1, BufferSize);
+            vDSP_vsubD (BufferA, BufferAStride, BufferB, BufferBStride, OutputBuffer, OutputStride, BufferSize);
         else
             static_assert (sizeof(T) == 0, "Unsupported type for addition");
     }
 
     // Vectorised Multiplication function using vdsp
     template <typename T>
-    static void multiplicationVectorised(T* BufferA, const T* BufferB, const int BufferSize)
+    static void multiplicationVectorised (const T* BufferA, const T* BufferB, T* OutputBuffer, const int BufferSize, const int BufferAStride = 1, const int BufferBStride = 1, const int OutputStride = 1)
     {
         if constexpr (std::is_same_v<T, float>)
-            vDSP_vmul (BufferA, 1, BufferB, 1, BufferA, 1, BufferSize);
+            vDSP_vmul (BufferA, BufferAStride, BufferB, BufferBStride, OutputBuffer, OutputStride, BufferSize);
         else if constexpr (std::is_same_v<T, double>)
-            vDSP_vmulD (BufferA, 1, BufferB, 1, BufferA, 1, BufferSize);
+            vDSP_vmulD (BufferA, BufferAStride, BufferB, BufferBStride, OutputBuffer, OutputStride, BufferSize);
         else
             static_assert (sizeof(T) == 0, "Unsupported type for addition");
     }
 
     template <typename T>
-    static void divisionVectorised (T* OutputPtr, T* InputPtr, const int BufferSize)
+    static void divisionVectorised (const T* BufferA, const T* BufferB, T* OutputBuffer, const int BufferSize)
     {
         if constexpr (std::is_same_v<T, float>)
-            vvdivf (OutputPtr, InputPtr, OutputPtr, &BufferSize);
+            vvdivf (OutputBuffer, BufferA, BufferB, &BufferSize);
         else if constexpr (std::is_same_v<T, double>)
-            vvdiv (OutputPtr, InputPtr, OutputPtr, &BufferSize);
+            vvdiv (OutputBuffer, BufferA, BufferB, &BufferSize);
     }
 
 

VectorisationWrappers/AccelerateArithmeticUnitTests.cpp

@@ -0,0 +1,85 @@
+// Unit tests for VDSP WRAPPER
+
+#include "Accelerate/AccelerateArithmetic.h"
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_template_test_macros.hpp>
+
+TEMPLATE_TEST_CASE ("VDSP wrapper testing", "[VDSP Wrapper]", float, double)
+{
+    using T = TestType;
+
+    constexpr auto bufferSize = 1024;
+
+    std::vector<T> BufferA (bufferSize);
+    std::vector<T> BufferB (bufferSize);
+
+    BufferA.assign (bufferSize, 0.0f);
+    BufferB.assign (bufferSize, 1.0f);
+
+    SECTION ("Addition Test")
+    {
+        Vectorised::additionVectorised (BufferA.data(), BufferB.data(), BufferB.data(), bufferSize);
+
+        for (const auto& value : BufferB)
+        {
+            REQUIRE (value == static_cast<T>(1));
+        }
+    }
+
+    SECTION ("Subtraction Test")
+    {
+        BufferA.assign (bufferSize, 4.0f);
+        BufferB.assign (bufferSize, 5.0f);
+
+        Vectorised::subtractionVectorised (BufferA.data(), BufferB.data(), BufferB.data(), bufferSize);
+
+        for (const auto& value : BufferB)
+        {
+            REQUIRE (value == static_cast<T>(1));
+        }
+    }
+
+    SECTION ("Multiplication Test")
+    {
+        BufferA.assign (bufferSize, 2.0f);
+        BufferB.assign (bufferSize, 1.0f);
+
+       Vectorised::multiplicationVectorised (BufferA.data(), BufferB.data(), BufferB.data(), bufferSize);
+
+        for (const auto& value : BufferB)
+        {
+            REQUIRE (value == static_cast<T>(2));
+        }
+    }
+
+    SECTION ("Division Test")
+    {
+        BufferA.assign (bufferSize, 2.0f);
+        BufferB.assign (bufferSize, 2.0f);
+
+        Vectorised::divisionVectorised (BufferA.data(), BufferB.data(), BufferB.data(), bufferSize);
+
+        for (const auto& value : BufferB)
+        {
+            REQUIRE (value == static_cast<T>(1));
+        }
+    }
+
+    // SECTION ("Division Test")
+    // {
+    //     Vectorised::tanhVectorised (input.data(), output.data(), 256);
+    // }
+    //
+    // SECTION ("Division Test")
+    // {
+    //     Vectorised::sineVectorised (input.data(), 256);
+    // }
+    //
+    // SECTION ("Division Test")
+    // {
+    //     const auto lowerLimit = -1.f;
+    //     const auto upperLimit = -1.f;
+    //
+    //     Vectorised::hardClipVectorised (input.data(), output.data(), 256, &lowerLimit, &upperLimit);
+    // }
+}