ZSCORE, CORR

.gitignore

@@ -12,6 +12,7 @@
 .vscode/
 *.deps.json
 .Sandbox/
+.sonarlint/
 .DS_Store
 
 # User-specific files (MonoDevelop/Xamarin Studio)

GitVersion.yml

@@ -1,3 +1,4 @@
+next-version: 0.1.19
 minor-version-bump-message: \+semver:\s?(feature|new)
 branches:
   main:
@@ -11,6 +12,6 @@ branches:
     regex: ^dev(elop)?(ment)?$
     is-release-branch: false
     mode: ContinuousDelivery
-    tag: 'v'
+    tag: 'nightly'
     increment: Inherit
 update-build-number: true

Source/Basics/Abstracts.cs

@@ -42,11 +42,24 @@ public abstract class Single_TSeries_Indicator : TSeries
 
 public abstract class Pair_TSeries_Indicator : TSeries
 {
+    protected readonly int _p;
+    protected readonly bool _NaN;
     protected readonly TSeries _d1;
     protected readonly TSeries _d2;
     protected readonly double _dd1, _dd2;
 
   // Chainable Constructors - add them at the end of primary constructors if needed
+    protected Pair_TSeries_Indicator(TSeries source1, TSeries source2, int period, bool useNaN)
+    {
+        this._p = period;
+        this._NaN = useNaN;
+        this._d1 = source1;
+        this._d2 = source2;
+        this._dd1 = double.NaN;
+        this._dd2 = double.NaN;
+        this._d1.Pub += this.Sub;
+        this._d2.Pub += this.Sub;
+    }
   protected Pair_TSeries_Indicator(TSeries source1, TSeries source2)
     {
         this._d1 = source1;

Source/Feeds/Yahoo_Feed.cs

@@ -22,24 +22,17 @@ public class Yahoo_Feed : TBars
         System.Net.Http.HttpClient client = new();
         var msg = client.GetStringAsync(requestUrl).Result;
         var jresult = JsonSerializer.Deserialize<JsonDocument>(msg).RootElement;
-        JsonElement json = new();
-        JsonElement datetime = new();
-        JsonElement open = new();
-        JsonElement high = new();
-        JsonElement low = new();
-        JsonElement close = new();
-        JsonElement volume = new();
         
-        jresult.TryGetProperty("chart",out json);
+        jresult.TryGetProperty("chart",out JsonElement json);
         json.TryGetProperty("result",out json);
-        json[0].TryGetProperty("timestamp",out datetime);
+        json[0].TryGetProperty("timestamp",out JsonElement datetime);
         json[0].TryGetProperty("indicators",out json);
         json.TryGetProperty("quote",out json);
-        json[0].TryGetProperty("open",out open);
+        json[0].TryGetProperty("open",out JsonElement open);
-        json[0].TryGetProperty("high",out high);
+        json[0].TryGetProperty("high",out JsonElement high);
-        json[0].TryGetProperty("low",out low);
+        json[0].TryGetProperty("low",out JsonElement low);
-        json[0].TryGetProperty("close",out close);
+        json[0].TryGetProperty("close",out JsonElement close);
-        json[0].TryGetProperty("volume",out volume);
+        json[0].TryGetProperty("volume",out JsonElement volume);
         
         for (int i=0; i<datetime.GetArrayLength(); i++) {
             DateTime d = DateTimeOffset.FromUnixTimeSeconds(long.Parse(datetime[i].GetRawText())).DateTime;

Source/QuanTAlib.csproj

@@ -51,7 +51,11 @@
     <PackageIcon>QuanTAlib2.png</PackageIcon>
     <PackageIconUrl>https://raw.githubusercontent.com/mihakralj/QuanTAlib/main/.github/QuanTAlib2.png</PackageIconUrl>
     <EnforceCodeStyleInBuild>True</EnforceCodeStyleInBuild>
+    <CodeAnalysisRuleSet>..\.sonarlint\mihakralj_quantalibcsharp.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
+  <ItemGroup>
+    <AdditionalFiles Include="..\.sonarlint\mihakralj_quantalib\CSharp\SonarLint.xml" Link="SonarLint.xml" />
+  </ItemGroup>
   <ItemGroup>
     <None Include="..\Docs\readme.md">
       <Pack>True</Pack>
@@ -64,10 +68,11 @@
     </None>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="System.Text.Json" Version="7.0.0" />
     <PackageReference Include="GitVersion.MsBuild" Version="5.11.1">
-      <PrivateAssets>All</PrivateAssets>
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="System.Text.Json" Version="7.0.0" />
   </ItemGroup>
   
 </Project>

Source/Statistics/CORR_Series.cs

@@ -0,0 +1,70 @@
+namespace QuanTAlib;
+using System;
+
+/* <summary>
+CORR: Pearson's Correlation Coefficient
+  PCC is a measure of linear correlation between two sets of data.
+  It is the ratio between the covariance of two variables and the product of
+  their standard deviations; it is essentially a normalized measurement of
+  the covariance, such that the result always has a value between −1 and 1.
+
+Sources:
+  https://en.wikipedia.org/wiki/Pearson_correlation_coefficient
+
+</summary> */
+
+public class CORR_Series : Pair_TSeries_Indicator
+{
+  public CORR_Series(TSeries d1, TSeries d2, int period, bool useNaN = false) : base(d1, d2, period, useNaN)
+  {
+    if (base._d1.Count > 0 && base._d2.Count > 0) { for (int i = 0; i < base._d1.Count; i++) { this.Add(base._d1[i], base._d2[i], false); } }
+  }
+
+  private readonly System.Collections.Generic.List<double> _x = new();
+  private readonly System.Collections.Generic.List<double> _xx = new();
+  private readonly System.Collections.Generic.List<double> _y = new();
+  private readonly System.Collections.Generic.List<double> _yy = new();
+  private readonly System.Collections.Generic.List<double> _xy = new();
+
+  public override void Add((System.DateTime t, double v) TValue1, (System.DateTime t, double v) TValue2, bool update)
+  {
+    if (update)
+    {
+      _x[_x.Count - 1] = TValue1.v;
+      _xx[_xx.Count - 1] = TValue1.v * TValue1.v;
+      _y[_y.Count - 1] = TValue2.v;
+      _y[_yy.Count - 1] = TValue2.v * TValue2.v;
+      _xy[_xy.Count - 1] = TValue1.v * TValue2.v;
+    }
+    else
+    {
+      _x.Add(TValue1.v);
+      _xx.Add(TValue1.v * TValue1.v);
+      _y.Add(TValue2.v);
+      _yy.Add(TValue2.v * TValue2.v);
+      _xy.Add(TValue1.v * TValue2.v);
+    }
+    if (_x.Count > this._p) { _x.RemoveAt(0); }
+    if (_xx.Count > this._p) { _xx.RemoveAt(0); }
+    if (_y.Count > this._p) { _y.RemoveAt(0); }
+    if (_yy.Count > this._p) { _yy.RemoveAt(0); }
+    if (_xy.Count > this._p) { _xy.RemoveAt(0); }
+
+    double _sumx = 0;
+    for (int i = 0; i < _x.Count; i++) { _sumx += _x[i]; }
+    double _sumxx = 0;
+    for (int i = 0; i < _xx.Count; i++) { _sumxx += _xx[i]; }
+    double _sumy = 0;
+    for (int i = 0; i < _y.Count; i++) { _sumy += _y[i]; }
+    double _sumyy = 0;
+    for (int i = 0; i < _yy.Count; i++) { _sumyy += _yy[i]; }
+    double _sumxy = 0;
+    for (int i = 0; i < _xy.Count; i++) { _sumxy += _xy[i]; }
+
+    double _div = (_sumxx - _sumx * _sumx / _p) * (_sumyy - _sumy * _sumy / _p);
+    double _cor = (_div != 0) ? (_sumxy - _sumx * _sumy / _p) / Math.Sqrt(_div) : 0.0;
+
+    var result = (TValue1.t, (this.Count < this._p - 1 && this._NaN) ? double.NaN : _cor);
+    if (update) { base[base.Count - 1] = result; } else { base.Add(result); }
+  }
+}

Source/Statistics/LINREG_Series.cs

@@ -21,17 +21,14 @@ Sources:
 
 public class LINREG_Series : Single_TSeries_Indicator
 {
-    public  TSeries Intercept { get; }
+    public readonly TSeries Intercept = new();
-    public  TSeries RSquared { get; }
+    public readonly TSeries RSquared = new();
-    public  TSeries StdDev { get; }
+    public readonly TSeries StdDev = new();
     private readonly System.Collections.Generic.List<double> _buffer = new();
 
     public LINREG_Series(TSeries source, int period, bool useNaN = false)
         : base(source, period, useNaN)
     {
-        this.Intercept = new();
-        this.RSquared = new();
-        this.StdDev = new();
         if (this._data.Count > 0) { base.Add(this._data); }
     }
 

Source/Statistics/ZSCORE_Series.cs

@@ -0,0 +1,51 @@
+namespace QuanTAlib;
+using System;
+
+/* <summary>
+ZSCORE: number of standard deviations from SMA
+  Z-score describes a value's relationship to the mean of a series, as measured in
+  terms of standard deviations from the mean. If a Z-score is 0, it indicates that
+  the data point's score is identical to the mean score. A Z-score of 1.0 would
+  indicate a value that is one standard deviation from the mean. Z-scores may be
+  positive or negative, with a positive value indicating the score is above the
+  mean and a negative score indicating it is below the mean.
+
+Sources:
+  https://en.wikipedia.org/wiki/Z-score
+  https://www.investopedia.com/terms/z/zscore.asp
+
+Calculation:
+    std = std * STDEV(close, length)
+    mean = SMA(close, length)
+    ZSCORE = (close - mean) / std
+    
+</summary> */
+
+public class ZSCORE_Series : Single_TSeries_Indicator
+{
+    public ZSCORE_Series(TSeries source, int period, bool useNaN = false) : base(source, period, useNaN)
+    {
+        if (base._data.Count > 0) { base.Add(base._data); }
+    }
+    private readonly System.Collections.Generic.List<double> _buffer = new();
+
+    public override void Add((System.DateTime t, double v) TValue, bool update)
+    {
+        if (update) { _buffer[_buffer.Count - 1] = TValue.v; }
+        else { _buffer.Add(TValue.v); }
+        if (_buffer.Count > this._p && this._p != 0) { _buffer.RemoveAt(0); }
+
+        double _sma = 0;
+        for (int i = 0; i < _buffer.Count; i++) { _sma += _buffer[i]; }
+        _sma /= this._buffer.Count;
+
+        double _pvar = 0;
+        for (int i = 0; i < _buffer.Count; i++) { _pvar += (_buffer[i] - _sma) * (_buffer[i] - _sma); }
+        _pvar /= this._buffer.Count;
+        double _psdev = Math.Sqrt(_pvar);
+        double _zscore = (_psdev == 0) ? double.NaN : (TValue.v - _sma) / _psdev;
+
+        var result = (TValue.t, (this.Count < this._p - 1 && this._NaN) ? double.NaN : _zscore);
+        base.Add(result, update);
+    }
+}

Tests/Validations/Pandas_TA.cs

@@ -58,7 +58,8 @@ public class PandasTA : IDisposable
   public void Dispose()
   {
     PythonEngine.Shutdown();
-  }
+		GC.SuppressFinalize(this);
+	}
 
   [Fact]
   void HL2()
@@ -191,10 +192,34 @@ public class PandasTA : IDisposable
   {
     TEMA_Series QL = new(bars.Close, period, false);
     var pta = df.ta.tema(close: df.close, length: period);
-    Assert.Equal(Math.Round((double)pta.tail(1), 4), Math.Round(QL.Last().v, 4));
+    Assert.Equal(Math.Round((double)pta.tail(1), 7), Math.Round(QL.Last().v, 7));
   }
 
-  [Fact]
+	[Fact]
+	void SDEV()
+	{
+		SDEV_Series QL = new(bars.Close, period, useNaN: false);
+		var pta = df.ta.stdev(close: df.close, length: period, ddof: 0);
+		Assert.Equal(Math.Round((double)pta.tail(1), 4), Math.Round(QL.Last().v, 4));
+	}
+
+	[Fact]
+	void SSDEV()
+	{
+		SSDEV_Series QL = new(bars.Close, period, useNaN: false);
+		var pta = df.ta.stdev(close: df.close, length: period, ddof: 1);
+		Assert.Equal(Math.Round((double)pta.tail(1), 4), Math.Round(QL.Last().v, 4));
+	}
+
+	[Fact]
+	void ZSCORE()
+	{
+		ZSCORE_Series QL = new(bars.Close, period, useNaN: false);
+		var pta = df.ta.zscore(close: df.close, length: period, ddof: 0);
+		Assert.Equal(Math.Round((double)pta.tail(1), 4), Math.Round(QL.Last().v, 4));
+	}
+
+	[Fact]
   void ENTP()
   {
     ENTP_Series QL = new(bars.Close, period, useNaN: false);

Tests/Validations/Skender_Stock.cs

@@ -6,277 +6,304 @@ using Xunit;
 namespace Validations;
 public class Skender_Stock
 {
-    private readonly GBM_Feed bars;
+  private readonly GBM_Feed bars;
-    private readonly Random rnd = new();
+  private readonly Random rnd = new();
-    private readonly int period;
+  private readonly int period;
-    private readonly IEnumerable<Quote> quotes;
+  private readonly IEnumerable<Quote> quotes;
 
-    public Skender_Stock()
+  public Skender_Stock()
-    {
+  {
-        bars = new(Bars: 5000, Volatility: 0.7, Drift: 0.0);
+    bars = new(Bars: 5000, Volatility: 0.7, Drift: 0.0);
-        period = rnd.Next(28) + 3;
+    period = rnd.Next(28) + 3;
-        quotes = bars.Select(
+    quotes = bars.Select(
-            q => new Quote
+        q => new Quote
-            {
+        {
-                Date = q.t,
+          Date = q.t,
-                Open = (decimal)q.o,
+          Open = (decimal)q.o,
-                High = (decimal)q.h,
+          High = (decimal)q.h,
-                Low = (decimal)q.l,
+          Low = (decimal)q.l,
-                Close = (decimal)q.c,
+          Close = (decimal)q.c,
-                Volume = (decimal)q.v
+          Volume = (decimal)q.v
-            });
+        });
-    }
+  }
 
-	[Fact]
+  [Fact]
-    public void SMA()
+  public void SMA()
-    {
+  {
-        SMA_Series QL = new(bars.Close, period, false);
+    SMA_Series QL = new(bars.Close, period, false);
-        var SK = quotes.GetSma(period);
+    var SK = quotes.GetSma(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Sma!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Sma!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void EMA()
+  public void EMA()
-    {
+  {
-        EMA_Series QL = new(bars.Close, period, false);
+    EMA_Series QL = new(bars.Close, period, false);
-        var SK = quotes.GetEma(period);
+    var SK = quotes.GetEma(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Ema!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Ema!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
-    [Fact]
+  [Fact]
-    public void WMA()
+  public void WMA()
-    {
+  {
-        WMA_Series QL = new(bars.Close, period, false);
+    WMA_Series QL = new(bars.Close, period, false);
-        var SK = quotes.GetWma(period);
+    var SK = quotes.GetWma(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Wma!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Wma!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void DEMA()
+  public void DEMA()
-    {
+  {
-        DEMA_Series QL = new(bars.Close, period, false);
+    DEMA_Series QL = new(bars.Close, period, false);
-        var SK = quotes.GetDema(period);
+    var SK = quotes.GetDema(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Dema!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Dema!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void TEMA()
+  public void TEMA()
-    {
+  {
-        TEMA_Series QL = new(bars.Close, period, false);
+    TEMA_Series QL = new(bars.Close, period, false);
-        var SK = quotes.GetTema(period);
+    var SK = quotes.GetTema(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Tema!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Tema!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void MAD()
+  public void MAD()
-    {
+  {
-        MAD_Series QL = new(bars.Close, period, false);
+    MAD_Series QL = new(bars.Close, period, false);
-        var SK = quotes.GetSmaAnalysis(period);
+    var SK = quotes.GetSmaAnalysis(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Mad!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Mad!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void MAPE()
+  public void MSE()
-    {
+  {
-        MAPE_Series QL = new(bars.Close, period, false);
+    MSE_Series QL = new(bars.Close, period, false);
-        var SK = quotes.GetSmaAnalysis(period);
+    var SK = quotes.GetSmaAnalysis(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Mape!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Mse!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void ATR()
+  public void MAPE()
-    {
+  {
-        ATR_Series QL = new(bars, period, false);
+    MAPE_Series QL = new(bars.Close, period, false);
-        var SK = quotes.GetAtr(period);
+    var SK = quotes.GetSmaAnalysis(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Atr!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Mape!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void OBV()
+  public void CORR()
-    {
+  {
-        OBV_Series QL = new(bars, period, false);
+    CORR_Series QL = new(bars.High, bars.Low, period, false);
-        var SK = quotes.GetObv(period);
+    var SK = quotes.Use(CandlePart.High).GetCorrelation(quotes.Use(CandlePart.Low), period);
 
-        // adding volume[0] to OBV to pass the test and keep compatibility with TA-LIB
+    Assert.Equal(Math.Round((double)SK.Last().Correlation!, 6), Math.Round(QL.Last().v, 6));
-        Assert.Equal(Math.Round(SK.Last().Obv! + (double)quotes.First().Volume!, 5),
+  }
-            Math.Round(QL.Last().v, 5));
-    }
 
-    [Fact]
+  [Fact]
-    public void ADL()
+  public void ATR()
-    {
+  {
-        ADL_Series QL = new(bars, false);
+    ATR_Series QL = new(bars, period, false);
-        var SK = quotes.GetAdl();
+    var SK = quotes.GetAtr(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Adl!, 5), Math.Round(QL.Last().v, 5));
+    Assert.Equal(Math.Round((double)SK.Last().Atr!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void CCI()
+  public void OBV()
-    {
+  {
-        CCI_Series QL = new(bars, period, false);
+    OBV_Series QL = new(bars, period, false);
-        var SK = quotes.GetCci(period);
+    var SK = quotes.GetObv(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Cci!, 6), Math.Round(QL.Last().v, 6));
+    // adding volume[0] to OBV to pass the test and keep compatibility with TA-LIB
-    }
+    Assert.Equal(Math.Round(SK.Last().Obv! + (double)quotes.First().Volume!, 5),
+        Math.Round(QL.Last().v, 5));
+  }
 
-    [Fact]
+  [Fact]
-    public void ATRP()
+  public void ADL()
-    {
+  {
-        ATRP_Series QL = new(bars, period, false);
+    ADL_Series QL = new(bars, false);
-        var SK = quotes.GetAtr(period);
+    var SK = quotes.GetAdl();
 
-        Assert.Equal(Math.Round((double)SK.Last().Atrp!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round(SK.Last().Adl!, 5), Math.Round(QL.Last().v, 5));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void KAMA()
+  public void CCI()
-    {
+  {
-        KAMA_Series QL = new(bars.Close, period, useNaN: false);
+    CCI_Series QL = new(bars, period, false);
-        var SK = quotes.GetKama(period);
+    var SK = quotes.GetCci(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Kama!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Cci!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void HMA()
+  public void ATRP()
-    {
+  {
-        HMA_Series QL = new(bars.Close, period, useNaN: false);
+    ATRP_Series QL = new(bars, period, false);
-        var SK = quotes.GetHma(period);
+    var SK = quotes.GetAtr(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Hma!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Atrp!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void SMMA()
+  public void KAMA()
-    {
+  {
-        SMMA_Series QL = new(bars.Close, period, useNaN: false);
+    KAMA_Series QL = new(bars.Close, period, useNaN: false);
-        var SK = quotes.GetSmma(period);
+    var SK = quotes.GetKama(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Smma!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Kama!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void MACD()
+  public void HMA()
-    {
+  {
-        MACD_Series QL = new(bars.Close, 26, 12, 9, useNaN: false);
+    HMA_Series QL = new(bars.Close, period, useNaN: false);
-        var SK = quotes.GetMacd(12, 26, 9);
+    var SK = quotes.GetHma(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Macd!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Hma!, 6), Math.Round(QL.Last().v, 6));
-        Assert.Equal(Math.Round((double)SK.Last().Signal!, 6), Math.Round(QL.Signal.Last().v, 6));
+  }
-    }
 
-    [Fact]
+  [Fact]
-    public void BBANDS()
+  public void SMMA()
-    {
+  {
-        BBANDS_Series QL = new(bars.Close, period, 2.0, useNaN: false);
+    SMMA_Series QL = new(bars.Close, period, useNaN: false);
-        var SK = quotes.GetBollingerBands(period, 2.0);
+    var SK = quotes.GetSmma(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Sma!, 6), Math.Round(QL.Mid.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Smma!, 6), Math.Round(QL.Last().v, 6));
-        Assert.Equal(Math.Round((double)SK.Last().UpperBand!, 6), Math.Round(QL.Upper.Last().v, 6));
+  }
-        Assert.Equal(Math.Round((double)SK.Last().LowerBand!, 6), Math.Round(QL.Lower.Last().v, 6));
-        Assert.Equal(Math.Round((double)SK.Last().Width!, 6), Math.Round(QL.Bandwidth.Last().v, 6));
-        Assert.Equal(Math.Round((double)SK.Last().PercentB!, 6), Math.Round(QL.PercentB.Last().v, 6));
-        Assert.Equal(Math.Round((double)SK.Last().ZScore!, 6), Math.Round(QL.Zscore.Last().v, 6));
-    }
 
-    [Fact]
+  [Fact]
-    public void RSI()
+  public void MACD()
-    {
+  {
-        RSI_Series QL = new(bars.Close, period, useNaN: false);
+    MACD_Series QL = new(bars.Close, 26, 12, 9, useNaN: false);
-        var SK = quotes.GetRsi(period);
+    var SK = quotes.GetMacd(12, 26, 9);
 
-        Assert.Equal(Math.Round((double)SK.Last().Rsi!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Macd!, 6), Math.Round(QL.Last().v, 6));
-    }
+    Assert.Equal(Math.Round((double)SK.Last().Signal!, 6), Math.Round(QL.Signal.Last().v, 6));
+  }
 
-	[Fact]
+  [Fact]
-    public void ALMA()
+  public void BBANDS()
-    {
+  {
-        ALMA_Series QL = new(bars.Close, period, useNaN: false);
+    BBANDS_Series QL = new(bars.Close, period, 2.0, useNaN: false);
-        var SK = quotes.GetAlma(period);
+    var SK = quotes.GetBollingerBands(period, 2.0);
 
-        Assert.Equal(Math.Round((double)SK.Last().Alma!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Sma!, 6), Math.Round(QL.Mid.Last().v, 6));
-    }
+    Assert.Equal(Math.Round((double)SK.Last().UpperBand!, 6), Math.Round(QL.Upper.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().LowerBand!, 6), Math.Round(QL.Lower.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Width!, 6), Math.Round(QL.Bandwidth.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().PercentB!, 6), Math.Round(QL.PercentB.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().ZScore!, 6), Math.Round(QL.Zscore.Last().v, 6));
+  }
 
-    [Fact]
+  [Fact]
-    public void SDEV()
+  public void RSI()
-    {
+  {
-        SDEV_Series QL = new(bars.Close, period, useNaN: false);
+    RSI_Series QL = new(bars.Close, period, useNaN: false);
-        var SK = quotes.GetStdDev(period);
+    var SK = quotes.GetRsi(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().StdDev!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Rsi!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void LINREG()
+  public void ALMA()
-    {
+  {
-        LINREG_Series QL = new(bars.Close, period, useNaN: false);
+    ALMA_Series QL = new(bars.Close, period, useNaN: false);
-        var SK = quotes.GetSlope(period);
+    var SK = quotes.GetAlma(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Slope!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Alma!, 6), Math.Round(QL.Last().v, 6));
-        Assert.Equal(Math.Round((double)SK.Last().Intercept!, 6), Math.Round(QL.Intercept.Last().v, 6));
+  }
-        Assert.Equal(Math.Round((double)SK.Last().RSquared!, 6), Math.Round(QL.RSquared.Last().v, 6));
-        Assert.Equal(Math.Round((double)SK.Last().StdDev!, 6), Math.Round(QL.StdDev.Last().v, 6));
-    }
 
-    [Fact]
+  [Fact]
-    public void TR()
+  public void SDEV()
-    {
+  {
-        TR_Series QL = new(bars, useNaN: false);
+    SDEV_Series QL = new(bars.Close, period, useNaN: false);
-        var SK = quotes.GetTr();
+    var SK = quotes.GetStdDev(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Tr!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().StdDev!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void HL2()
+  public void ZSCORE()
-    {
+  {
-        TSeries QL = bars.HL2;
+    ZSCORE_Series QL = new(bars.Close, period, useNaN: false);
-        var SK = quotes.GetBaseQuote(CandlePart.HL2);
+    var SK = quotes.GetStdDev(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().ZScore!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void OC2()
+  public void LINREG()
-    {
+  {
-        TSeries QL = bars.OC2;
+    LINREG_Series QL = new(bars.Close, period, useNaN: false);
-        var SK = quotes.GetBaseQuote(CandlePart.OC2);
+    var SK = quotes.GetSlope(period);
 
-        Assert.Equal(Math.Round((double)SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Slope!, 6), Math.Round(QL.Last().v, 6));
-    }
+    Assert.Equal(Math.Round((double)SK.Last().Intercept!, 6), Math.Round(QL.Intercept.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().RSquared!, 6), Math.Round(QL.RSquared.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().StdDev!, 6), Math.Round(QL.StdDev.Last().v, 6));
+  }
 
-    [Fact]
+  [Fact]
-    public void HLC3()
+  public void TR()
-    {
+  {
-        TSeries QL = bars.HLC3;
+    TR_Series QL = new(bars, useNaN: false);
-        var SK = quotes.GetBaseQuote(CandlePart.HLC3);
+    var SK = quotes.GetTr();
 
-        Assert.Equal(Math.Round((double)SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round((double)SK.Last().Tr!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void OHL3()
+  public void HL2()
-    {
+  {
-        TSeries QL = bars.OHL3;
+    TSeries QL = bars.HL2;
-        var SK = quotes.GetBaseQuote(CandlePart.OHL3);
+    var SK = quotes.GetBaseQuote(CandlePart.HL2);
 
-        Assert.Equal(Math.Round((double)SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round(SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void OHLC4()
+  public void OC2()
-    {
+  {
-        TSeries QL = bars.OHLC4;
+    TSeries QL = bars.OC2;
-        var SK = quotes.GetBaseQuote(CandlePart.OHLC4);
+    var SK = quotes.GetBaseQuote(CandlePart.OC2);
 
-        Assert.Equal(Math.Round((double)SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
+    Assert.Equal(Math.Round(SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
-    }
+  }
+
+  [Fact]
+  public void HLC3()
+  {
+    TSeries QL = bars.HLC3;
+    var SK = quotes.GetBaseQuote(CandlePart.HLC3);
+
+    Assert.Equal(Math.Round(SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
+  }
+
+  [Fact]
+  public void OHL3()
+  {
+    TSeries QL = bars.OHL3;
+    var SK = quotes.GetBaseQuote(CandlePart.OHL3);
+
+    Assert.Equal(Math.Round(SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
+  }
+
+  [Fact]
+  public void OHLC4()
+  {
+    TSeries QL = bars.OHLC4;
+    var SK = quotes.GetBaseQuote(CandlePart.OHLC4);
+
+    Assert.Equal(Math.Round((double)SK.Last().Value!, 6), Math.Round(QL.Last().v, 6));
+  }
 }

Tests/Validations/TA_LIB.cs

@@ -6,304 +6,313 @@ using QuanTAlib;
 namespace Validations;
 public class TA_LIB
 {
-    private readonly GBM_Feed bars;
+  private readonly GBM_Feed bars;
-    private readonly Random rnd = new();
+  private readonly Random rnd = new();
-    private readonly int period;
+  private readonly int period;
-    private readonly double[] TALIB;
+  private readonly double[] TALIB;
-    private readonly double[] inopen;
+  private readonly double[] inopen;
-    private readonly double[] inhigh;
+  private readonly double[] inhigh;
-    private readonly double[] inlow;
+  private readonly double[] inlow;
-    private readonly double[] inclose;
+  private readonly double[] inclose;
-    private readonly double[] involume;
+  private readonly double[] involume;
 
-    public TA_LIB()
+  public TA_LIB()
-    {
+  {
-        bars = new(5000);
+    bars = new(5000);
-        period = rnd.Next(28) + 3;
+    period = rnd.Next(28) + 3;
-        TALIB = new double[bars.Count];
+    TALIB = new double[bars.Count];
-        inopen = bars.Open.v.ToArray();
+    inopen = bars.Open.v.ToArray();
-        inhigh = bars.High.v.ToArray();
+    inhigh = bars.High.v.ToArray();
-        inlow = bars.Low.v.ToArray();
+    inlow = bars.Low.v.ToArray();
-        inclose = bars.Close.v.ToArray();
+    inclose = bars.Close.v.ToArray();
-        involume = bars.Volume.v.ToArray();
+    involume = bars.Volume.v.ToArray();
-    }
+  }
 
-    /////////////////////////////////////////
+  /////////////////////////////////////////
 
-    [Fact]
+  [Fact]
-    public void ADD()
+  public void ADD()
-    {
+  {
-        ADD_Series QL = new(bars.Open, bars.Close);
+    ADD_Series QL = new(bars.Open, bars.Close);
-        Core.Add(inopen, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.Add(inopen, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void SUB()
+  public void SUB()
-    {
+  {
-        SUB_Series QL = new(bars.Open, bars.Close);
+    SUB_Series QL = new(bars.Open, bars.Close);
-        Core.Sub(inopen, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.Sub(inopen, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void MUL()
+  public void MUL()
-    {
+  {
-        MUL_Series QL = new(bars.Open, bars.Close);
+    MUL_Series QL = new(bars.Open, bars.Close);
-        Core.Mult(inopen, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.Mult(inopen, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void DIV()
+  public void DIV()
-    {
+  {
-        DIV_Series QL = new(bars.Open, bars.Close);
+    DIV_Series QL = new(bars.Open, bars.Close);
-        Core.Div(inopen, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.Div(inopen, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void SDEV()
+  public void CORR()
-    {
+  {
-        SDEV_Series QL = new(bars.Close, period, false);
+    CORR_Series QL = new(bars.Open, bars.Close, period);
-        Core.StdDev(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Correl(inopen, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, optInTimePeriod: period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void SMA()
+  public void SDEV()
-    {
+  {
-        SMA_Series QL = new(bars.Close, period, false);
+    SDEV_Series QL = new(bars.Close, period, false);
-        Core.Sma(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.StdDev(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void SUM()
+  public void SMA()
-    {
+  {
-	    SUM_Series QL = new(bars.Close, period, false);
+    SMA_Series QL = new(bars.Close, period, false);
-	    Core.Sum(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Sma(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-	    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void MIDPRICE()
+  public void SUM()
-    {
+  {
-	    MIDPRICE_Series QL = new(bars, period, false);
+    SUM_Series QL = new(bars.Close, period, false);
-	    Core.MidPrice(inhigh, inlow, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Sum(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-	    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
+
+  [Fact]
+  public void MIDPRICE()
+  {
+    MIDPRICE_Series QL = new(bars, period, false);
+    Core.MidPrice(inhigh, inlow, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+  }
 
 
-	[Fact]
+  [Fact]
-	public void VAR()
+  public void VAR()
-	{
+  {
-		VAR_Series QL = new(bars.Close, period, false);
+    VAR_Series QL = new(bars.Close, period, false);
-		Core.Var(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Var(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-		Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 5, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 5));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 5, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 5));
-	}
+  }
 
-	[Fact]
+  [Fact]
-    public void MIDPOINT()
+  public void MIDPOINT()
-    {
+  {
-	    MIDPOINT_Series QL = new(bars.Close, period, false);
+    MIDPOINT_Series QL = new(bars.Close, period, false);
-	    Core.MidPoint(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.MidPoint(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-	    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-	[Fact]
+  [Fact]
-    public void TRIMA()
+  public void TRIMA()
-    {
+  {
-        TRIMA_Series QL = new(bars.Close, period, false);
+    TRIMA_Series QL = new(bars.Close, period, false);
-        Core.Trima(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Trima(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void EMA()
+  public void EMA()
-    {
+  {
-        EMA_Series QL = new(bars.Close, period, false);
+    EMA_Series QL = new(bars.Close, period, false);
-        Core.Ema(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Ema(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void WMA()
+  public void WMA()
-    {
+  {
-        WMA_Series QL = new(bars.Close, period, false);
+    WMA_Series QL = new(bars.Close, period, false);
-        Core.Wma(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Wma(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void DEMA()
+  public void DEMA()
-    {
+  {
-        DEMA_Series QL = new(bars.Close, period, false);
+    DEMA_Series QL = new(bars.Close, period, false);
-        Core.Dema(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Dema(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void TEMA()
+  public void TEMA()
-    {
+  {
-        TEMA_Series QL = new(bars.Close, period, false);
+    TEMA_Series QL = new(bars.Close, period, false);
-        Core.Tema(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Tema(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void MAX()
+  public void MAX()
-    {
+  {
-        MAX_Series QL = new(bars.Close, period, false);
+    MAX_Series QL = new(bars.Close, period, false);
-        Core.Max(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Max(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void MIN()
+  public void MIN()
-    {
+  {
-        MIN_Series QL = new(bars.Close, period, false);
+    MIN_Series QL = new(bars.Close, period, false);
-        Core.Min(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Min(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void ADL()
+  public void ADL()
-    {
+  {
-        ADL_Series QL = new(bars, false);
+    ADL_Series QL = new(bars, false);
-        Core.Ad(inhigh, inlow, inclose, involume, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.Ad(inhigh, inlow, inclose, involume, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void OBV()
+  public void OBV()
-    {
+  {
-        OBV_Series QL = new(bars, period, false);
+    OBV_Series QL = new(bars, period, false);
-        Core.Obv(inclose, involume, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.Obv(inclose, involume, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void ADOSC()
+  public void ADOSC()
-    {
+  {
-        ADOSC_Series QL = new(bars, false);
+    ADOSC_Series QL = new(bars, false);
-        Core.AdOsc(inhigh, inlow, inclose, involume, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.AdOsc(inhigh, inlow, inclose, involume, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void ATR()
+  public void ATR()
-    {
+  {
-        ATR_Series QL = new(bars, period, false);
+    ATR_Series QL = new(bars, period, false);
-        Core.Atr(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Atr(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void CCI()
+  public void CCI()
-    {
+  {
-        CCI_Series QL = new(bars, period, false);
+    CCI_Series QL = new(bars, period, false);
-        Core.Cci(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Cci(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void RSI()
+  public void RSI()
-    {
+  {
-        RSI_Series QL = new(bars.Close, period, false);
+    RSI_Series QL = new(bars.Close, period, false);
-        Core.Rsi(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
+    Core.Rsi(inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _, period);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void TR()
+  public void TR()
-    {
+  {
-        TR_Series QL = new(bars, false);
+    TR_Series QL = new(bars, false);
-        Core.TRange(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.TRange(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void MACD()
+  public void MACD()
-    {
+  {
-        double[] macdSignal = new double[bars.Count];
+    double[] macdSignal = new double[bars.Count];
-        double[] macdHist = new double[bars.Count];
+    double[] macdHist = new double[bars.Count];
-        MACD_Series QL = new(bars.Close, slow: 26, fast: 12, signal: 9, false);
+    MACD_Series QL = new(bars.Close, slow: 26, fast: 12, signal: 9, false);
-        Core.Macd(inclose, 0, bars.Count - 1, outMacd: TALIB, outMacdSignal: macdSignal, outMacdHist: macdHist, out int outBegIdx, out _);
+    Core.Macd(inclose, 0, bars.Count - 1, outMacd: TALIB, outMacdSignal: macdSignal, outMacdHist: macdHist, out int outBegIdx, out _);
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-        Assert.Equal(Math.Round(macdSignal[macdSignal.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Signal.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(macdSignal[macdSignal.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Signal.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void BBANDS()
+  public void BBANDS()
-    {
+  {
-        double[] outMiddle = new double[bars.Count];
+    double[] outMiddle = new double[bars.Count];
-        double[] outUpper = new double[bars.Count];
+    double[] outUpper = new double[bars.Count];
-        double[] outLower = new double[bars.Count];
+    double[] outLower = new double[bars.Count];
-        BBANDS_Series QL = new(bars.Close, period: 26, multiplier: 2.0, false);
+    BBANDS_Series QL = new(bars.Close, period: 26, multiplier: 2.0, false);
-        Core.Bbands(inclose, 0, bars.Count - 1, outRealUpperBand: outUpper, outRealMiddleBand: outMiddle, outRealLowerBand: outLower, out int outBegIdx, out _, optInTimePeriod: 26, optInNbDevUp: 2.0, optInNbDevDn: 2.0);
+    Core.Bbands(inclose, 0, bars.Count - 1, outRealUpperBand: outUpper, outRealMiddleBand: outMiddle, outRealLowerBand: outLower, out int outBegIdx, out _, optInTimePeriod: 26, optInNbDevUp: 2.0, optInNbDevDn: 2.0);
-        Assert.Equal(Math.Round(outUpper[outUpper.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Upper.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(outUpper[outUpper.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Upper.Last().v, 6, MidpointRounding.AwayFromZero));
-        Assert.Equal(Math.Round(outMiddle[outMiddle.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Mid.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(outMiddle[outMiddle.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Mid.Last().v, 6, MidpointRounding.AwayFromZero));
-        Assert.Equal(Math.Round(outLower[outLower.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Lower.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(outLower[outLower.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Lower.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void HL2()
+  public void HL2()
-    {
+  {
-        TSeries QL = bars.HL2;
+    TSeries QL = bars.HL2;
-        Core.MedPrice(inhigh, inlow, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.MedPrice(inhigh, inlow, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void HLC3()
+  public void HLC3()
-    {
+  {
-        TSeries QL = bars.HLC3;
+    TSeries QL = bars.HLC3;
-        Core.TypPrice(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.TypPrice(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void OHLC4()
+  public void OHLC4()
-    {
+  {
-        TSeries QL = bars.OHLC4;
+    TSeries QL = bars.OHLC4;
-        Core.AvgPrice(inopen, inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.AvgPrice(inopen, inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 
-    [Fact]
+  [Fact]
-    public void HLCC4()
+  public void HLCC4()
-    {
+  {
-        TSeries QL = bars.HLCC4;
+    TSeries QL = bars.HLCC4;
-        Core.WclPrice(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
+    Core.WclPrice(inhigh, inlow, inclose, 0, bars.Count - 1, TALIB, out int outBegIdx, out _);
 
-        Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
+    Assert.Equal(Math.Round(TALIB[TALIB.Length - outBegIdx - 1], 6, MidpointRounding.AwayFromZero), Math.Round(QL.Last().v, 6, MidpointRounding.AwayFromZero));
-    }
+  }
 }

docs/.md

@@ -1,87 +0,0 @@
-
-## 1. Prepare the Peloton tablet
-
-Stop Peloton overlay app:
-- tap on Settings in the top right corner and select Device Settings
-- tap Apps and scroll down to find and tap Peloton app (not Peloton Launcher, just Peloton)
-- tap FORCE STOP to stop the app overlay
-- confrm by tapping OK
-
-Turn on developer mode
-- return to Settings page
-- tap About tablet in System section
-- tap Build number repeatedly until you activate developer mode
-
-Enable USB debugging
-- return to Settings page
-- tap (now visible) Developer options in System section
-- scroll down to find USB Debugging option
-- Enable USB debugging
-- Confirm by tapping OK
-	
-## 3. Prepare the PC with Zwift/Rouvy
-
-- Create your Splashtop account https://my.splashtop.com/login
-- Download and install Splashtop Streamer https://www.splashtop.com/downloads#pers
-- Download Android Platform Tools https://developer.android.com/studio/releases/platform-tools
-- Download Nova launcher APK (or any other launcher that works on Android 7) https://apkpure.com/nova-launcher/com.teslacoilsw.launcher/download/62019-APK
-- Download Splashtop APK https://apkpure.com/splashtop-personal-access/com.splashtop.remote.pad.v2
-- Unzip Android tools into a new folder
-- move both APKs to the same folder
-- Run Command Prompt (CMD) and move to the same folder
-- Launch Android Debuging Bridge: adb start-server
-- Connect PC and Peloton tablet with USB cable
-- Peloton tablet will check for confirmation; Accept debugging over USB
-- Verify connectivity on PC in the Command window: adb devices
-
-## 4. Side-load APKs
-
-- Execute the following three commands on PC:
-	adb shell settings put secure install_non_market_apps 1
-	adb install <name_of_nova_launcher.apk>
-	adb install <name_of_splashtop.apk>
-- Disconnect USB cable
-- On Peloton tablet tap Peloton 'P' logo at the bottom 
-- Select Nova as a default launcher
-- Accept all defaults for Nova launcher - you can customize it later
-
-
-- (optional) Bring Peloton and Splashtop icons to the main page of Nova launcher
-- Choosing Peloton launches Peloton app; Choosing Splashtop launches Splashtop app
-- Swiping down from the top of the screen reveals the hidden 'P' launcher button
-
-## 5. Connect Peloton tablet and PC
-
-- Launch Splashtop app on Peloton tablet
-- Login with Splashtop credentials
-- Connect to PC that runs Splashtop streamer (and Zwift/Rouvy)
-- Launch Zwift/Rouvy 
-
-## 5. Enable sensors
-
-- (optional): buy ANT+ USB dongle https://www.amazon.com/s?k=ant%2B+USB+stick
-
-Peloton Tread:
-	Speed: Runn https://npe-inc.com/runn-smart-treadmill-sensor-2/
-	(or Stryd https://www.stryd.com/us/en)
-	Cadence: Garmin foodpod (or Stryd)
-	Heartrate:	any HR monitor (BT or ANT+) https://www.amazon.com/s?k=bluetooth+HR+monitor
-	Power: Stryd
-	
-Peloton Bike (gen1):	
-	Power & Cadence: DFC (Data Fitness Connector) https://www.crowdsupply.com/intelligenate/data-fitness-connector
-	Heartrate:vany HR monitor (BT or ANT+)
-	
-## 6. Navigation
-
-Nova is now a default launcher on Android tablet, but on Tread we need to run Peloton app in the background to prevent locking of treadmill:
-
-- Launch Peloton app
-- Swipe down from the top and return to Nova launcher
-- Launch Splashtop app
-- Connect to PC
-- Launch Zwift or Rouvy
-- Connect all sensors
-- Run/Ride!
-	
-	

docs/readme.md

@@ -38,13 +38,13 @@ See [Getting Started](https://github.com/mihakralj/QuanTAlib/blob/main/Docs/gett
 | **BASIC TRANSFORMS** | **QuanTAlib** | **TA-LIB** | **Skender** | **Pandas TA** |
 |--|:--:|:--:|:--:|:--:|
 | ⭐ OC2 - (Open+Close)/2 |️ `.OC2` || CandlePart.OC2 ||
-| ⭐ HL2 - Median Price | `.HL2` | MEDPRICE | CandlePart.HL2 ||
+| ⭐ HL2 - Median Price | `.HL2` | MEDPRICE | CandlePart.HL2 | hl2 |
-| ⭐ HLC3 - Typical Price | `.HLC3` | TYPPRICE | CandlePart.HLC3 ||
+| ⭐ HLC3 - Typical Price | `.HLC3` | TYPPRICE | CandlePart.HLC3 | hlc3 |
 | ⭐ OHL3 - (Open+High+Low)/3 | `.OHL3` || CandlePart.OHL3 ||
-| ⭐ OHLC4 - Average Price | `.OHLC4` | AVGPRICE |️ CandlePart.OHLC4 ||
+| ⭐ OHLC4 - Average Price | `.OHLC4` | AVGPRICE |️ CandlePart.OHLC4 | ohlc4 |
 | ⭐ HLCC4 - Weighted Price |  `.HLCC4` | WCLPRICE | CandlePart.HLCC4 ||
-| ⭐ MIDPOINT - Midpoint value | `MIDPOINT_Series` | MIDPOINT |||
+| ⭐ MIDPOINT - Midpoint value | `MIDPOINT_Series` | MIDPOINT || midpoint |
-| ⭐ MIDPRICE - Midpoint price | `MIDPRICE_Series` | MIDPRICE |||
+| ⭐ MIDPRICE - Midpoint price | `MIDPRICE_Series` | MIDPRICE || midprice |
 | ⭐ MAX - Max value | `MAX_Series` | MAX |||
 | ⭐ MIN - Min value | `MIN_Series` | MIN |||
 | ⭐ SUM - Summation | `SUM_Series` | SUM |||
@@ -55,7 +55,7 @@ See [Getting Started](https://github.com/mihakralj/QuanTAlib/blob/main/Docs/gett
 |||||
 | **STATISTICS & NUMERICAL ANALYSIS** | **QuanTAlib** | **TA-LIB** | **Skender** | **Pandas TA** |
 | ⭐ BIAS - Bias | `BIAS_Series` ||| bias |
-| ⛔ CORREL - Pearson's Correlation Coefficient || CORREL | GetCorrelation ||
+| ⭐ CORR - Pearson's Correlation Coefficient | `CORR_Series` | CORREL | GetCorrelation ||
 | ⛔ COVAR - Covariance ||| GetCorrelation ||
 | ⭐ ENTP - Entropy | `ENTP_Series` ||| entropy |
 | ⭐ KURT - Kurtosis | `KURT_Series` ||| kurtosis |
@@ -63,54 +63,54 @@ See [Getting Started](https://github.com/mihakralj/QuanTAlib/blob/main/Docs/gett
 | ⭐ MAD - Mean Absolute Deviation | `MAD_Series` || GetSma | mad |
 | ⭐ MAPE - Mean Absolute Percent Error | `MAPE_Series` || GetSma ||
 | ⭐ MED - Median value | `MED_Series` ||| median |
-| ✔️ MSE - Mean Squared Error | `MSE_Series` || GetSma ||
+| ⭐ MSE - Mean Squared Error | `MSE_Series` || GetSma ||
-| ⛔ SKEW - Skewness |||||
+| ⛔ SKEW - Skewness |||| skew |
-| ⭐ SDEV - Standard Deviation (Volatility) | `SDEV_Series` | STDDEV |||
+| ⭐ SDEV - Standard Deviation (Volatility) | `SDEV_Series` | STDDEV | GetStdDev | stdev |
-| ✔️ SSDEV - Sample Standard Deviation | `SSDEV_Series` ||||
+| ⭐ SSDEV - Sample Standard Deviation | `SSDEV_Series` ||| stdev |
 | ✔️ SMAPE - Symmetric Mean Absolute Percent Error | `SMAPE_Series` ||||
 | ⭐ VAR - Population Variance | `VAR_Series` | VAR || variance |
 | ⭐ SVAR - Sample Variance | `SVAR_Series` ||| variance |
-| ⛔ QUANT - Quantile |||||
+| ⛔ QUANTILE - Quantile |||| quantile |
 | ✔️ WMAPE - Weighted Mean Absolute Percent Error | `WMAPE_Series` ||||
-| ⛔ ZSCORE - Number of standard deviations from mean |||||
+| ⭐ ZSCORE - Number of standard deviations from mean | `ZSCORE_Series` || GetStdDev | zscore |
 ||||||
 | **TREND INDICATORS & AVERAGES** | **QuanTAlib** | **TA-LIB** | **Skender** | **Pandas TA** |
 | ⛔ AFIRMA - Autoregressive Finite Impulse Response Moving Average |||||
-| ⭐ ALMA - Arnaud Legoux Moving Average | `ALMA_Series` || GetAlma ||
+| ⭐ ALMA - Arnaud Legoux Moving Average | `ALMA_Series` || GetAlma | alma |
 | ⛔ ARIMA - Autoregressive Integrated Moving Average |||||
 | ⭐ DEMA - Double EMA Average | `DEMA_Series` | DEMA | GetDema | dema |
 | ⭐ EMA - Exponential Moving Average | `EMA_Series` || GetEma | ema |
 | ⛔ EPMA - Endpoint Moving Average ||| GetEpma ||
 | ⛔ FRAMA - Fractal Adaptive Moving Average |||||
-| ⛔ FWMA - Fibonacci's Weighted Moving Average |||||
+| ⛔ FWMA - Fibonacci's Weighted Moving Average |||| fwma |
-| ⛔ HILO - Gann High-Low Activator |||||
+| ⛔ HILO - Gann High-Low Activator |||| hilo |
 | ✔️ HEMA - Hull/EMA Average | `HEMA_Series` ||||
 | ⛔ Hilbert Transform Instantaneous Trendline || HT_TRENDLINE | GetHtTrendline ||
 | ⭐ HMA - Hull  Moving Average | `HMA_Series` || GetHma | hma |
-| ⛔ HWMA - Holt-Winter Moving Average |||||
+| ⛔ HWMA - Holt-Winter Moving Average |||| hwma |
-| ✔️ JMA - Jurik Moving Average | `JMA_Series` ||||
+| ✔️ JMA - Jurik Moving Average | `JMA_Series` ||| jma |
 | ⭐ KAMA - Kaufman's Adaptive Moving Average | `KAMA_Series` | KAMA | GetKama | kama |
-| ⛔ KDJ - KDJ Indicator (trend reversal) |||||
+| ⛔ KDJ - KDJ Indicator (trend reversal) |||| kdj |
 | ⛔ LSMA - Least Squares Moving Average |||||
-| ⭐ MACD - Moving Average Convergence/Divergence | `MACD_Series` | MACD | GetMacd ||
+| ⭐ MACD - Moving Average Convergence/Divergence | `MACD_Series` | MACD | GetMacd | macd |
 | ⛔ MAMA - MESA Adaptive Moving Average || MAMA | GetMama ||
-| ⛔ MCGD - McGinley Dynamic |||||
+| ⛔ MCGD - McGinley Dynamic |||| mcgd |
 | ⛔ MMA - Modified Moving Average |||||
 | ⛔ PPMA - Pivot Point Moving Average |||||
-| ⛔ PWMA - Pascal's Weighted Moving Average |||||
+| ⛔ PWMA - Pascal's Weighted Moving Average |||| pwma |
 | ⭐ RMA - WildeR's Moving Average | `RMA_Series` ||| rma |
-| ⛔ SINWMA - Sine Weighted Moving Average |||||
+| ⛔ SINWMA - Sine Weighted Moving Average |||| sinwma |
 | ⭐ SMA - Simple Moving Average | `SMA_Series` | SMA | GetSma | sma |
 | ⭐ SMMA - Smoothed Moving Average | `SMMA_Series` || GetSmma ||
-| ⛔ SSF - Ehler's Super Smoother Filter |||||
+| ⛔ SSF - Ehler's Super Smoother Filter |||| ssf |
-| ⛔ SUP - Supertrend |||||
+| ⛔ SUPERTREND - Supertrend |||| supertrend |
-| ⛔ SWMA - Symmetric Weighted Moving Average |||||
+| ⛔ SWMA - Symmetric Weighted Moving Average |||| swma |
-| ⛔ T3 - Tillson T3 Moving Average || T3 | GetT3 ||
+| ⛔ T3 - Tillson T3 Moving Average || T3 | GetT3 | t3 |
 | ⭐ TEMA - Triple EMA Average | `TEMA_Series` | TEMA | GetTema | tema |
-| ⭐ TRIMA - Triangular Moving Average | `TRIMA_Series` | TRIMA |||
+| ⭐ TRIMA - Triangular Moving Average | `TRIMA_Series` | TRIMA || trima |
 | ⛔ TSF - Time Series Forecast || TSF |||
-| ⛔ VIDYA - Variable Index Dynamic Average |||||
+| ⛔ VIDYA - Variable Index Dynamic Average |||| vidya |
-| ⛔ VOR - Vortex Indicator |||||
+| ⛔ VORTEX - Vortex Indicator |||| vortex |
 | ⭐ WMA - Weighted Moving Average | `WMA_Series` | WMA | GetWma | wma |
 | ⭐ ZLEMA - Zero Lag EMA Average | `ZLEMA_Series` ||| zlma |
 ||||||