Rebase

Tests/Basics/ADD_Test.cs

@@ -0,0 +1,64 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Basics;
+public class ADD_Test
+{
+    [Fact]
+    public void ADDSeriesSeries_Test()
+    {
+        TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+        TSeries b = new() { 5, 4, 3, 2, 1, 0 };
+        ADD_Series c = new(a, b);
+        Assert.Equal(5, c.Last().v);
+    }
+
+    [Fact]
+    public void ADDSeriesDouble_Test()
+    {
+        TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+        ADD_Series c = new(a, 10.0);
+        Assert.Equal(15, c.Last().v);
+    }
+
+    [Fact]
+    public void ADDDoubleSeries_Test()
+    {
+        TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+        ADD_Series c = new(10.0, a);
+        Assert.Equal(15, c.Last().v);
+    }
+
+    [Fact]
+    public void ADDEventing_Test()
+    {
+        TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+        TSeries b = new() { 5, 4, 3, 2, 1, 0 };
+        ADD_Series c = new(a, b);
+        a.Add(2);
+        b.Add(2);
+        Assert.Equal(4, c.Last().v);
+    }
+
+    [Fact]
+    public void ADDUpdateDouble_Test()
+    {
+        TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+        double b = 10;
+        ADD_Series c = new(a, b);
+        a.Add(0, true);
+        Assert.Equal(10, c.Last().v);
+    }
+
+    [Fact]
+    public void ADDUpdating_Test()
+    {
+        TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+        TSeries b = new() { 5, 4, 3, 2, 1, 0 };
+        ADD_Series c = new(a, b);
+        a.Add(10, true);
+        b.Add(10, true);
+        Assert.Equal(20, c.Last().v);
+    }
+}

Tests/Basics/Abstract_Test.cs

@@ -0,0 +1,23 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Basics;
+public class Abstract_Test
+{
+    [Fact]
+    public void Single_Add_variations()
+    {
+        TSeries s = new() { 1,2,3,4,5 };
+		SMA_Series a = new(s, 3)
+		{
+			{ (DateTime.Today, 10), true }
+		};
+		Assert.Equal(s.Length, a.Length);
+        a.Add(true);
+        Assert.Equal(s.Length, a.Length);
+        a.Add();
+        Assert.Equal(s.Length+1, a.Length);
+		}
+
+}

Tests/Basics/DIV_Test.cs

@@ -0,0 +1,64 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Basics;
+public class DIV_Test
+{
+	[Fact]
+	public void DIVSeriesSeries_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 15 };
+		TSeries b = new() { 5, 4, 3, 2, 1, 3 };
+		DIV_Series c = new(a, b);
+		Assert.Equal(5, c.Last().v);
+	}
+
+	[Fact]
+	public void DIVSeriesDouble_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 15.0 };
+		DIV_Series c = new(a, 0);
+		Assert.Equal(double.PositiveInfinity, c.Last().v);
+	}
+
+	[Fact]
+	public void DIVDoubleSeries_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 3.0 };
+		DIV_Series c = new(12.0, a);
+		Assert.Equal(4.0, c.Last().v);
+	}
+
+	[Fact]
+	public void DIVEventing_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TSeries b = new() { 5, 4, 3, 2, 1, 0 };
+		DIV_Series c = new(a, b);
+		a.Add(12.0);
+		b.Add(2);
+		Assert.Equal(6.0, c.Last().v);
+	}
+
+	[Fact]
+	public void DIVUpdatewDouble_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 15 };
+		double b = 2;
+		DIV_Series c = new(a, b);
+		a.Add(10, true);
+		Assert.Equal(5, c.Last().v);
+	}
+
+	[Fact]
+	public void DIVUpdating_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TSeries b = new() { 5, 4, 3, 2, 1, 1 };
+		DIV_Series c = new(a, b);
+		a.Add(10, true);
+		b.Add(2, true);
+		Assert.Equal(5, c.Last().v);
+	}
+}

Tests/Basics/MUL_Test.cs

@@ -0,0 +1,64 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Basics;
+public class MUL_Test
+{
+	[Fact]
+	public void MULSeriesSeries_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TSeries b = new() { 5, 4, 3, 2, 1, 1 };
+		MUL_Series c = new(a, b);
+		Assert.Equal(5, c.Last().v);
+	}
+
+	[Fact]
+	public void MULSeriesDouble_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		MUL_Series c = new(a, 10.0);
+		Assert.Equal(50, c.Last().v);
+	}
+
+	[Fact]
+	public void MULDoubleSeries_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		MUL_Series c = new(5.0, a);
+		Assert.Equal(25, c.Last().v);
+	}
+
+	[Fact]
+	public void MULEventing_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TSeries b = new() { 5, 4, 3, 2, 1, 0 };
+		MUL_Series c = new(a, b);
+		a.Add(2);
+		b.Add(5);
+		Assert.Equal(10, c.Last().v);
+	}
+
+	[Fact]
+	public void MULUpdateDouble_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		double b = 10;
+		MUL_Series c = new(a, b);
+		a.Add(2, true);
+		Assert.Equal(20, c.Last().v);
+	}
+
+	[Fact]
+	public void MULUpdating_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TSeries b = new() { 5, 4, 3, 2, 1, 0 };
+		MUL_Series c = new(a, b);
+		a.Add(10, true);
+		b.Add(10, true);
+		Assert.Equal(100, c.Last().v);
+	}
+}

Tests/Basics/SUB_Test.cs

@@ -0,0 +1,64 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Basics;
+public class SUB_Test
+{
+	[Fact]
+	public void SUBSeriesSeries_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TSeries b = new() { 5, 4, 3, 2, 1, 1 };
+		SUB_Series c = new(a, b);
+		Assert.Equal(4, c.Last().v);
+	}
+
+	[Fact]
+	public void SUBSeriesDouble_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 15.0 };
+		SUB_Series c = new(a, 10.0);
+		Assert.Equal(5.0, c.Last().v);
+	}
+
+	[Fact]
+	public void SUBDoubleSeries_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 15.0 };
+		SUB_Series c = new(10.0, a);
+		Assert.Equal(-5.0, c.Last().v);
+	}
+
+	[Fact]
+	public void SUBEventing_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TSeries b = new() { 5, 4, 3, 2, 1, 0 };
+		SUB_Series c = new(a, b);
+		a.Add(7.0);
+		b.Add(2);
+		Assert.Equal(5.0, c.Last().v);
+	}
+
+	[Fact]
+	public void SUBUpdatewDouble_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 15 };
+		double b = 10;
+		SUB_Series c = new(a, b);
+		a.Add(1, true);
+		Assert.Equal(-9, c.Last().v);
+	}
+
+	[Fact]
+	public void SUBUpdating_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TSeries b = new() { 5, 4, 3, 2, 1, 1 };
+		SUB_Series c = new(a, b);
+		a.Add(10, true);
+		b.Add(0, true);
+		Assert.Equal(10, c.Last().v);
+	}
+}

Tests/Basics/TBars_Test.cs

@@ -0,0 +1,113 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Basics;
+public class TBars_Test
+{
+    [Fact]
+    public void InsertingTuple()
+    {
+        TBars s = new() { (t: DateTime.Today, o: double.Epsilon, h: double.NaN, l: Double.MaxValue, c: Double.NegativeInfinity, v: Double.PositiveInfinity) };
+        var tup = (t: DateTime.Today, o: double.Epsilon, h: double.NaN, l: Double.MaxValue,
+	        c: Double.NegativeInfinity, v: Double.PositiveInfinity);
+        Assert.Equal(tup, s[^1]);
+    }
+
+    [Fact]
+    public void Casting_Parameters()
+    {
+		TBars s = new()
+		{
+			{ DateTime.Today, 0.1, 1.1, 2.1, 3.1, 4.1, false }
+		};
+		Assert.Equal(0.1, s[^1].o);
+			Assert.Equal(1.1, s[^1].h);
+			Assert.Equal(2.1, s[^1].l);
+			Assert.Equal(3.1, s[^1].c);
+			Assert.Equal(4.1, s[^1].v);
+			Assert.Equal(DateTime.Today, s[^1].t);
+			Assert.Single(s);
+  }
+
+    [Fact]
+    public void Updating_Value()
+    {
+		TBars s = new()
+		{
+			{ DateTime.Today, 0.1, 1.1, 2.1, 3.1, 4.1 }
+		};
+		s.Add(DateTime.Today, 1.0, 1.0, 1.0, 1.0, 1.0, update: false);
+			s.Add(DateTime.Today, 0.0, 0.0, 0.0, 0.0, 0.0, update: true);
+      Assert.Equal(0.0, s[^1].o);
+      Assert.Equal(0.0, s[^1].h);
+      Assert.Equal(0.0, s[^1].l);
+      Assert.Equal(0.0, s[^1].c);
+      Assert.Equal(0.0, s[^1].v);
+			Assert.Equal(2, s.Count);
+    }
+    [Fact]
+    public void Extracting_TSeries()
+    {
+		TBars s = new()
+		{
+			{ DateTime.Today, 0.1, 1.1, 2.1, 3.1, 4.1 },
+			{ DateTime.Today, 2.1, 3.1, 4.1, 5.1, 6.1 }
+		};
+
+		TSeries t = s.Open;
+        Assert.Equal(t.t, s.Open.t);
+        Assert.Equal(t.v, s.Open.v);
+
+        t = s.High;
+        Assert.Equal(t.t, s.High.t);
+        Assert.Equal(t.v, s.High.v);
+
+        t = s.Low;
+        Assert.Equal(t.t, s.Low.t);
+        Assert.Equal(t.v, s.Low.v);
+
+        t = s.Close;
+        Assert.Equal(t.t, s.Close.t);
+        Assert.Equal(t.v, s.Close.v);
+
+        t = s.Volume;
+        Assert.Equal(t.t, s.Volume.t);
+        Assert.Equal(t.v, s.Volume.v);
+
+        t = s.HL2;
+        Assert.Equal(t.t, s.HL2.t);
+        Assert.Equal(t.v, s.HL2.v);
+
+        t = s.OC2;
+        Assert.Equal(t.t, s.OC2.t);
+        Assert.Equal(t.v, s.OC2.v);
+
+        t = s.OHL3;
+        Assert.Equal(t.t, s.OHL3.t);
+        Assert.Equal(t.v, s.OHL3.v);
+
+        t = s.HLC3;
+        Assert.Equal(t.t, s.HLC3.t);
+        Assert.Equal(t.v, s.HLC3.v);
+
+				t = s.OHLC4;
+				Assert.Equal(t.t, s.OHLC4.t);
+				Assert.Equal(t.v, s.OHLC4.v);
+
+				t = s.HLCC4;
+				Assert.Equal(t.t, s.HLCC4.t);
+				Assert.Equal(t.v, s.HLCC4.v);
+  }
+    [Fact]
+    public void Broadcasting_Events()
+    {
+      TBars s = new() { (DateTime.Today, 2.1, 3.1, 4.1, 5.1, 6.1) };
+      TSeries t = new();
+      s.Close.Pub += t.Sub;
+			s.Add(DateTime.Today, 0.1, 1.1, 2.1, 3.1, 4.1, false);
+			Assert.Equal(s.Close.v, t.v);
+			Assert.Equal(s.Close.Count, t.Count);
+
+  }
+}

Tests/Basics/TSeries_Test.cs

@@ -0,0 +1,63 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace Basics;
+public class TSeries_Test
+{
+    [Fact]
+    public void InsertingTuple()
+    {
+        TSeries s = new() { (t: DateTime.Today, v: double.Epsilon) };
+        Assert.Equal((DateTime.Today, double.Epsilon), s);
+    }
+
+    [Fact]
+    public void CastingTwoParameters()
+    {
+        TSeries s = new()
+        {
+            { DateTime.Today, 0.0 }
+        };
+        Assert.Equal(0.0, s[s.Count - 1].v);
+        Assert.Equal(DateTime.Today, s[s.Count - 1].t);
+    }
+
+    [Fact]
+    public void CastingOneParameter()
+    {
+        TSeries s = new()
+        {
+            double.PositiveInfinity
+        };
+        Assert.Equal(double.PositiveInfinity, (double)s);
+    }
+
+    [Fact]
+    public void UpdatingValue()
+    {
+        TSeries s = new() { 1, 2, 3, 4, 5 };
+        s.Add(0.0, update: true);
+        Assert.Equal(0.0, (double)s);
+        Assert.Equal(5, s.Count);
+    }
+    [Fact]
+    public void ReflectingSeries()
+    {
+        TSeries s = new() { 1, 2, 3, 4, 5 };
+        TSeries t = s;
+        Assert.Equal(5, (double)t);
+        Assert.Equal(5, t.Count);
+
+    }
+    [Fact]
+    public void BroadcastingEvents()
+    {
+        TSeries s = new() { 1, 2, 3, 4, 5 };
+        TSeries t = new();
+        s.Pub += t.Sub;
+        s.Add(0.0, update: true);
+        Assert.Equal(0.0, (double)t);
+
+    }
+}

Tests/MovingAvg/DEMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class DEMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		DEMA_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 };
+		DEMA_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/MovingAvg/EMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class EMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		EMA_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 };
+		EMA_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/MovingAvg/HEMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class HEMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		HEMA_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 };
+		HEMA_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/MovingAvg/HMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class HMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		HMA_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 };
+		HMA_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/MovingAvg/JMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class JMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		JMA_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 };
+		JMA_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/MovingAvg/RMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class RMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		RMA_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 };
+		RMA_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/MovingAvg/SMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class SMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		SMA_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 };
+		SMA_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/MovingAvg/TEMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class TEMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		TEMA_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 };
+		TEMA_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/MovingAvg/WMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class WMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		WMA_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 };
+		WMA_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/MovingAvg/ZLEMA_Test.cs

@@ -0,0 +1,33 @@
+using Xunit;
+using System;
+using QuanTAlib;
+
+namespace MovingAvg;
+public class ZLEMA_Test
+{
+	[Fact]
+	public void Add_Test()
+	{
+		TSeries a = new() { 0, 1, 2, 3, 4, 5 };
+		ZLEMA_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 };
+		ZLEMA_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/BIAS_Test.cs

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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/MAD_Test.cs

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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 };
+		PSDEV_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 };
+		PSDEV_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

@@ -0,0 +1,33 @@
+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 };
+		PVAR_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 };
+		PVAR_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

@@ -0,0 +1,33 @@
+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 };
+		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/SMAPE_Test.cs

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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 };
+		VAR_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 };
+		VAR_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

@@ -0,0 +1,33 @@
+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);
+
+	}
+
+}

Tests/Tests.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+
+    <Platforms>AnyCPU;x64</Platforms>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="JetBrains.dotCover.CommandLineTools" Version="2022.1.0-eap10">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0-preview-20220401-08" />
+    <PackageReference Include="Python.Included" Version="3.7.3.13" />
+    <PackageReference Include="TALib.NETCore" Version="0.4.4" />
+    <PackageReference Include="Skender.Stock.Indicators" Version="1.23.0" />
+    <PackageReference Include="xunit" Version="2.4.2-pre.12" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Source\QuanTAlib.csproj" />
+  </ItemGroup>
+
+</Project>

Tests/Validations/Pandas_TA.cs

@@ -0,0 +1,120 @@
+using Xunit;
+using System;
+using QuanTAlib;
+using Python.Runtime;
+using Python.Included;
+
+namespace Validation;
+public class PandasTA
+{
+	private readonly RND_Feed bars;
+	private readonly Random rnd = new();
+	private readonly int period;
+	private readonly dynamic ta;
+	private readonly dynamic df;
+
+	public PandasTA()
+	{
+		this.bars = new(1000);
+		this.period = this.rnd.Next(28) + 3;
+
+		Installer.SetupPython().Wait();
+		Installer.TryInstallPip();
+		Installer.PipInstallModule("numpy");
+		Installer.PipInstallModule("pandas");
+		Installer.PipInstallModule("pandas-ta");
+		PythonEngine.Initialize();
+		this.ta = Py.Import("pandas_ta");
+		this.df = this.ta.DataFrame(this.bars.Close.v);
+	}
+
+	~PandasTA()
+	{
+		PythonEngine.Shutdown();
+	}
+
+	[Fact]
+	void SMA()
+	{
+		SMA_Series QL = new(this.bars.Close, this.period, false);
+		var pta = this.ta.sma(close: this.df[0], length: this.period);
+		
+		Assert.Equal(System.Math.Round((double)pta.tail(1), 7), Math.Round(QL.Last().v, 7));
+	}
+	
+/*
+	[Fact]
+	void EMA()
+	{
+		EMA_Series QL = new(this.bars.Close, this.period, false);
+		var pta = this.ta.ema(close: this.df[0], length: this.period);
+		
+		Assert.Equal(System.Math.Round((double)pta.tail(1), 7), Math.Round(QL.Last().v, 7));
+	}
+
+		[Fact]
+	void TEMA()
+	{
+		TEMA_Series QL = new(this.bars.Close, this.period, false);
+		var pta = this.ta.tema(close: this.df[0], length: this.period);
+
+		Assert.Equal(System.Math.Round((double)pta.tail(1), 7), Math.Round(QL.Last().v, 7));
+	}
+
+		[Fact]
+	void ENTP()
+	{
+		ENTP_Series QL = new(this.bars.Close, this.period, useNaN:false);
+		var pta = this.ta.entropy(close: this.df[0], length: this.period);
+
+		Assert.Equal(System.Math.Round((double)pta.tail(1), 7), Math.Round(QL.Last().v, 7));
+	}
+
+
+	[Fact]
+	void WMA()
+	{
+		WMA_Series QL = new(this.bars.Close, this.period, false);
+		var pta = this.ta.wma(close: this.df[0], length: this.period);
+		
+		Assert.Equal(System.Math.Round((double)pta.tail(1), 7), Math.Round(QL.Last().v, 7));
+	}
+	
+	[Fact]
+	void DEMA()
+	{
+		DEMA_Series QL = new(this.bars.Close, this.period, false);
+		var pta = this.ta.dema(close: this.df[0], length: this.period);
+		
+		Assert.Equal(System.Math.Round((double)pta.tail(1), 7), Math.Round(QL.Last().v, 7));
+	}
+	
+	[Fact]
+	void BIAS()
+	{
+		BIAS_Series QL = new(this.bars.Close, this.period, false);
+		var pta = this.ta.bias(close: this.df[0], length: this.period);
+
+		Assert.Equal(System.Math.Round((double)pta.tail(1), 7), Math.Round(QL.Last().v, 7));
+	}
+
+	[Fact]
+	void KURT()
+	{
+		KURT_Series QL = new(this.bars.Close, this.period, useNaN: false);
+		var pta = this.ta.kurtosis(close: this.df[0], length: this.period);
+
+		Assert.Equal(System.Math.Round((double)pta.tail(1), 4), Math.Round(QL.Last().v, 4));
+	}
+
+	[Fact]
+	void MAD()
+	{
+		MAD_Series QL = new(this.bars.Close, this.period, useNaN: false);
+		var pta = this.ta.mad(close: this.df[0], length: this.period);
+
+		Assert.Equal(System.Math.Round((double)pta.tail(1), 7), Math.Round(QL.Last().v, 7));
+	}
+*/
+	
+}

Tests/Validations/Skender_Stock.cs

@@ -0,0 +1,93 @@
+using Xunit;
+using System;
+using Skender.Stock.Indicators;
+using QuanTAlib;
+
+
+namespace Validation;
+public class Skender_Stock
+{
+	private readonly RND_Feed bars;
+	private readonly Random rnd = new();
+	private readonly int period;
+	private readonly IEnumerable<Quote> quotes;
+
+	public Skender_Stock()
+	{
+		this.bars = new(1000);
+		this.period = this.rnd.Next(28) + 3;
+		this.quotes = this.bars.Select(
+			q => new Quote
+			{
+				Date = q.t,
+				Open = (decimal)q.o,
+				High = (decimal)q.h,
+				Low = (decimal)q.l,
+				Close = (decimal)q.c,
+				Volume = (decimal)q.v
+			});
+	}
+
+	[Fact]
+	public void SMA()
+	{
+		SMA_Series QL = new(this.bars.Close, this.period, false);
+		var SK = this.quotes.GetSma(this.period, CandlePart.Close);
+
+		Assert.Equal(Math.Round((double)SK.Last().Sma!, 8), Math.Round(QL.Last().v, 8));
+	}
+
+		[Fact]
+	public void EMA()
+	{
+		EMA_Series QL = new(this.bars.Close, this.period, false);
+		var SK = this.quotes.GetEma(this.period, CandlePart.Close);
+
+		Assert.Equal(Math.Round((double)SK.Last().Ema!, 8), Math.Round(QL.Last().v, 8));
+	}
+	[Fact]
+	public void WMA()
+	{
+		WMA_Series QL = new(this.bars.Close, this.period, false);
+		var SK = this.quotes.GetWma(this.period, CandlePart.Close);
+
+		Assert.Equal(Math.Round((double)SK.Last().Wma!, 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void DEMA()
+	{
+		DEMA_Series QL = new(this.bars.Close, this.period, false);
+		var SK = this.quotes.GetDema(this.period);
+
+		Assert.Equal(Math.Round((double)SK.Last().Dema!, 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void TEMA()
+	{
+		TEMA_Series QL = new(this.bars.Close, this.period, false);
+		var SK = this.quotes.GetTema(this.period);
+
+		Assert.Equal(Math.Round((double)SK.Last().Tema!, 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void MAD()
+	{
+		MAD_Series QL = new(this.bars.Close, this.period, false);
+		var SK = this.quotes.GetSmaExtended(this.period);
+
+		Assert.Equal(Math.Round((double)SK.Last().Mad!, 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void MAPE()
+	{
+		MAPE_Series QL = new(this.bars.Close, this.period, false);
+		var SK = this.quotes.GetSmaExtended(this.period);
+
+		Assert.Equal(Math.Round((double)SK.Last().Mape!, 8), Math.Round(QL.Last().v, 8));
+	}
+
+}

Tests/Validations/TA_LIB.cs

@@ -0,0 +1,88 @@
+using Xunit;
+using System;
+using TALib;
+using QuanTAlib;
+
+namespace Validation;
+public class TA_LIB
+{
+	private readonly RND_Feed bars;
+	private readonly Random rnd = new();
+	private readonly int period;
+	private readonly double[] TALIB;
+	private readonly double[] input;
+
+	public TA_LIB()
+	{
+		this.bars = new(1000);
+		this.period = this.rnd.Next(28) + 3;
+		this.TALIB = new double[this.bars.Count];
+		this.input = this.bars.Close.v.ToArray();
+	}
+
+/////////////////////////////////////////
+
+	[Fact]
+	public void SMA()
+	{
+		SMA_Series QL = new(this.bars.Close, this.period, false);
+		Core.Sma(this.input, 0, this.bars.Count - 1, this.TALIB, out int outBegIdx, out _, this.period);
+
+		Assert.Equal(Math.Round(this.TALIB[this.TALIB.Length - outBegIdx - 1], 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void EMA()
+	{
+		EMA_Series QL = new(this.bars.Close, this.period, false);
+		Core.Ema(this.input, 0, this.bars.Count - 1, this.TALIB, out int outBegIdx, out _, this.period);
+
+		Assert.Equal(Math.Round(this.TALIB[this.TALIB.Length - outBegIdx - 1], 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void WMA()
+	{
+		WMA_Series QL = new(this.bars.Close, this.period, false);
+		Core.Wma(this.input, 0, this.bars.Count - 1, this.TALIB, out int outBegIdx, out _, this.period);
+
+		Assert.Equal(Math.Round(this.TALIB[this.TALIB.Length - outBegIdx - 1], 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void DEMA()
+	{
+		DEMA_Series QL = new(this.bars.Close, this.period, false);
+		Core.Dema(this.input, 0, this.bars.Count - 1, this.TALIB, out int outBegIdx, out _, this.period);
+
+		Assert.Equal(Math.Round(this.TALIB[this.TALIB.Length - outBegIdx - 1], 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void TEMA()
+	{
+		TEMA_Series QL = new(this.bars.Close, this.period, false);
+		Core.Tema(this.input, 0, this.bars.Count - 1, this.TALIB, out int outBegIdx, out _, this.period);
+
+		Assert.Equal(Math.Round(this.TALIB[this.TALIB.Length - outBegIdx - 1], 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void MAX()
+	{
+		MAX_Series QL = new(this.bars.Close, this.period, false);
+		Core.Max(this.input, 0, this.bars.Count - 1, this.TALIB, out int outBegIdx, out _, this.period);
+
+		Assert.Equal(Math.Round(this.TALIB[this.TALIB.Length - outBegIdx - 1], 8), Math.Round(QL.Last().v, 8));
+	}
+
+	[Fact]
+	public void MIN()
+	{
+		MIN_Series QL = new(this.bars.Close, this.period, false);
+		Core.Min(this.input, 0, this.bars.Count - 1, this.TALIB, out int outBegIdx, out _, this.period);
+
+		Assert.Equal(Math.Round(this.TALIB[this.TALIB.Length - outBegIdx - 1], 8), Math.Round(QL.Last().v, 8));
+	}
+
+}