Add running average

tests/Math/RunningAverageTest.cpp

@@ -0,0 +1,180 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+#include <catch2/catch_all.hpp>
+
+#include "Math/RunningAverage.hpp"
+#include "Math/Math.hpp"
+
+using namespace OpenVulkano::Math;
+
+TEST_CASE("RunningAverage Basic Functionality - Integer Type", "[RunningAverage]")
+{
+    SECTION("Dynamic Size Constructor with Default Value")
+    {
+        RunningAverage<int> avg(5);
+        REQUIRE(avg.Get() == 0);
+    }
+    
+    SECTION("Dynamic Size Constructor with Custom Default")
+    {
+        RunningAverage<int> avg(5, 10);
+        REQUIRE(avg.Get() == 10);
+    }
+    
+    SECTION("Static Size Constructor with Default Value")
+    {
+        RunningAverage<int, 5> avg;
+        REQUIRE(avg.Get() == 0);
+    }
+    
+    SECTION("Static Size Constructor with Custom Default")
+    {
+        RunningAverage<int, 5> avg(10);
+        REQUIRE(avg.Get() == 10);
+    }
+    
+    SECTION("Push Single Value")
+    {
+        RunningAverage<int> avg(5, 0);
+        avg.Push(5);
+        REQUIRE(avg.Get() == 1);  // (0+0+0+0+5)/5 = 1
+    }
+    
+    SECTION("Push Multiple Values")
+    {
+        RunningAverage<int> avg(4, 0);
+        avg.Push(4);
+        avg.Push(8);
+        avg.Push(12);
+        avg.Push(16);
+        REQUIRE(avg.Get() == 10);  // (4+8+12+16)/4 = 10
+    }
+    
+    SECTION("Push with Overwrite")
+    {
+        RunningAverage<int> avg(3, 0);
+        avg.Push(3);
+        avg.Push(6);
+        avg.Push(9);
+        REQUIRE(avg.Get() == 6);  // (3+6+9)/3 = 6
+        
+        avg.Push(12);  // Overwrite 3
+        REQUIRE(avg.Get() == 9);  // (6+9+12)/3 = 9
+    }
+}
+
+TEST_CASE("RunningAverage with Floating Point Types", "[RunningAverage]")
+{
+    SECTION("Basic Floating Point Operation")
+    {
+        RunningAverage<double> avg(3, 0.0);
+        avg.Push(1.5);
+        avg.Push(2.5);
+        avg.Push(3.5);
+        REQUIRE(avg.Get() == Catch::Approx(2.5));  // (1.5+2.5+3.5)/3 = 2.5
+    }
+    
+    SECTION("Recalculation with Floating Point")
+    {
+        // Set recalculation to happen after 3 operations
+        RunningAverage<double, std::numeric_limits<size_t>::max(), true, 3> avg(3, 0.0);
+        avg.Push(1.0);
+        avg.Push(2.0);
+        avg.Push(3.0);  // This should trigger recalculation
+        REQUIRE(avg.Get() == Catch::Approx(2.0));  // (1.0+2.0+3.0)/3 = 2.0
+        
+        // Push another value to check that recalculation didn't affect the result
+        avg.Push(4.0);
+        REQUIRE(avg.Get() == Catch::Approx(3.0));  // (2.0+3.0+4.0)/3 = 3.0
+    }
+    
+    SECTION("Manual Recalculation")
+    {
+        RunningAverage<double> avg(3, 0.0);
+        avg.Push(1.5);
+        avg.Push(2.5);
+        avg.Push(3.5);
+        
+        // Force recalculation and verify it doesn't change the result
+        avg.Recalculate();
+        REQUIRE(avg.Get() == Catch::Approx(2.5));
+    }
+}
+
+TEST_CASE("RunningAverage Edge Cases", "[RunningAverage]")
+{
+    SECTION("Large Values")
+    {
+        RunningAverage<int> avg(3, 0);
+        avg.Push(1000000);
+        avg.Push(2000000);
+        avg.Push(3000000);
+        REQUIRE(avg.Get() == 2000000);
+    }
+    
+    SECTION("Negative Values")
+    {
+        RunningAverage<int> avg(3, 0);
+        avg.Push(-10);
+        avg.Push(-20);
+        avg.Push(-30);
+        REQUIRE(avg.Get() == -20);
+    }
+    
+    SECTION("Mixed Sign Values")
+    {
+        RunningAverage<int> avg(4, 0);
+        avg.Push(-10);
+        avg.Push(10);
+        avg.Push(-10);
+        avg.Push(10);
+        REQUIRE(avg.Get() == 0);
+    }
+}
+
+TEST_CASE("Custom Types with RunningAverage", "[RunningAverage]")
+{
+    SECTION("Vector Type Average")
+    {
+        RunningAverage<Vector2f> avg(3, Vector2f(0, 0));
+        avg.Push(Vector2f(1, 2));
+        avg.Push(Vector2f(3, 4));
+        avg.Push(Vector2f(5, 6));
+        
+        Vector2f result = avg.Get();
+        REQUIRE(result.x == Catch::Approx(3.0f));
+        REQUIRE(result.y == Catch::Approx(4.0f));
+    }
+}
+
+// This test specifically checks the correctness of recalculation for floating point
+TEST_CASE("Precision with Floating Point Types", "[RunningAverage]")
+{
+    SECTION("Accumulation Error Correction")
+    {
+        // Create a running average that would normally suffer from floating point errors
+        // Force recalculation after 20 operations
+        RunningAverage<double, std::numeric_limits<size_t>::max(), true, 20> avg(5, 0.0);
+        
+        // Push values that would cause floating point rounding errors
+        for (int i = 0; i < 100; i++) {
+            avg.Push(0.1);  // 0.1 cannot be represented exactly in binary floating point
+        }
+        
+        // Check that the result is still accurate due to periodic recalculation
+        REQUIRE(avg.Get() == Catch::Approx(0.1).epsilon(0.0001));
+    }
+}
+
+TEST_CASE("Class size", "[RunningAverage]")
+{
+	REQUIRE(sizeof(RunningAverage<int32_t>) == 40);
+	REQUIRE(sizeof(RunningAverage<int32_t, ::OpenVulkano::RING_BUFFER_DYNAMIC, true>) == 48);
+	REQUIRE(sizeof(RunningAverage<float>) == 48);
+	REQUIRE(sizeof(RunningAverage<int32_t, 5>) == 48);
+	REQUIRE(sizeof(RunningAverage<Vector2f>) == 40);
+}