Adding utility functions to the wrapper with basic Unit tests

CMakeLists.txt

@@ -9,6 +9,7 @@ if (APPLE)
                                     VectorisationWrappers/Accelerate/AccelerateRange.h
                                     VectorisationWrappers/Accelerate/AccelerateUtilities.h
                                     VectorisationWrappers/AccelerateWrapperUnitTests.cpp
+                                    VectorisationWrappers/AccelerateUtilitiesUnitTests.cpp
                                     VectorisationWrappers/AccelerateRangeUnitTests.cpp)
 
     target_link_libraries (accelerate_DSP PRIVATE Catch2::Catch2WithMain "$<LINK_LIBRARY:FRAMEWORK,Accelerate>")

VectorisationWrappers/Accelerate/AccelerateUtilities.h

@@ -5,38 +5,38 @@
 namespace Vectorised::Utilities
 {
     template <typename T>
-    static void scalerMultiplication (T* InputBuffer, T* OutputBuffer, const int BufferSize, const int InputStride = 1, const int OutputStride = 1)
+    static void scalerMultiplication (const T* InputBuffer, T* OutputBuffer, const int BufferSize, T& ScalarValue, const int InputStride = 1, const int OutputStride = 1)
     {
         if constexpr (std::is_same_v<T, float>)
-            VDSP_vscal (InputBuffer, InputStride, OutputBuffer, OutputStride, BufferSize);
+            vDSP_vsmul (InputBuffer, InputStride, &ScalarValue, OutputBuffer, OutputStride, BufferSize);
         else if constexpr (std::is_same_v<T, double>)
-            VDSP_vscalD (InputBuffer, InputStride, OutputBuffer, OutputStride, BufferSize);
+            vDSP_vsmulD (InputBuffer, InputStride, &ScalarValue, OutputBuffer, OutputStride, BufferSize);
     }
 
     template <typename T>
     static void absBuffer (T* InputBuffer, T*  OutputBuffer, const int BufferSize, const int InputStride = 1, const int OutputStride = 1)
     {
         if constexpr (std::is_same_v<T, float>)
-            vDSP_abs (InputBuffer, InputStride, OutputBuffer, OutputStride, BufferSize);
+            vDSP_vabs (InputBuffer, InputStride, OutputBuffer, OutputStride, BufferSize);
         else if constexpr (std::is_same_v<T, double>)
-            vDSP_absD (InputBuffer, InputStride, OutputBuffer, OutputStride, BufferSize);
+            vDSP_vabsD (InputBuffer, InputStride, OutputBuffer, OutputStride, BufferSize);
     }
 
     template <typename T>
     static void fillBuffer (T* ValueToFill, T* Buffer, const int BufferSize, const int BufferStride = 1)
     {
         if constexpr (std::is_same_v<T, float>)
-            VDSP_vfill (ValueToFill, Buffer, BufferStride, BufferSize);
+            vDSP_vfill (ValueToFill, Buffer, BufferStride, BufferSize);
         else if constexpr (std::is_same_v<T, double>)
-            VDSP_vfill (ValueToFill, Buffer, BufferStride, BufferSize);
+            vDSP_vfillD (ValueToFill, Buffer, BufferStride, BufferSize);
     }
 
     template <typename T>
-    static void zeroBuffer (T* ValueToFill, const int BufferSize, const int BufferStride = 1)
+    static void zeroBuffer (T* Buffer, const int BufferSize, const int BufferStride = 1)
     {
         if constexpr (std::is_same_v<T, float>)
-            vdsp_vzero (ValueToFill, BufferStride, BufferSize);
+            vDSP_vclr (Buffer, BufferStride, BufferSize);
         if constexpr (std::is_same_v<T, double>)
-            vdsp_vzeroD (ValueToFill, BufferStride, BufferSize);
+            vDSP_vclrD (Buffer, BufferStride, BufferSize);
     }
 };

VectorisationWrappers/Accelerate/AccelerateWrapper.h

@@ -41,24 +41,6 @@ namespace Vectorised
             static_assert (sizeof(T) == 0, "Unsupported type for addition");
     }
 
-    template <typename T>
-    static void scalerMultiplication (T* InputBuffer, T* OutputBuffer, const int BufferSize, const int InputStride = 1, const int OutputStride = 1)
-    {
-        if constexpr (std::is_same_v<T, float>)
-            VDSP_vscal (InputBuffer, InputStride, OutputBuffer, OutputStride, BufferSize);
-        else if constexpr (std::is_same_v<T, double>)
-            VDSP_vscalD (InputBuffer, InputStride, OutputBuffer, OutputStride, BufferSize);
-    }
-
-    template <typename T>
-    static void fillBuffer (T* ValueToFill, T* Buffer, const int BufferSize, const int BufferStride = 1)
-    {
-        if constexpr (std::is_same_v<T, float>)
-            VDSP_vfill (ValueToFill, Buffer, BufferStride, BufferSize);
-        else if constexpr (std::is_same_v<T, double>)
-            VDSP_vfill (ValueToFill, Buffer, BufferStride, BufferSize);
-    }
-
     template <typename T>
     static void divisionVectorised (T* OutputPtr, T* InputPtr, const int BufferSize)
     {

VectorisationWrappers/AccelerateRangeUnitTests.cpp

@@ -1,5 +1,6 @@
 #include <Accelerate/Accelerate.h>
 #include "Accelerate/AccelerateRange.h"
+#include "Accelerate/AccelerateUtilities.h"
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_template_test_macros.hpp>
 

VectorisationWrappers/AccelerateUtilitiesUnitTests.cpp

@@ -0,0 +1,62 @@
+#include <Accelerate/Accelerate.h>
+#include "Accelerate/AccelerateUtilities.h"
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_template_test_macros.hpp>
+
+TEMPLATE_TEST_CASE("Accelerate Utils Unit Testing", "[Accelerate U]", float, double)
+{
+    using T = TestType;
+
+    constexpr auto bufferSize = 1024;
+
+    std::vector<T> inputBuffer (bufferSize);
+    std::vector<T> outputBuffer (bufferSize);
+
+    inputBuffer.assign (bufferSize, static_cast<T>(0));
+    outputBuffer.assign (bufferSize, static_cast<T>(2));
+
+
+    SECTION("Accelerate Abs Values")
+    {
+        inputBuffer.assign (bufferSize, static_cast<T>(-1));
+        Vectorised::Utilities::absBuffer (inputBuffer.data(), outputBuffer.data(), bufferSize);
+
+        for (const auto& value : outputBuffer)
+        {
+            REQUIRE (value == static_cast<T>(1));
+        }
+    }
+
+    SECTION ("Accelerate Fill Buffer")
+    {
+        T valueToFill = 1.0;
+        Vectorised::Utilities::fillBuffer (&valueToFill, inputBuffer.data(), bufferSize);
+
+        for (const auto& Value : inputBuffer)
+        {
+            REQUIRE (Value == valueToFill);
+        }
+    }
+
+    SECTION ("Accelerate Zero Buffer")
+    {
+        Vectorised::Utilities::zeroBuffer (outputBuffer.data(), bufferSize);
+
+        for (const auto& Value : inputBuffer)
+        {
+            REQUIRE (Value == static_cast<T>(0));
+        }
+    }
+
+    SECTION ("Accelerate Scale Buffer")
+    {
+        auto scalarValue = static_cast<T>(2);
+        inputBuffer.assign (bufferSize, static_cast<T>(1));
+        Vectorised::Utilities::scalerMultiplication (inputBuffer.data(), outputBuffer.data(), bufferSize, scalarValue);
+
+        for (const auto& Value : outputBuffer)
+        {
+            REQUIRE (Value == 2);
+        }
+    }
+}