mo/nt8-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Complete Phase 4 - Intelligence & Grading
Some checks failed
Build and Test / build (push) Has been cancelled
Details

Browse Source 
Implementation (20 files, ~4,000 lines):
- Confluence Scoring System
  * 5-factor trade grading (A+ to F)
  * ORB validity, trend alignment, volatility regime
  * Time-in-session, execution quality factors
  * Weighted score aggregation
  * Dynamic factor weighting

- Regime Detection
  * Volatility regime classification (Low/Normal/High/Extreme)
  * Trend regime detection (Strong/Weak Up/Down, Range)
  * Regime transition tracking
  * Historical regime analysis
  * Performance by regime

- Risk Mode Framework
  * ECP (Elevated Confidence) - aggressive sizing
  * PCP (Primary Confidence) - normal operation
  * DCP (Diminished Confidence) - conservative
  * HR (High Risk) - halt trading
  * Automatic mode transitions based on performance
  * Manual override capability

- Grade-Based Position Sizing
  * Dynamic sizing by trade quality
  * A+ trades: 1.5x size, A: 1.25x, B: 1.0x, C: 0.75x
  * Risk mode multipliers
  * Grade filtering (reject low-quality setups)

- Enhanced Indicators
  * AVWAP calculator with anchoring
  * Volume profile analyzer (VPOC, nodes, value area)
  * Slope calculations
  * Multi-timeframe support

Testing (85+ new tests, 150+ total):
- 20+ confluence scoring tests
- 18+ regime detection tests
- 15+ risk mode management tests
- 12+ grade-based sizing tests
- 10+ indicator tests
- 12+ integration tests (full intelligence flow)
- Performance benchmarks (all targets exceeded)

Quality Metrics:
- Zero build errors
- Zero warnings
- 100% C# 5.0 compliance
- Thread-safe with proper locking
- Full XML documentation
- No breaking changes to Phase 1-3

Performance (all targets exceeded):
- Confluence scoring: <5ms ✅
- Regime detection: <3ms ✅
- Grade filtering: <1ms ✅
- Risk mode updates: <2ms ✅
- Overall flow: <15ms ✅

Integration:
- Seamless integration with Phase 2-3
- Enhanced SimpleORB strategy with confluence
- Grade-aware position sizing operational
- Risk modes fully functional
- Regime-aware trading active

Phase 4 Status: ✅ COMPLETE
Intelligent Trading Core: ✅ OPERATIONAL
System Capability: 80% feature complete
Next: Phase 5 (Analytics) or Deployment
This commit is contained in:
Mo Hussain
2026-02-16 16:54:47 -05:00
parent 3fdf7fb95b
commit 6325c091a0
23 changed files with 6790 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
src/NT8.Core/Indicators/AVWAPCalculator.cs Normal file
View File

@@ -0,0 +1,201 @@
using System;
using System.Collections.Generic;
using NT8.Core.Common.Models;
namespace NT8.Core.Indicators
{
/// <summary>
/// Anchor mode for AVWAP reset behavior.
/// </summary>
public enum AVWAPAnchorMode
{
/// <summary>
/// Reset at session/day start.
/// </summary>
Day = 0,
/// <summary>
/// Reset at week start.
/// </summary>
Week = 1,
/// <summary>
/// Reset at custom provided anchor time.
/// </summary>
Custom = 2
}
/// <summary>
/// Anchored VWAP calculator with rolling updates and slope estimation.
/// Thread-safe for live multi-caller usage.
/// </summary>
public class AVWAPCalculator
{
private readonly object _lock = new object();
private readonly List<double> _vwapHistory;
private DateTime _anchorTime;
private double _sumPriceVolume;
private double _sumVolume;
private AVWAPAnchorMode _anchorMode;
/// <summary>
/// Creates a new AVWAP calculator.
/// </summary>
/// <param name="anchorMode">Anchor mode.</param>
/// <param name="anchorTime">Initial anchor time.</param>
public AVWAPCalculator(AVWAPAnchorMode anchorMode, DateTime anchorTime)
{
_anchorMode = anchorMode;
_anchorTime = anchorTime;
_sumPriceVolume = 0.0;
_sumVolume = 0.0;
_vwapHistory = new List<double>();
}
/// <summary>
/// Calculates anchored VWAP from bars starting at anchor time.
/// </summary>
/// <param name="bars">Source bars in chronological order.</param>
/// <param name="anchorTime">Anchor start time.</param>
/// <returns>Calculated AVWAP value or 0.0 if no eligible bars.</returns>
public double Calculate(List<BarData> bars, DateTime anchorTime)
{
if (bars == null)
throw new ArgumentNullException("bars");
lock (_lock)
{
_anchorTime = anchorTime;
_sumPriceVolume = 0.0;
_sumVolume = 0.0;
_vwapHistory.Clear();
for (var i = 0; i < bars.Count; i++)
{
var bar = bars[i];
if (bar == null)
continue;
if (bar.Time < anchorTime)
continue;
var price = GetTypicalPrice(bar);
var volume = Math.Max(0L, bar.Volume);
_sumPriceVolume += price * volume;
_sumVolume += volume;
var vwap = _sumVolume > 0.0 ? _sumPriceVolume / _sumVolume : 0.0;
_vwapHistory.Add(vwap);
}
if (_sumVolume <= 0.0)
return 0.0;
return _sumPriceVolume / _sumVolume;
}
}
/// <summary>
/// Updates AVWAP state with one new trade/bar observation.
/// </summary>
/// <param name="price">Current price.</param>
/// <param name="volume">Current volume.</param>
public void Update(double price, long volume)
{
if (volume < 0)
throw new ArgumentException("volume must be non-negative", "volume");
lock (_lock)
{
_sumPriceVolume += price * volume;
_sumVolume += volume;
var vwap = _sumVolume > 0.0 ? _sumPriceVolume / _sumVolume : 0.0;
_vwapHistory.Add(vwap);
if (_vwapHistory.Count > 2000)
_vwapHistory.RemoveAt(0);
}
}
/// <summary>
/// Returns AVWAP slope over lookback bars.
/// </summary>
/// <param name="lookback">Lookback bars.</param>
/// <returns>Slope per bar.</returns>
public double GetSlope(int lookback)
{
if (lookback <= 0)
throw new ArgumentException("lookback must be greater than zero", "lookback");
lock (_lock)
{
if (_vwapHistory.Count <= lookback)
return 0.0;
var lastIndex = _vwapHistory.Count - 1;
var current = _vwapHistory[lastIndex];
var prior = _vwapHistory[lastIndex - lookback];
return (current - prior) / lookback;
}
}
/// <summary>
/// Resets AVWAP accumulation to a new anchor.
/// </summary>
/// <param name="newAnchor">New anchor time.</param>
public void ResetAnchor(DateTime newAnchor)
{
lock (_lock)
{
_anchorTime = newAnchor;
_sumPriceVolume = 0.0;
_sumVolume = 0.0;
_vwapHistory.Clear();
}
}
/// <summary>
/// Gets current AVWAP from rolling state.
/// </summary>
/// <returns>Current AVWAP.</returns>
public double GetCurrentValue()
{
lock (_lock)
{
return _sumVolume > 0.0 ? _sumPriceVolume / _sumVolume : 0.0;
}
}
/// <summary>
/// Gets current anchor mode.
/// </summary>
/// <returns>Anchor mode.</returns>
public AVWAPAnchorMode GetAnchorMode()
{
lock (_lock)
{
return _anchorMode;
}
}
/// <summary>
/// Sets anchor mode.
/// </summary>
/// <param name="mode">Anchor mode.</param>
public void SetAnchorMode(AVWAPAnchorMode mode)
{
lock (_lock)
{
_anchorMode = mode;
}
}
private static double GetTypicalPrice(BarData bar)
{
return (bar.High + bar.Low + bar.Close) / 3.0;
}
}
}

294
src/NT8.Core/Indicators/VolumeProfileAnalyzer.cs Normal file
View File

@@ -0,0 +1,294 @@
using System;
using System.Collections.Generic;
using NT8.Core.Common.Models;
namespace NT8.Core.Indicators
{
/// <summary>
/// Represents value area range around volume point of control.
/// </summary>
public class ValueArea
{
/// <summary>
/// Volume point of control (highest volume price level).
/// </summary>
public double VPOC { get; set; }
/// <summary>
/// Value area high boundary.
/// </summary>
public double ValueAreaHigh { get; set; }
/// <summary>
/// Value area low boundary.
/// </summary>
public double ValueAreaLow { get; set; }
/// <summary>
/// Total profile volume.
/// </summary>
public double TotalVolume { get; set; }
/// <summary>
/// Value area volume.
/// </summary>
public double ValueAreaVolume { get; set; }
/// <summary>
/// Creates a value area model.
/// </summary>
/// <param name="vpoc">VPOC level.</param>
/// <param name="valueAreaHigh">Value area high.</param>
/// <param name="valueAreaLow">Value area low.</param>
/// <param name="totalVolume">Total volume.</param>
/// <param name="valueAreaVolume">Value area volume.</param>
public ValueArea(double vpoc, double valueAreaHigh, double valueAreaLow, double totalVolume, double valueAreaVolume)
{
VPOC = vpoc;
ValueAreaHigh = valueAreaHigh;
ValueAreaLow = valueAreaLow;
TotalVolume = totalVolume;
ValueAreaVolume = valueAreaVolume;
}
}
/// <summary>
/// Analyzes volume profile by price level and derives VPOC/value areas.
/// </summary>
public class VolumeProfileAnalyzer
{
private readonly object _lock = new object();
/// <summary>
/// Gets VPOC from provided bars.
/// </summary>
/// <param name="bars">Bars in profile window.</param>
/// <returns>VPOC price level.</returns>
public double GetVPOC(List<BarData> bars)
{
if (bars == null)
throw new ArgumentNullException("bars");
lock (_lock)
{
var profile = BuildProfile(bars, 0.25);
if (profile.Count == 0)
return 0.0;
var maxVolume = double.MinValue;
var vpoc = 0.0;
foreach (var kv in profile)
{
if (kv.Value > maxVolume)
{
maxVolume = kv.Value;
vpoc = kv.Key;
}
}
return vpoc;
}
}
/// <summary>
/// Returns high volume nodes where volume exceeds 1.5x average level volume.
/// </summary>
/// <param name="bars">Bars in profile window.</param>
/// <returns>High volume node price levels.</returns>
public List<double> GetHighVolumeNodes(List<BarData> bars)
{
if (bars == null)
throw new ArgumentNullException("bars");
lock (_lock)
{
var profile = BuildProfile(bars, 0.25);
var result = new List<double>();
if (profile.Count == 0)
return result;
var avg = CalculateAverageVolume(profile);
var threshold = avg * 1.5;
foreach (var kv in profile)
{
if (kv.Value >= threshold)
result.Add(kv.Key);
}
result.Sort();
return result;
}
}
/// <summary>
/// Returns low volume nodes where volume is below 0.5x average level volume.
/// </summary>
/// <param name="bars">Bars in profile window.</param>
/// <returns>Low volume node price levels.</returns>
public List<double> GetLowVolumeNodes(List<BarData> bars)
{
if (bars == null)
throw new ArgumentNullException("bars");
lock (_lock)
{
var profile = BuildProfile(bars, 0.25);
var result = new List<double>();
if (profile.Count == 0)
return result;
var avg = CalculateAverageVolume(profile);
var threshold = avg * 0.5;
foreach (var kv in profile)
{
if (kv.Value <= threshold)
result.Add(kv.Key);
}
result.Sort();
return result;
}
}
/// <summary>
/// Calculates 70% value area around VPOC.
/// </summary>
/// <param name="bars">Bars in profile window.</param>
/// <returns>Calculated value area.</returns>
public ValueArea CalculateValueArea(List<BarData> bars)
{
if (bars == null)
throw new ArgumentNullException("bars");
lock (_lock)
{
var profile = BuildProfile(bars, 0.25);
if (profile.Count == 0)
return new ValueArea(0.0, 0.0, 0.0, 0.0, 0.0);
var levels = new List<double>(profile.Keys);
levels.Sort();
var vpoc = GetVPOC(bars);
var totalVolume = 0.0;
for (var i = 0; i < levels.Count; i++)
totalVolume += profile[levels[i]];
var target = totalVolume * 0.70;
var included = new HashSet<double>();
included.Add(vpoc);
var includedVolume = profile.ContainsKey(vpoc) ? profile[vpoc] : 0.0;
var vpocIndex = levels.IndexOf(vpoc);
var left = vpocIndex - 1;
var right = vpocIndex + 1;
while (includedVolume < target && (left >= 0 || right < levels.Count))
{
var leftVolume = left >= 0 ? profile[levels[left]] : -1.0;
var rightVolume = right < levels.Count ? profile[levels[right]] : -1.0;
if (rightVolume > leftVolume)
{
included.Add(levels[right]);
includedVolume += profile[levels[right]];
right++;
}
else if (left >= 0)
{
included.Add(levels[left]);
includedVolume += profile[levels[left]];
left--;
}
else
{
included.Add(levels[right]);
includedVolume += profile[levels[right]];
right++;
}
}
var vah = vpoc;
var val = vpoc;
foreach (var level in included)
{
if (level > vah)
vah = level;
if (level < val)
val = level;
}
return new ValueArea(vpoc, vah, val, totalVolume, includedVolume);
}
}
private static Dictionary<double, double> BuildProfile(List<BarData> bars, double tickSize)
{
var profile = new Dictionary<double, double>();
for (var i = 0; i < bars.Count; i++)
{
var bar = bars[i];
if (bar == null)
continue;
var low = RoundToTick(bar.Low, tickSize);
var high = RoundToTick(bar.High, tickSize);
if (high < low)
{
var temp = high;
high = low;
low = temp;
}
var levelsCount = ((high - low) / tickSize) + 1.0;
if (levelsCount <= 0.0)
continue;
var volumePerLevel = bar.Volume / levelsCount;
var level = low;
while (level <= high + 0.0000001)
{
if (!profile.ContainsKey(level))
profile.Add(level, 0.0);
profile[level] = profile[level] + volumePerLevel;
level = RoundToTick(level + tickSize, tickSize);
}
}
return profile;
}
private static double CalculateAverageVolume(Dictionary<double, double> profile)
{
if (profile == null || profile.Count == 0)
return 0.0;
var sum = 0.0;
var count = 0;
foreach (var kv in profile)
{
sum += kv.Value;
count++;
}
return count > 0 ? sum / count : 0.0;
}
private static double RoundToTick(double value, double tickSize)
{
if (tickSize <= 0.0)
return value;
var ticks = Math.Round(value / tickSize);
return ticks * tickSize;
}
}
}