mirror of
https://github.com/mihakralj/QuanTAlib.git
synced 2026-08-24 05:28:05 +00:00
SIMD Refactor: Merge simd-dev into dev (#55)
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com> Co-authored-by: aider (openrouter/anthropic/claude-sonnet-4) <aider@aider.chat> Co-authored-by: Warp <agent@warp.dev>
This commit is contained in:
Miha Kralj
co-authored by
Claude Opus 4.5
aider
Warp
Claude Opus 4.5
aider
Warp
parent
5bcdf8d614
commit
86fe32a682
@@ -0,0 +1,89 @@
|
||||
using TradingPlatform.BusinessLayer;
|
||||
using QuanTAlib;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class AdlIndicatorTests
|
||||
{
|
||||
[Fact]
|
||||
public void AdlIndicator_Constructor_SetsDefaults()
|
||||
{
|
||||
var indicator = new AdlIndicator();
|
||||
|
||||
Assert.Equal("ADL - Accumulation/Distribution Line", indicator.Name);
|
||||
Assert.True(indicator.SeparateWindow);
|
||||
Assert.True(indicator.OnBackGround);
|
||||
Assert.Equal(0, AdlIndicator.MinHistoryDepths);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdlIndicator_ShortName_IsCorrect()
|
||||
{
|
||||
var indicator = new AdlIndicator();
|
||||
Assert.Equal("ADL", indicator.ShortName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdlIndicator_MinHistoryDepths_EqualsZero()
|
||||
{
|
||||
var indicator = new AdlIndicator();
|
||||
|
||||
Assert.Equal(0, AdlIndicator.MinHistoryDepths);
|
||||
Assert.Equal(0, ((IWatchlistIndicator)indicator).MinHistoryDepths);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdlIndicator_Initialize_CreatesInternalAdl()
|
||||
{
|
||||
var indicator = new AdlIndicator();
|
||||
|
||||
// Initialize should not throw
|
||||
indicator.Initialize();
|
||||
|
||||
// After init, line series should exist
|
||||
Assert.Single(indicator.LinesSeries);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdlIndicator_ProcessUpdate_HistoricalBar_ComputesValue()
|
||||
{
|
||||
var indicator = new AdlIndicator();
|
||||
indicator.Initialize();
|
||||
|
||||
// Add historical data
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i, 1000);
|
||||
|
||||
// Process update for each bar to simulate history loading
|
||||
var args = new UpdateArgs(UpdateReason.HistoricalBar);
|
||||
indicator.ProcessUpdate(args);
|
||||
}
|
||||
|
||||
// Line series should have a value
|
||||
double val = indicator.LinesSeries[0].GetValue(0);
|
||||
Assert.True(double.IsFinite(val));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AdlIndicator_ProcessUpdate_NewBar_ComputesValue()
|
||||
{
|
||||
var indicator = new AdlIndicator();
|
||||
indicator.Initialize();
|
||||
|
||||
var now = DateTime.UtcNow;
|
||||
for (int i = 0; i < 20; i++)
|
||||
{
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(i), 100 + i, 110 + i, 90 + i, 105 + i, 1000);
|
||||
}
|
||||
|
||||
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.HistoricalBar));
|
||||
|
||||
// Add new bar
|
||||
indicator.HistoricalData.AddBar(now.AddMinutes(20), 120, 130, 110, 125, 1500);
|
||||
indicator.ProcessUpdate(new UpdateArgs(UpdateReason.NewBar));
|
||||
|
||||
Assert.Equal(2, indicator.LinesSeries[0].Count);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
using System.Drawing;
|
||||
using System.Runtime.CompilerServices;
|
||||
using TradingPlatform.BusinessLayer;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
[SkipLocalsInit]
|
||||
public sealed class AdlIndicator : Indicator, IWatchlistIndicator
|
||||
{
|
||||
[InputParameter("Show cold values", sortIndex: 21)]
|
||||
public bool ShowColdValues { get; set; } = true;
|
||||
|
||||
private Adl _adl = null!;
|
||||
private readonly LineSeries _series;
|
||||
|
||||
public static int MinHistoryDepths => 0;
|
||||
int IWatchlistIndicator.MinHistoryDepths => MinHistoryDepths;
|
||||
|
||||
public override string ShortName => "ADL";
|
||||
public override string SourceCodeLink => "https://github.com/mihakralj/QuanTAlib/blob/main/lib/volume/adl/Adl.Quantower.cs";
|
||||
|
||||
public AdlIndicator()
|
||||
{
|
||||
OnBackGround = true;
|
||||
SeparateWindow = true;
|
||||
Name = "ADL - Accumulation/Distribution Line";
|
||||
Description = "Accumulation/Distribution Line";
|
||||
|
||||
_series = new LineSeries(name: "ADL", color: Color.Blue, width: 2, style: LineStyle.Solid);
|
||||
AddLineSeries(_series);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
protected override void OnInit()
|
||||
{
|
||||
_adl = new Adl();
|
||||
base.OnInit();
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
protected override void OnUpdate(UpdateArgs args)
|
||||
{
|
||||
TBar bar = this.GetInputBar(args);
|
||||
TValue result = _adl.Update(bar, args.IsNewBar());
|
||||
|
||||
_series.SetValue(result.Value, _adl.IsHot, ShowColdValues);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,209 @@
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class AdlTests
|
||||
{
|
||||
[Fact]
|
||||
public void Adl_BasicCalculation_ReturnsExpectedValues()
|
||||
{
|
||||
// Arrange
|
||||
var adl = new Adl();
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Bar 1: Close=10, High=12, Low=8. Range=4.
|
||||
// MFM = ((10-8) - (12-10)) / 4 = (2 - 2) / 4 = 0.
|
||||
// Vol = 100. MFV = 0. ADL = 0.
|
||||
var bar1 = new TBar(time, 10, 12, 8, 10, 100);
|
||||
var val1 = adl.Update(bar1);
|
||||
Assert.Equal(0, val1.Value);
|
||||
|
||||
// Bar 2: Close=12, High=12, Low=8. Range=4.
|
||||
// MFM = ((12-8) - (12-12)) / 4 = (4 - 0) / 4 = 1.
|
||||
// Vol = 200. MFV = 200. ADL = 0 + 200 = 200.
|
||||
var bar2 = new TBar(time.AddMinutes(1), 10, 12, 8, 12, 200);
|
||||
var val2 = adl.Update(bar2);
|
||||
Assert.Equal(200, val2.Value);
|
||||
|
||||
// Bar 3: Close=8, High=12, Low=8. Range=4.
|
||||
// MFM = ((8-8) - (12-8)) / 4 = (0 - 4) / 4 = -1.
|
||||
// Vol = 100. MFV = -100. ADL = 200 - 100 = 100.
|
||||
var bar3 = new TBar(time.AddMinutes(2), 12, 12, 8, 8, 100);
|
||||
var val3 = adl.Update(bar3);
|
||||
Assert.Equal(100, val3.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_IsNew_False_UpdatesSameBar()
|
||||
{
|
||||
var adl = new Adl();
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Initial update
|
||||
// MFM = 1, Vol = 100 -> ADL = 100
|
||||
var bar1 = new TBar(time, 10, 12, 8, 12, 100);
|
||||
adl.Update(bar1, isNew: true);
|
||||
Assert.Equal(100, adl.Last.Value);
|
||||
|
||||
// Update same bar with different volume
|
||||
// MFM = 1, Vol = 200 -> ADL = 200 (replaces previous 100)
|
||||
var bar1Update = new TBar(time, 10, 12, 8, 12, 200);
|
||||
adl.Update(bar1Update, isNew: false);
|
||||
Assert.Equal(200, adl.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_Reset_ClearsState()
|
||||
{
|
||||
var adl = new Adl();
|
||||
var bar = new TBar(DateTime.UtcNow, 10, 12, 8, 12, 100);
|
||||
adl.Update(bar);
|
||||
|
||||
Assert.True(adl.IsHot);
|
||||
Assert.NotEqual(0, adl.Last.Value);
|
||||
|
||||
adl.Reset();
|
||||
Assert.False(adl.IsHot);
|
||||
Assert.Equal(0, adl.Last.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_HighEqualsLow_HandlesDivisionByZero()
|
||||
{
|
||||
var adl = new Adl();
|
||||
// High = Low = 10. Range = 0. MFM should be 0.
|
||||
var bar = new TBar(DateTime.UtcNow, 10, 10, 10, 10, 100);
|
||||
var val = adl.Update(bar);
|
||||
Assert.Equal(0, val.Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_TValueUpdate_ThrowsNotSupportedException()
|
||||
{
|
||||
var adl = new Adl();
|
||||
var bar = new TBar(DateTime.UtcNow, 10, 12, 8, 12, 100);
|
||||
adl.Update(bar); // ADL = 100
|
||||
|
||||
// Update with TValue should throw since ADL requires OHLCV bar data
|
||||
Assert.Throws<NotSupportedException>(() => adl.Update(new TValue(DateTime.UtcNow, 15)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_Name_IsCorrect()
|
||||
{
|
||||
Assert.Equal("ADL", Adl.Name);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_PubEvent_FiresOnUpdate()
|
||||
{
|
||||
var adl = new Adl();
|
||||
bool eventFired = false;
|
||||
adl.Pub += (object? sender, in TValueEventArgs args) => eventFired = true;
|
||||
|
||||
adl.Update(new TBar(DateTime.UtcNow, 10, 12, 8, 10, 100));
|
||||
Assert.True(eventFired);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_UpdateTBarSeries_ReturnsCorrectSeries()
|
||||
{
|
||||
var adl = new Adl();
|
||||
var bars = new TBarSeries();
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
// Add same bars as in BasicCalculation
|
||||
bars.Add(new TBar(time, 10, 12, 8, 10, 100)); // ADL=0
|
||||
bars.Add(new TBar(time.AddMinutes(1), 10, 12, 8, 12, 200)); // ADL=200
|
||||
bars.Add(new TBar(time.AddMinutes(2), 12, 12, 8, 8, 100)); // ADL=100
|
||||
|
||||
var result = adl.Update(bars);
|
||||
|
||||
Assert.Equal(3, result.Count);
|
||||
Assert.Equal(0, result[0].Value);
|
||||
Assert.Equal(200, result[1].Value);
|
||||
Assert.Equal(100, result[2].Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_CalculateTBarSeries_ReturnsCorrectSeries()
|
||||
{
|
||||
var bars = new TBarSeries();
|
||||
var time = DateTime.UtcNow;
|
||||
|
||||
bars.Add(new TBar(time, 10, 12, 8, 10, 100));
|
||||
bars.Add(new TBar(time.AddMinutes(1), 10, 12, 8, 12, 200));
|
||||
bars.Add(new TBar(time.AddMinutes(2), 12, 12, 8, 8, 100));
|
||||
|
||||
var result = Adl.Calculate(bars);
|
||||
|
||||
Assert.Equal(3, result.Count);
|
||||
Assert.Equal(0, result[0].Value);
|
||||
Assert.Equal(200, result[1].Value);
|
||||
Assert.Equal(100, result[2].Value);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_CalculateSpan_ReturnsCorrectValues()
|
||||
{
|
||||
double[] high = { 12, 12, 12 };
|
||||
double[] low = { 8, 8, 8 };
|
||||
double[] close = { 10, 12, 8 };
|
||||
double[] volume = { 100, 200, 100 };
|
||||
double[] output = new double[3];
|
||||
|
||||
Adl.Calculate(high, low, close, volume, output);
|
||||
|
||||
Assert.Equal(0, output[0]);
|
||||
Assert.Equal(200, output[1]);
|
||||
Assert.Equal(100, output[2]);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_CalculateSpan_ThrowsOnMismatchedLengths()
|
||||
{
|
||||
double[] high = { 10, 11 };
|
||||
double[] low = { 9, 10 };
|
||||
double[] close = { 9.5, 10.5 };
|
||||
double[] volume = { 100 }; // Short
|
||||
double[] output = new double[2];
|
||||
|
||||
Assert.Throws<ArgumentException>(() =>
|
||||
Adl.Calculate(high, low, close, volume, output));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_Calculate_EmptySeries_ReturnsEmpty()
|
||||
{
|
||||
var bars = new TBarSeries();
|
||||
var result = Adl.Calculate(bars);
|
||||
Assert.Empty(result);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_CalculateSpan_SimdPath_ReturnsCorrectValues()
|
||||
{
|
||||
const int count = 100; // Enough to trigger SIMD
|
||||
double[] high = new double[count];
|
||||
double[] low = new double[count];
|
||||
double[] close = new double[count];
|
||||
double[] volume = new double[count];
|
||||
double[] output = new double[count];
|
||||
|
||||
// Setup: High=12, Low=8, Close=12 (MFM=1), Vol=10
|
||||
// Expected ADL increments by 10 each step.
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
high[i] = 12;
|
||||
low[i] = 8;
|
||||
close[i] = 12;
|
||||
volume[i] = 10;
|
||||
}
|
||||
|
||||
Adl.Calculate(high, low, close, volume, output);
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
Assert.Equal((i + 1) * 10, output[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
using Skender.Stock.Indicators;
|
||||
using OoplesFinance.StockIndicators;
|
||||
using OoplesFinance.StockIndicators.Models;
|
||||
|
||||
namespace QuanTAlib.Tests;
|
||||
|
||||
public class AdlValidationTests
|
||||
{
|
||||
private readonly ValidationTestData _data;
|
||||
|
||||
public AdlValidationTests()
|
||||
{
|
||||
_data = new ValidationTestData();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_Matches_Skender()
|
||||
{
|
||||
// Skender
|
||||
var skenderResults = _data.SkenderQuotes.GetAdl();
|
||||
var skenderValues = skenderResults.Select(x => x.Adl).ToArray();
|
||||
|
||||
// QuanTAlib
|
||||
var adl = new Adl();
|
||||
var quantalibValues = new List<double>();
|
||||
foreach (var bar in _data.Bars)
|
||||
{
|
||||
quantalibValues.Add(adl.Update(bar).Value);
|
||||
}
|
||||
|
||||
ValidationHelper.VerifyData(quantalibValues.ToArray(), skenderValues, 0, 100, ValidationHelper.SkenderTolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_Matches_Talib()
|
||||
{
|
||||
// TA-Lib
|
||||
var high = _data.Bars.High.Values.ToArray();
|
||||
var low = _data.Bars.Low.Values.ToArray();
|
||||
var close = _data.Bars.Close.Values.ToArray();
|
||||
var volume = _data.Bars.Volume.Values.ToArray();
|
||||
var talibValues = new double[high.Length];
|
||||
|
||||
var retCode = TALib.Functions.Ad(high, low, close, volume, 0..^0, talibValues, out var outRange);
|
||||
Assert.Equal(TALib.Core.RetCode.Success, retCode);
|
||||
|
||||
// QuanTAlib
|
||||
var adl = new Adl();
|
||||
var quantalibValues = new List<double>();
|
||||
foreach (var bar in _data.Bars)
|
||||
{
|
||||
quantalibValues.Add(adl.Update(bar).Value);
|
||||
}
|
||||
|
||||
ValidationHelper.VerifyData(quantalibValues.ToArray(), talibValues, outRange, 0, 100, ValidationHelper.TalibTolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_Matches_Tulip()
|
||||
{
|
||||
// Tulip
|
||||
var high = _data.Bars.High.Values.ToArray();
|
||||
var low = _data.Bars.Low.Values.ToArray();
|
||||
var close = _data.Bars.Close.Values.ToArray();
|
||||
var volume = _data.Bars.Volume.Values.ToArray();
|
||||
|
||||
var tulipIndicator = Tulip.Indicators.ad;
|
||||
double[][] inputs = { high, low, close, volume };
|
||||
double[] options = Array.Empty<double>();
|
||||
double[][] outputs = { new double[high.Length] };
|
||||
|
||||
tulipIndicator.Run(inputs, options, outputs);
|
||||
var tulipValues = outputs[0];
|
||||
|
||||
// QuanTAlib
|
||||
var adl = new Adl();
|
||||
var quantalibValues = new List<double>();
|
||||
foreach (var bar in _data.Bars)
|
||||
{
|
||||
quantalibValues.Add(adl.Update(bar).Value);
|
||||
}
|
||||
|
||||
ValidationHelper.VerifyData(quantalibValues.ToArray(), tulipValues, 0, 100, ValidationHelper.TulipTolerance);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Adl_Matches_Ooples()
|
||||
{
|
||||
// Ooples
|
||||
var ooplesData = _data.SkenderQuotes.Select(q => new TickerData
|
||||
{
|
||||
Date = q.Date,
|
||||
Open = (double)q.Open,
|
||||
High = (double)q.High,
|
||||
Low = (double)q.Low,
|
||||
Close = (double)q.Close,
|
||||
Volume = (double)q.Volume
|
||||
}).ToList();
|
||||
|
||||
var stockData = new StockData(ooplesData);
|
||||
var oResult = stockData.CalculateAccumulationDistributionLine();
|
||||
var oValues = oResult.OutputValues["Adl"];
|
||||
|
||||
// QuanTAlib
|
||||
var adl = new Adl();
|
||||
var quantalibValues = new List<double>();
|
||||
foreach (var bar in _data.Bars)
|
||||
{
|
||||
quantalibValues.Add(adl.Update(bar).Value);
|
||||
}
|
||||
|
||||
ValidationHelper.VerifyData(quantalibValues.ToArray(), oValues.ToArray(), 0, 100, ValidationHelper.OoplesTolerance);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,199 @@
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Numerics;
|
||||
|
||||
namespace QuanTAlib;
|
||||
|
||||
/// <summary>
|
||||
/// ADL: Accumulation/Distribution Line
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// The Accumulation/Distribution Line is a cumulative indicator that uses volume and price
|
||||
/// to assess whether a stock is being accumulated or distributed.
|
||||
///
|
||||
/// Calculation:
|
||||
/// 1. Money Flow Multiplier = [(Close - Low) - (High - Close)] / (High - Low)
|
||||
/// 2. Money Flow Volume = Money Flow Multiplier * Volume
|
||||
/// 3. ADL = Previous ADL + Money Flow Volume
|
||||
///
|
||||
/// If High equals Low, the Multiplier is 0.
|
||||
///
|
||||
/// Sources:
|
||||
/// https://www.investopedia.com/terms/a/accumulationdistribution.asp
|
||||
/// https://school.stockcharts.com/doku.php?id=technical_indicators:accumulation_distribution_line
|
||||
/// </remarks>
|
||||
[SkipLocalsInit]
|
||||
public sealed class Adl : ITValuePublisher
|
||||
{
|
||||
private double _adl;
|
||||
private double _p_adl;
|
||||
private bool _isInitialized;
|
||||
|
||||
/// <summary>
|
||||
/// Display name for the indicator.
|
||||
/// </summary>
|
||||
public static string Name => "ADL";
|
||||
|
||||
public event TValuePublishedHandler? Pub;
|
||||
|
||||
/// <summary>
|
||||
/// Current ADL value.
|
||||
/// </summary>
|
||||
public TValue Last { get; private set; }
|
||||
|
||||
/// <summary>
|
||||
/// True if the indicator has processed at least one bar.
|
||||
/// </summary>
|
||||
public bool IsHot => _isInitialized;
|
||||
|
||||
/// <summary>
|
||||
/// Creates a new ADL indicator.
|
||||
/// </summary>
|
||||
public Adl()
|
||||
{
|
||||
_isInitialized = false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resets the indicator state.
|
||||
/// </summary>
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public void Reset()
|
||||
{
|
||||
_adl = 0;
|
||||
_p_adl = 0;
|
||||
_isInitialized = false;
|
||||
Last = default;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public TValue Update(TBar input, bool isNew = true)
|
||||
{
|
||||
if (isNew)
|
||||
{
|
||||
_p_adl = _adl;
|
||||
}
|
||||
else
|
||||
{
|
||||
_adl = _p_adl;
|
||||
}
|
||||
|
||||
double highLowRange = input.High - input.Low;
|
||||
double mfm = 0;
|
||||
|
||||
if (highLowRange > double.Epsilon)
|
||||
{
|
||||
mfm = (input.Close - input.Low - (input.High - input.Close)) / highLowRange;
|
||||
}
|
||||
|
||||
double mfv = mfm * input.Volume;
|
||||
_adl += mfv;
|
||||
|
||||
_isInitialized = true;
|
||||
Last = new TValue(input.Time, _adl);
|
||||
Pub?.Invoke(this, new TValueEventArgs { Value = Last, IsNew = isNew });
|
||||
return Last;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Updates ADL with a TValue input.
|
||||
/// </summary>
|
||||
/// <exception cref="NotSupportedException">
|
||||
/// ADL requires OHLCV bar data to calculate the Money Flow Multiplier and Volume.
|
||||
/// Use Update(TBar) instead.
|
||||
/// </exception>
|
||||
#pragma warning disable S2325 // Method signature must match ITValuePublisher contract
|
||||
public TValue Update(TValue input, bool isNew = true)
|
||||
#pragma warning restore S2325
|
||||
{
|
||||
throw new NotSupportedException(
|
||||
"ADL requires OHLCV bar data to calculate the Money Flow Multiplier and Volume. " +
|
||||
"Use Update(TBar) instead.");
|
||||
}
|
||||
|
||||
public TSeries Update(TBarSeries source)
|
||||
{
|
||||
var t = new List<long>(source.Count);
|
||||
var v = new List<double>(source.Count);
|
||||
|
||||
Reset();
|
||||
|
||||
for (int i = 0; i < source.Count; i++)
|
||||
{
|
||||
var val = Update(source[i], isNew: true);
|
||||
t.Add(val.Time);
|
||||
v.Add(val.Value);
|
||||
}
|
||||
|
||||
return new TSeries(t, v);
|
||||
}
|
||||
|
||||
public static TSeries Calculate(TBarSeries source)
|
||||
{
|
||||
if (source.Count == 0) return [];
|
||||
|
||||
var t = source.Open.Times.ToArray(); // Times are same for all series
|
||||
var v = new double[source.Count];
|
||||
|
||||
Calculate(source.High.Values, source.Low.Values, source.Close.Values, source.Volume.Values, v);
|
||||
|
||||
return new TSeries(t, v);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public static void Calculate(ReadOnlySpan<double> high, ReadOnlySpan<double> low, ReadOnlySpan<double> close, ReadOnlySpan<double> volume, Span<double> output)
|
||||
{
|
||||
if (high.Length != low.Length || high.Length != close.Length || high.Length != volume.Length || high.Length != output.Length)
|
||||
throw new ArgumentException("All spans must be of the same length", nameof(output));
|
||||
|
||||
int len = high.Length;
|
||||
int i = 0;
|
||||
|
||||
if (Vector.IsHardwareAccelerated && len >= Vector<double>.Count)
|
||||
{
|
||||
int vectorSize = Vector<double>.Count;
|
||||
var epsilon = new Vector<double>(double.Epsilon);
|
||||
|
||||
for (; i <= len - vectorSize; i += vectorSize)
|
||||
{
|
||||
var h = new Vector<double>(high.Slice(i, vectorSize));
|
||||
var l = new Vector<double>(low.Slice(i, vectorSize));
|
||||
var c = new Vector<double>(close.Slice(i, vectorSize));
|
||||
var vol = new Vector<double>(volume.Slice(i, vectorSize));
|
||||
|
||||
var hl = h - l;
|
||||
var num = c - l - (h - c);
|
||||
|
||||
var mask = Vector.GreaterThan(hl, epsilon);
|
||||
var safeHl = Vector.ConditionalSelect(mask, hl, Vector<double>.One);
|
||||
var mfm = num / safeHl;
|
||||
mfm = Vector.ConditionalSelect(mask, mfm, Vector<double>.Zero);
|
||||
|
||||
var mfv = mfm * vol;
|
||||
mfv.CopyTo(output.Slice(i, vectorSize));
|
||||
}
|
||||
}
|
||||
|
||||
for (; i < len; i++)
|
||||
{
|
||||
double h = high[i];
|
||||
double l = low[i];
|
||||
double c = close[i];
|
||||
double vol = volume[i];
|
||||
|
||||
double hl = h - l;
|
||||
double mfm = 0;
|
||||
if (hl > double.Epsilon)
|
||||
{
|
||||
mfm = (c - l - (h - c)) / hl;
|
||||
}
|
||||
output[i] = mfm * vol;
|
||||
}
|
||||
|
||||
double sum = 0;
|
||||
for (i = 0; i < len; i++)
|
||||
{
|
||||
sum += output[i];
|
||||
output[i] = sum;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
# ADL: Accumulation/Distribution Line
|
||||
|
||||
> "Volume precedes price." — Old Wall Street Adage
|
||||
|
||||
The Accumulation/Distribution Line (ADL) is the bedrock of volume analysis. It attempts to answer a single, vital question: "Are the big players buying or selling?"
|
||||
|
||||
Unlike On-Balance Volume (OBV), which treats every up-day as 100% buying, ADL is nuanced. It looks at *where* the price closed within the day's range. A close near the high on massive volume screams "Accumulation." A close near the low on massive volume screams "Distribution."
|
||||
|
||||
## Historical Context
|
||||
|
||||
Developed by Marc Chaikin, the ADL was originally designed to spot divergences. Chaikin noticed that if a stock made a new high but the ADL failed to make a new high, a crash was imminent. He essentially quantified the "smart money" flow.
|
||||
|
||||
## Architecture & Physics
|
||||
|
||||
ADL is a cumulative indicator, meaning it has infinite memory. Today's value depends on the sum of all yesterdays.
|
||||
|
||||
The core mechanic is the **Money Flow Multiplier (MFM)**, also known as the Close Location Value (CLV). This value ranges from -1 to +1:
|
||||
|
||||
* **+1**: Close = High (Maximum Accumulation)
|
||||
* **-1**: Close = Low (Maximum Distribution)
|
||||
* **0**: Close is exactly in the middle
|
||||
|
||||
This multiplier is then applied to the volume to determine the "Money Flow Volume" for the period.
|
||||
|
||||
## Mathematical Foundation
|
||||
|
||||
### 1. Money Flow Multiplier (MFM)
|
||||
|
||||
$$
|
||||
MFM = \frac{(Close - Low) - (High - Close)}{High - Low}
|
||||
$$
|
||||
|
||||
### 2. Money Flow Volume (MFV)
|
||||
|
||||
$$
|
||||
MFV = MFM \times Volume
|
||||
$$
|
||||
|
||||
### 3. Accumulation/Distribution Line (ADL)
|
||||
|
||||
$$
|
||||
ADL_t = ADL_{t-1} + MFV_t
|
||||
$$
|
||||
|
||||
## Performance Profile
|
||||
|
||||
| Metric | Score | Notes |
|
||||
| :--- | :--- | :--- |
|
||||
| **Throughput** | 10 | High; O(1) calculation with simple arithmetic. |
|
||||
| **Allocations** | 0 | Zero-allocation in hot paths. |
|
||||
| **Complexity** | O(1) | Constant time per update. |
|
||||
| **Accuracy** | 10 | Matches all standard libraries exactly. |
|
||||
| **Timeliness** | 10 | No lag; updates immediately with each bar. |
|
||||
| **Overshoot** | N/A | Cumulative indicator; concept doesn't apply. |
|
||||
| **Smoothness** | 2 | Jagged; reflects raw volume and price location. |
|
||||
|
||||
## Validation
|
||||
|
||||
| Library | Status | Notes |
|
||||
| :--- | :--- | :--- |
|
||||
| **QuanTAlib** | ✅ | Validated. |
|
||||
| **TA-Lib** | ✅ | Matches `TA_AD` exactly. |
|
||||
| **Skender** | ✅ | Matches `GetAdl` exactly. |
|
||||
| **Tulip** | ✅ | Matches `ad` exactly. |
|
||||
| **Ooples** | ✅ | Matches `CalculateAccumulationDistributionLine`. |
|
||||
|
||||
### Common Pitfalls
|
||||
|
||||
* **Gaps**: ADL ignores gaps. If a stock gaps up but closes near its low, ADL will register distribution, even if the price is higher than yesterday.
|
||||
* **Scale**: The absolute value of ADL is meaningless; it depends on the start date of the data. Only the *trend* and *divergence* matter.
|
||||
* **Volume Spikes**: A single bad data point with erroneous volume can permanently skew the ADL. Sanitize your data.
|
||||
Reference in New Issue
Block a user