GitVersion

GitVersion

Tests/Statistics/BIAS_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class BIAS_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		BIAS_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		BIAS_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class BIAS_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		BIAS_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		BIAS_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/ENTP_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class KURT_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		KURT_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		KURT_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class KURT_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		KURT_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		KURT_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/KURT_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class ENTP_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		ENTP_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		ENTP_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class ENTP_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		ENTP_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		ENTP_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/LINREG_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class LINREG_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		LINREG_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		LINREG_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class LINREG_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		LINREG_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		LINREG_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/MAD_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class MAD_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		MAD_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		MAD_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class MAD_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		MAD_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		MAD_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/MAPE_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class MAPE_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		MAPE_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		MAPE_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class MAPE_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		MAPE_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		MAPE_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/MAX_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class MAX_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		MAX_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		MAX_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class MAX_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		MAX_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		MAX_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/MED_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class MED_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		MED_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		MED_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class MED_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		MED_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		MED_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/MIN_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class MIN_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		MIN_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		MIN_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class MIN_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		MIN_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		MIN_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/MSE_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class MSE_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		MSE_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		MSE_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class MSE_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		MSE_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		MSE_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/PSDEV_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class PSDEV_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		SDEV_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		SDEV_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class PSDEV_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		SDEV_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		SDEV_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/PVAR_Test .cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class PVAR_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		SVAR_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		SVAR_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class PVAR_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		SVAR_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		SVAR_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/SDEV_Test .cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class SDEV_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		SSDEV_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		SSDEV_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class SDEV_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		SSDEV_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		SSDEV_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/SMAPE_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class SMAPE_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		SMAPE_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		SMAPE_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class SMAPE_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		SMAPE_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		SMAPE_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/VAR_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class VAR_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		SVAR_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		SVAR_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class VAR_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		SVAR_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		SVAR_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}

Tests/Statistics/WMAPE_Test.cs

@@ -1,31 +1,31 @@
-using Xunit;
-using System;
-using QuanTAlib;
-
-namespace Statistics;
-public class WMAPE_Test
-{
-	[Fact]
-	public void Add_Test()
-	{
-		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
-		WMAPE_Series c = new(a, 3);
-		Assert.Equal(6, c.Count);
-		a.Add(5);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(0, update: true);
-		Assert.Equal(a.Count, c.Count);
-	}
-
-	[Fact]
-	public void Edge_Test()
-	{
-		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
-		WMAPE_Series c = new(a, 3);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.NaN);
-		Assert.Equal(a.Count, c.Count);
-		a.Add(double.PositiveInfinity);
-		Assert.Equal(a.Count, c.Count);
-	}
-}
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Statistics;
+public class WMAPE_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		WMAPE_Series c = new(a, 3);
+		Assert.Equal(6, c.Count);
+		a.Add(5);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(0, update: true);
+		Assert.Equal(a.Count, c.Count);
+	}
+
+	[Fact]
+	public void Edge_Test()
+	{
+		TSeries a = new() { double.NaN, double.Epsilon, double.PositiveInfinity, double.MaxValue };
+		WMAPE_Series c = new(a, 3);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.NaN);
+		Assert.Equal(a.Count, c.Count);
+		a.Add(double.PositiveInfinity);
+		Assert.Equal(a.Count, c.Count);
+	}
+}