Testing trig functions added with rough test implementation

CMakeLists.txt

@@ -1,18 +1,19 @@
 cmake_minimum_required (VERSION 3.25)
-project (WRAPPER DESCRIPTION "Vectoisation Wrapper with Unit tested" LANGUAGES CXX)
+project (WRAPPER DESCRIPTION "Vectorisation Wrapper with Unit tested" LANGUAGES CXX)
 
 set (CMAKE_CXX_STANDARD 23)
 add_subdirectory (Catch2)
 
 if (APPLE)
-    add_executable (accelerate_DSP VectorisationWrappers/Accelerate/AccelerateArithmetic.h
-                                    VectorisationWrappers/Accelerate/AccelerateRange.h
-                                    VectorisationWrappers/Accelerate/AccelerateUtilities.h
-                                    VectorisationWrappers/AccelerateArithmeticUnitTests.cpp
-                                    VectorisationWrappers/AccelerateUtilitiesUnitTests.cpp
-                                    VectorisationWrappers/AccelerateRangeUnitTests.cpp)
+    set (ACCELERATE_SOURCES VectorisationWrappers/Accelerate/AccelerateWrapper.cpp
+            VectorisationWrappers/Accelerate/Tests/AccelerateArithmeticUnitTests.cpp
+            VectorisationWrappers/Accelerate/Tests/AccelerateUtilitiesUnitTests.cpp
+            VectorisationWrappers/Accelerate/Tests/AccelerateRangeUnitTests.cpp
+            VectorisationWrappers/Accelerate/Tests/AccelerateTrigonometryUnitTests.cpp)
+
+    add_executable(accelerate_DSP ${ACCELERATE_SOURCES})
 
     target_link_libraries (accelerate_DSP PRIVATE Catch2::Catch2WithMain "$<LINK_LIBRARY:FRAMEWORK,Accelerate>")
-ELSEIF (MSVC)
-    message ("No Wrapper is availble")
-ENDIF()
+elseif (MSVC)
+    message ("No Wrapper")
+endif()

VectorisationWrappers/Accelerate/AccelerateArithmetic.h

@@ -1,8 +1,5 @@
 #pragma once
 
-#include <Accelerate/Accelerate.h>
-
-// VDSP wrapper namespace in a vectorised way
 namespace Vectorised
 {
     // Vectorised Addition function for VDSP
@@ -49,41 +46,4 @@ namespace Vectorised
         else if constexpr (std::is_same_v<T, double>)
             vvdiv (OutputBuffer, BufferA, BufferB, &BufferSize);
     }
-
-
-    // Vectorised tanh function for VDSP
-    template <typename T>
-    static void tanhVectorised (const T* InputBuffer, T* OutputBuffer, const int BufferSize)
-    {
-        if constexpr (std::is_same_v<T, float>)
-            vvtanhf (OutputBuffer, InputBuffer, &BufferSize);
-        else if constexpr (std::is_same_v<T, double>)
-            vvtanh (OutputBuffer, InputBuffer, &BufferSize);
-        else
-            static_assert (sizeof(T) == 0, "Unsupported type for tanh");
-    }
-
-    // Vectorised tanh function for hard clipping
-    template <typename T>
-    static void hardClipVectorised(const T* InputBuffer, T* OutputBuffer, const int BufferSize, const T* ClipLowerLimit, const T* ClipUpperLimit)
-    {
-        if constexpr (std::is_same_v<T, float>)
-            vDSP_vclip(InputBuffer, 1, ClipLowerLimit, ClipUpperLimit, OutputBuffer, 1, BufferSize);
-        else if constexpr (std::is_same_v<T, double>)
-            vDSP_vclipD(InputBuffer, 1, ClipLowerLimit, ClipUpperLimit, OutputBuffer, 1, BufferSize);
-        else
-            static_assert (sizeof(T) == 0, "Unsupported type for hard clipping");
-    }
-
-    // Vectorised tanh function for sine
-    template <typename T>
-    static void sineVectorised (T* InputBuffer, const int BufferSize)
-    {
-        if constexpr (std::is_same_v<T, float>)
-            vvsinf (InputBuffer, InputBuffer, &BufferSize);
-        else if constexpr  (std::is_same_v<T, double>)
-            vvsin (InputBuffer, InputBuffer, &BufferSize);
-        else
-            static_assert (sizeof(T) == 0, "Unsupported type for sine");
-    }
 };

VectorisationWrappers/Accelerate/AccelerateRange.h

@@ -1,6 +1,4 @@
 #pragma once
-#include <Accelerate/Accelerate.h>
-#include <type_traits>
 
 namespace Vectorised::Range
 {

VectorisationWrappers/Accelerate/AccelerateTrigonometry.h

@@ -0,0 +1,39 @@
+#pragma once
+
+namespace Vectorised::Trigonometry
+{
+    template <typename T>
+    static void tanhVectorised (const T* WorkBuffer, T* OutputBuffer, const int BufferSize)
+    {
+        if constexpr (std::is_same_v<T, float>)
+            vvtanhf (OutputBuffer, WorkBuffer, &BufferSize);
+        else if constexpr (std::is_same_v<T, double>)
+            vvtanh (OutputBuffer, WorkBuffer, &BufferSize);
+        else
+            static_assert (sizeof(T) == 0, "Unsupported type for tanh");
+    }
+
+    // Vectorised tanh function for hard clipping
+    template <typename T>
+    static void hardClipVectorised(const T* InputBuffer, T* OutputBuffer, const int BufferSize, const T* ClipLowerLimit, const T* ClipUpperLimit)
+    {
+        if constexpr (std::is_same_v<T, float>)
+            vDSP_vclip(InputBuffer, 1, ClipLowerLimit, ClipUpperLimit, OutputBuffer, 1, BufferSize);
+        else if constexpr (std::is_same_v<T, double>)
+            vDSP_vclipD(InputBuffer, 1, ClipLowerLimit, ClipUpperLimit, OutputBuffer, 1, BufferSize);
+        else
+            static_assert (sizeof(T) == 0, "Unsupported type for hard clipping");
+    }
+
+    // Vectorised tanh function for sine
+    template <typename T>
+    static void sineVectorised (T* InputBuffer, const int BufferSize)
+    {
+        if constexpr (std::is_same_v<T, float>)
+            vvsinf (InputBuffer, InputBuffer, &BufferSize);
+        else if constexpr  (std::is_same_v<T, double>)
+            vvsin (InputBuffer, InputBuffer, &BufferSize);
+        else
+            static_assert (sizeof(T) == 0, "Unsupported type for sine");
+    }
+}

VectorisationWrappers/Accelerate/AccelerateUtilities.h

@@ -1,7 +1,5 @@
 #pragma once
-#include <Accelerate/Accelerate.h>
 
-// VDSP wrapper namespace in a vectorised way
 namespace Vectorised::Utilities
 {
     template <typename T>

VectorisationWrappers/Accelerate/AccelerateWrapper.cpp

@@ -1,3 +1,5 @@
 //
-// Created by Kristian Mc Gurran on 12/06/2025.
+// Including all the header files
 //
+
+#include "AccelerateWrapper.h"

VectorisationWrappers/Accelerate/AccelerateWrapper.h

@@ -0,0 +1,12 @@
+//
+// Including all the header files
+//
+
+#pragma once
+
+#include <Accelerate/Accelerate.h>
+#include <type_traits>
+#include "AccelerateArithmetic.h"
+#include "AccelerateRange.h"
+#include "AccelerateTrigonometry.h"
+#include "AccelerateUtilities.h"

VectorisationWrappers/AccelerateArithmeticUnitTests.cpp → VectorisationWrappers/Accelerate/Tests/AccelerateArithmeticUnitTests.cpp

@@ -1,6 +1,6 @@
 // Unit tests for VDSP WRAPPER
 
-#include "Accelerate/AccelerateArithmetic.h"
+#include "../AccelerateWrapper.h"
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_template_test_macros.hpp>
 
@@ -64,22 +64,4 @@ TEMPLATE_TEST_CASE ("VDSP wrapper testing", "[VDSP Wrapper]", float, double)
             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);
-    // }
 }

VectorisationWrappers/AccelerateRangeUnitTests.cpp → VectorisationWrappers/Accelerate/Tests/AccelerateRangeUnitTests.cpp

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

VectorisationWrappers/Accelerate/Tests/AccelerateTrigonometryUnitTests.cpp

@@ -0,0 +1,62 @@
+#include "../AccelerateWrapper.h"
+#include <cmath>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/catch_template_test_macros.hpp>
+#include <catch2/catch_approx.hpp>
+
+TEMPLATE_TEST_CASE("Accelerate Trigonometry Unit Testing", "[Accelerate Trigonometry]", float, double)
+{
+    using T = TestType;
+
+    constexpr auto bufferSize = 1024;
+
+    std::vector<T> workingBuffer (bufferSize);
+    workingBuffer.assign (bufferSize, static_cast<T>(1));
+
+    SECTION ("Sine Function Tests")
+    {
+        auto sinValue = static_cast<T> (std::sin (1.f));
+
+        Vectorised::Trigonometry::sineVectorised (workingBuffer.data(), bufferSize);
+
+        for (const auto& value : workingBuffer)
+        {
+            REQUIRE (value == Catch::Approx (sinValue));
+        }
+    }
+
+    SECTION ("Tanh Function Tests")
+    {
+        workingBuffer.assign (bufferSize, static_cast<T> (10));
+        const auto tanhValue = static_cast<T> (std::tanh (10.f));
+
+        Vectorised::Trigonometry::tanhVectorised (workingBuffer.data(), workingBuffer.data(), bufferSize);
+
+        for (const auto& value : workingBuffer)
+        {
+            REQUIRE (value == Catch::Approx (tanhValue));
+        }
+    }
+
+    SECTION ("Sigmud Function Tests")
+    {
+        const auto minValue = static_cast<T>(-1);
+        const auto maxValue = static_cast<T>(1);
+
+        workingBuffer.assign (bufferSize, static_cast<T> (-10));
+        Vectorised::Trigonometry::hardClipVectorised (workingBuffer.data(), workingBuffer.data(), bufferSize, &minValue, &maxValue);
+
+        for (const auto& value : workingBuffer)
+        {
+            REQUIRE (value == Catch::Approx (minValue));
+        }
+
+        workingBuffer.assign (bufferSize, static_cast<T> (10));
+        Vectorised::Trigonometry::hardClipVectorised (workingBuffer.data(), workingBuffer.data(), bufferSize, &minValue, &maxValue);
+
+        for (const auto& value : workingBuffer)
+        {
+            REQUIRE (value == Catch::Approx (maxValue));
+        }
+    }
+}

VectorisationWrappers/AccelerateUtilitiesUnitTests.cpp → VectorisationWrappers/Accelerate/Tests/AccelerateUtilitiesUnitTests.cpp

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