Compare commits
3 Commits
6325c091a0
...
0e36fe5d23
| Author | SHA1 | Date | |
|---|---|---|---|
| 0e36fe5d23 | |||
| e93cbc1619 | |||
| 79dcb1890c |
392
NEXT_STEPS_RECOMMENDED.md
Normal file
392
NEXT_STEPS_RECOMMENDED.md
Normal file
@@ -0,0 +1,392 @@
|
|||||||
|
# NT8 SDK - Recommended Next Steps
|
||||||
|
|
||||||
|
**Date:** February 17, 2026
|
||||||
|
**Current Status:** Phase 5 Complete (85% Project Completion)
|
||||||
|
**Last Update:** Phase 5 Analytics & Reporting delivered with 240+ passing tests
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🎯 Strategic Decision Points
|
||||||
|
|
||||||
|
You have **three primary paths** forward, each with different objectives and timelines:
|
||||||
|
|
||||||
|
### Path 1: Production Hardening (Recommended First) ⭐
|
||||||
|
**Goal:** Make the system production-ready for live trading
|
||||||
|
**Timeline:** 2-3 weeks
|
||||||
|
**Risk Level:** Low (infrastructure improvements)
|
||||||
|
**Value:** Enables safe deployment to live markets
|
||||||
|
|
||||||
|
### Path 2: Golden Strategy Implementation
|
||||||
|
**Goal:** Build reference strategy demonstrating all capabilities
|
||||||
|
**Timeline:** 1 week
|
||||||
|
**Risk Level:** Medium (requires market knowledge)
|
||||||
|
**Value:** Validates entire system, provides template for future strategies
|
||||||
|
|
||||||
|
### Path 3: Advanced Features
|
||||||
|
**Goal:** Add sophisticated institutional capabilities
|
||||||
|
**Timeline:** 2-4 weeks per major feature
|
||||||
|
**Risk Level:** High (complex new functionality)
|
||||||
|
**Value:** Competitive differentiation
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📋 Path 1: Production Hardening (RECOMMENDED)
|
||||||
|
|
||||||
|
### Why This Path?
|
||||||
|
- **Safety First:** Ensures robust error handling before live trading
|
||||||
|
- **Operational Excellence:** Proper monitoring prevents costly surprises
|
||||||
|
- **Confidence Building:** Comprehensive testing validates all 20,000 lines of code
|
||||||
|
- **Professional Standard:** Matches institutional-grade infrastructure expectations
|
||||||
|
|
||||||
|
### Detailed Task Breakdown
|
||||||
|
|
||||||
|
#### 1.1 CI/CD Pipeline Implementation
|
||||||
|
**Priority:** CRITICAL
|
||||||
|
**Time Estimate:** 3-5 days
|
||||||
|
|
||||||
|
**Tasks:**
|
||||||
|
- [ ] GitHub Actions or GitLab CI configuration
|
||||||
|
- [ ] Automated build on every commit
|
||||||
|
- [ ] Automated test execution (all 240+ tests)
|
||||||
|
- [ ] Code coverage reporting with trend tracking
|
||||||
|
- [ ] Automated deployment to NT8 Custom directory
|
||||||
|
- [ ] Build artifact archiving for rollback capability
|
||||||
|
- [ ] Notification system for build failures
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- `.github/workflows/build-test.yml` or equivalent
|
||||||
|
- Coverage reports visible in CI dashboard
|
||||||
|
- Automated deployment script
|
||||||
|
- Build status badges for README
|
||||||
|
|
||||||
|
**Success Criteria:**
|
||||||
|
- Zero manual steps from commit to NT8 deployment
|
||||||
|
- All tests run automatically on every commit
|
||||||
|
- Code coverage visible and tracked over time
|
||||||
|
- Failed builds block deployment
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
#### 1.2 Enhanced Integration Testing
|
||||||
|
**Priority:** HIGH
|
||||||
|
**Time Estimate:** 4-6 days
|
||||||
|
|
||||||
|
**Tasks:**
|
||||||
|
- [ ] End-to-end workflow tests (signal → risk → sizing → OMS → execution)
|
||||||
|
- [ ] Multi-component integration scenarios
|
||||||
|
- [ ] Performance benchmarking suite (measure <200ms latency target)
|
||||||
|
- [ ] Stress testing under load (100+ orders/second)
|
||||||
|
- [ ] Market data replay testing with historical tick data
|
||||||
|
- [ ] Partial fill handling validation
|
||||||
|
- [ ] Network failure simulation tests
|
||||||
|
- [ ] Risk limit breach scenario testing
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- `tests/NT8.Integration.Tests/EndToEndWorkflowTests.cs`
|
||||||
|
- `tests/NT8.Performance.Tests/LatencyBenchmarks.cs`
|
||||||
|
- `tests/NT8.Integration.Tests/StressTests.cs`
|
||||||
|
- Performance baseline documentation
|
||||||
|
- Load testing reports
|
||||||
|
|
||||||
|
**Success Criteria:**
|
||||||
|
- Complete trade flow executes in <200ms (measured)
|
||||||
|
- System handles 100+ orders/second without degradation
|
||||||
|
- All risk controls trigger correctly under stress
|
||||||
|
- Network failures handled gracefully
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
#### 1.3 Monitoring & Observability
|
||||||
|
**Priority:** HIGH
|
||||||
|
**Time Estimate:** 3-4 days
|
||||||
|
|
||||||
|
**Tasks:**
|
||||||
|
- [ ] Structured logging enhancements with correlation IDs
|
||||||
|
- [ ] Health check endpoint implementation
|
||||||
|
- [ ] Performance metrics collection (latency, throughput, memory)
|
||||||
|
- [ ] Risk breach alert system (email/SMS/webhook)
|
||||||
|
- [ ] Order execution tracking dashboard
|
||||||
|
- [ ] Daily P&L summary reports
|
||||||
|
- [ ] System health monitoring (CPU, memory, thread count)
|
||||||
|
- [ ] Trade execution audit log
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Enhanced `BasicLogger` with structured output
|
||||||
|
- `HealthCheckMonitor.cs` component
|
||||||
|
- `MetricsCollector.cs` for performance tracking
|
||||||
|
- `AlertManager.cs` for risk notifications
|
||||||
|
- Monitoring dashboard design/implementation
|
||||||
|
|
||||||
|
**Success Criteria:**
|
||||||
|
- Every trade has correlation ID for full audit trail
|
||||||
|
- Health checks detect component failures within 1 second
|
||||||
|
- Risk breaches trigger alerts within 5 seconds
|
||||||
|
- Daily reports generated automatically
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
#### 1.4 Configuration Management
|
||||||
|
**Priority:** MEDIUM
|
||||||
|
**Time Estimate:** 2-3 days
|
||||||
|
|
||||||
|
**Tasks:**
|
||||||
|
- [ ] JSON-based configuration system
|
||||||
|
- [ ] Environment-specific configs (dev/sim/prod)
|
||||||
|
- [ ] Runtime parameter validation
|
||||||
|
- [ ] Configuration hot-reload capability (non-risk parameters only)
|
||||||
|
- [ ] Configuration schema documentation
|
||||||
|
- [ ] Default configuration templates
|
||||||
|
- [ ] Configuration migration tools
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- `ConfigurationManager.cs` (complete implementation)
|
||||||
|
- `config/dev.json`, `config/sim.json`, `config/prod.json`
|
||||||
|
- `ConfigurationSchema.md` documentation
|
||||||
|
- Configuration validation unit tests
|
||||||
|
|
||||||
|
**Success Criteria:**
|
||||||
|
- All hardcoded values moved to configuration files
|
||||||
|
- Invalid configurations rejected at startup
|
||||||
|
- Environment switching requires zero code changes
|
||||||
|
- Configuration changes logged for audit
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
#### 1.5 Error Recovery & Resilience
|
||||||
|
**Priority:** HIGH
|
||||||
|
**Time Estimate:** 4-5 days
|
||||||
|
|
||||||
|
**Tasks:**
|
||||||
|
- [ ] Graceful degradation patterns (continue trading if analytics fails)
|
||||||
|
- [ ] Circuit breaker implementations (stop on repeated failures)
|
||||||
|
- [ ] Retry policies with exponential backoff
|
||||||
|
- [ ] Dead letter queue for failed orders
|
||||||
|
- [ ] Connection loss recovery procedures
|
||||||
|
- [ ] State recovery after restart
|
||||||
|
- [ ] Partial system failure handling
|
||||||
|
- [ ] Emergency position flattening capability
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- `ResilienceManager.cs` component
|
||||||
|
- `CircuitBreaker.cs` implementation
|
||||||
|
- `RetryPolicy.cs` with configurable backoff
|
||||||
|
- `DeadLetterQueue.cs` for failed operations
|
||||||
|
- Emergency procedures documentation
|
||||||
|
|
||||||
|
**Success Criteria:**
|
||||||
|
- System recovers from NT8 connection loss automatically
|
||||||
|
- Failed orders logged and queued for manual review
|
||||||
|
- Circuit breakers prevent cascading failures
|
||||||
|
- Emergency flatten works in all scenarios
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
#### 1.6 Documentation & Runbooks
|
||||||
|
**Priority:** MEDIUM
|
||||||
|
**Time Estimate:** 2-3 days
|
||||||
|
|
||||||
|
**Tasks:**
|
||||||
|
- [ ] Deployment runbook (step-by-step)
|
||||||
|
- [ ] Troubleshooting guide (common issues)
|
||||||
|
- [ ] Emergency procedures manual
|
||||||
|
- [ ] Performance tuning guide
|
||||||
|
- [ ] Configuration reference
|
||||||
|
- [ ] Monitoring dashboard guide
|
||||||
|
- [ ] Incident response playbook
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- `docs/DEPLOYMENT_RUNBOOK.md`
|
||||||
|
- `docs/TROUBLESHOOTING.md`
|
||||||
|
- `docs/EMERGENCY_PROCEDURES.md`
|
||||||
|
- `docs/PERFORMANCE_TUNING.md`
|
||||||
|
- `docs/INCIDENT_RESPONSE.md`
|
||||||
|
|
||||||
|
**Success Criteria:**
|
||||||
|
- New team member can deploy following runbook
|
||||||
|
- Common issues resolved using troubleshooting guide
|
||||||
|
- Emergency procedures tested and validated
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Production Hardening: Total Timeline
|
||||||
|
**Estimated Time:** 18-26 days (2.5-4 weeks)
|
||||||
|
**Critical Path:** CI/CD → Integration Tests → Monitoring → Resilience
|
||||||
|
**Can Start Immediately:** All infrastructure code, no dependencies
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📋 Path 2: Golden Strategy Implementation
|
||||||
|
|
||||||
|
### Why This Path?
|
||||||
|
- **System Validation:** Proves all modules work together correctly
|
||||||
|
- **Best Practice Template:** Shows proper SDK usage patterns
|
||||||
|
- **Confidence Building:** Successful backtest validates architecture
|
||||||
|
- **Documentation by Example:** Working strategy is best documentation
|
||||||
|
|
||||||
|
### Strategy Specification: Enhanced SimpleORB
|
||||||
|
|
||||||
|
**Concept:** Opening Range Breakout with full intelligence layer integration
|
||||||
|
|
||||||
|
**Components Used:**
|
||||||
|
- ✅ Phase 1 (OMS): Order management and state machine
|
||||||
|
- ✅ Phase 2 (Risk): Multi-tier risk validation, position sizing
|
||||||
|
- ✅ Phase 3 (Market Structure): Liquidity monitoring, execution quality
|
||||||
|
- ✅ Phase 4 (Intelligence): Confluence scoring, regime detection
|
||||||
|
- ✅ Phase 5 (Analytics): Performance tracking, attribution
|
||||||
|
|
||||||
|
**Strategy Logic:**
|
||||||
|
1. Calculate opening range (first 30 minutes)
|
||||||
|
2. Detect regime (trending/ranging/volatile)
|
||||||
|
3. Calculate confluence score (6+ factors)
|
||||||
|
4. Apply grade-based filtering (A/B grades only in conservative mode)
|
||||||
|
5. Size position based on volatility and grade
|
||||||
|
6. Execute with liquidity checks
|
||||||
|
7. Manage trailing stops
|
||||||
|
8. Track all trades for attribution
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- `src/NT8.Strategies/Examples/EnhancedSimpleORB.cs` (~500 lines)
|
||||||
|
- `tests/NT8.Core.Tests/Strategies/EnhancedSimpleORBTests.cs` (30+ tests)
|
||||||
|
- `docs/GOLDEN_STRATEGY_GUIDE.md` (comprehensive walkthrough)
|
||||||
|
- Backtest results report (6 months historical data)
|
||||||
|
- Performance attribution breakdown
|
||||||
|
|
||||||
|
**Timeline:** 5-7 days
|
||||||
|
1. Day 1-2: Core strategy logic and backtesting framework
|
||||||
|
2. Day 3-4: Full module integration and unit testing
|
||||||
|
3. Day 5: Backtesting and performance analysis
|
||||||
|
4. Day 6-7: Documentation and refinement
|
||||||
|
|
||||||
|
**Success Criteria:**
|
||||||
|
- Strategy uses all Phase 1-5 components correctly
|
||||||
|
- Backtest shows positive edge (Sharpe > 1.0)
|
||||||
|
- All 30+ strategy tests passing
|
||||||
|
- Attribution shows expected grade/regime performance distribution
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📋 Path 3: Advanced Features (Future Enhancements)
|
||||||
|
|
||||||
|
These are lower priority but high value for institutional differentiation:
|
||||||
|
|
||||||
|
### 3.1 Smart Order Routing
|
||||||
|
**Time:** 2-3 weeks
|
||||||
|
**Value:** Optimize execution across multiple venues/brokers
|
||||||
|
|
||||||
|
### 3.2 Advanced Order Types
|
||||||
|
**Time:** 2-3 weeks
|
||||||
|
**Value:** Iceberg, TWAP, VWAP, POV execution algorithms
|
||||||
|
|
||||||
|
### 3.3 ML Model Integration
|
||||||
|
**Time:** 3-4 weeks
|
||||||
|
**Value:** Support for TensorFlow/ONNX model predictions
|
||||||
|
|
||||||
|
### 3.4 Multi-Timeframe Analysis
|
||||||
|
**Time:** 1-2 weeks
|
||||||
|
**Value:** Coordinate signals across multiple timeframes
|
||||||
|
|
||||||
|
### 3.5 Correlation-Based Portfolio Management
|
||||||
|
**Time:** 2-3 weeks
|
||||||
|
**Value:** Cross-strategy risk management and allocation
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🎯 Recommended Execution Order
|
||||||
|
|
||||||
|
### Option A: Safety First (Conservative)
|
||||||
|
```
|
||||||
|
Week 1-2: Production Hardening (CI/CD, Testing, Monitoring)
|
||||||
|
Week 3-4: Production Hardening (Config, Resilience, Docs)
|
||||||
|
Week 5: Golden Strategy Implementation
|
||||||
|
Week 6: Live Simulation Testing
|
||||||
|
Week 7+: Gradual live deployment with small position sizes
|
||||||
|
```
|
||||||
|
|
||||||
|
### Option B: Faster to Live (Moderate Risk)
|
||||||
|
```
|
||||||
|
Week 1: Core Production Hardening (CI/CD, Monitoring, Resilience)
|
||||||
|
Week 2: Golden Strategy + Basic Integration Tests
|
||||||
|
Week 3: Live Simulation Testing
|
||||||
|
Week 4+: Gradual live deployment
|
||||||
|
Weeks 5-6: Complete remaining hardening tasks
|
||||||
|
```
|
||||||
|
|
||||||
|
### Option C: Validate First (Learning Focus)
|
||||||
|
```
|
||||||
|
Week 1: Golden Strategy Implementation
|
||||||
|
Week 2: Extensive Backtesting and Refinement
|
||||||
|
Week 3: Production Hardening Critical Path
|
||||||
|
Week 4+: Remaining hardening + Live Deployment
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 💡 Recommendation: **Option A - Safety First**
|
||||||
|
|
||||||
|
**Rationale:**
|
||||||
|
- Production trading software must prioritize safety over speed
|
||||||
|
- Comprehensive monitoring prevents costly mistakes
|
||||||
|
- Proper infrastructure enables confident scaling
|
||||||
|
- Golden strategy validates after infrastructure is solid
|
||||||
|
- Matches institutional-grade standards
|
||||||
|
|
||||||
|
**First Action Items:**
|
||||||
|
1. Set up CI/CD pipeline (automated build + test)
|
||||||
|
2. Implement health monitoring and alerting
|
||||||
|
3. Add circuit breakers and resilience patterns
|
||||||
|
4. Create deployment runbook
|
||||||
|
5. Build enhanced integration test suite
|
||||||
|
6. Implement Golden Strategy for validation
|
||||||
|
7. Run 30-day simulation with full monitoring
|
||||||
|
8. Deploy to live with micro positions
|
||||||
|
9. Scale up gradually based on performance data
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📊 Success Metrics
|
||||||
|
|
||||||
|
### Production Readiness Checklist
|
||||||
|
- [ ] CI/CD pipeline operational (automated build/test/deploy)
|
||||||
|
- [ ] 240+ tests passing automatically on every commit
|
||||||
|
- [ ] Health monitoring operational with alerting
|
||||||
|
- [ ] Circuit breakers preventing cascading failures
|
||||||
|
- [ ] Complete deployment runbook validated
|
||||||
|
- [ ] Emergency procedures tested
|
||||||
|
- [ ] Configuration management operational
|
||||||
|
- [ ] Golden strategy running in simulation (30+ days)
|
||||||
|
- [ ] Performance metrics meeting targets (<200ms latency)
|
||||||
|
- [ ] Risk controls validated under stress
|
||||||
|
|
||||||
|
### Go-Live Criteria
|
||||||
|
- [ ] All production readiness items complete
|
||||||
|
- [ ] 30+ days successful simulation trading
|
||||||
|
- [ ] Zero critical incidents in simulation
|
||||||
|
- [ ] Performance attribution showing expected patterns
|
||||||
|
- [ ] Monitoring dashboard operational
|
||||||
|
- [ ] Emergency procedures tested and documented
|
||||||
|
- [ ] Team trained on runbooks and procedures
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🎉 Current Achievement Summary
|
||||||
|
|
||||||
|
**Phase 5 Completion Represents:**
|
||||||
|
- ✅ 85% of original project scope complete
|
||||||
|
- ✅ 20,000 lines of institutional-grade code
|
||||||
|
- ✅ 240+ tests with 100% pass rate
|
||||||
|
- ✅ Complete trading infrastructure (OMS, Risk, Sizing, Intelligence, Analytics)
|
||||||
|
- ✅ Sub-200ms latency performance
|
||||||
|
- ✅ Thread-safe, deterministic, auditable architecture
|
||||||
|
- ✅ Full .NET Framework 4.8 / C# 5.0 compliance
|
||||||
|
|
||||||
|
**Remaining to Production:**
|
||||||
|
- Infrastructure hardening (2-4 weeks)
|
||||||
|
- Strategy validation (1 week)
|
||||||
|
- Simulation testing (30 days)
|
||||||
|
- Gradual live deployment (ongoing)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**The NT8 SDK is ready for production hardening. The foundation is solid, comprehensive, and institutional-grade.**
|
||||||
|
|
||||||
|
Next step: Choose your path and let's execute! 🚀
|
||||||
745
NT8_INTEGRATION_IMPLEMENTATION_PLAN.md
Normal file
745
NT8_INTEGRATION_IMPLEMENTATION_PLAN.md
Normal file
@@ -0,0 +1,745 @@
|
|||||||
|
# NinjaTrader 8 Integration - Complete Implementation Plan
|
||||||
|
|
||||||
|
**Project:** NT8 SDK
|
||||||
|
**Phase:** NT8 Integration Layer
|
||||||
|
**Date:** February 17, 2026
|
||||||
|
**Status:** Planning → Implementation Ready
|
||||||
|
**Estimated Time:** 12-16 hours total
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🎯 Objective
|
||||||
|
|
||||||
|
Build a **complete, production-ready NinjaTrader 8 integration layer** that enables the NT8 SDK to run strategies inside NinjaTrader 8 with full order execution, risk management, and performance tracking.
|
||||||
|
|
||||||
|
**Success Criteria:**
|
||||||
|
- ✅ SimpleORB strategy compiles in NinjaTrader 8
|
||||||
|
- ✅ Strategy can be enabled on a chart
|
||||||
|
- ✅ Orders submit correctly to simulation account
|
||||||
|
- ✅ Risk controls trigger appropriately
|
||||||
|
- ✅ All 240+ existing tests still pass
|
||||||
|
- ✅ Zero compilation warnings in NT8
|
||||||
|
- ✅ Strategy runs for 1+ hours without errors
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📋 Current State Assessment
|
||||||
|
|
||||||
|
### What We Have ✅
|
||||||
|
- **Core SDK:** 20,000 lines of production code (Phases 0-5 complete)
|
||||||
|
- **Strategy Logic:** SimpleORBStrategy fully implemented
|
||||||
|
- **Risk System:** Multi-tier validation operational
|
||||||
|
- **Position Sizing:** Multiple sizing methods working
|
||||||
|
- **Analytics:** Complete performance tracking
|
||||||
|
- **Test Coverage:** 240+ tests passing (100% pass rate)
|
||||||
|
|
||||||
|
### What's Missing ❌
|
||||||
|
1. **NT8 Strategy Base Class** - Inherits from NinjaTrader's Strategy class
|
||||||
|
2. **Real Order Adapter** - Actual NT8 order submission (not stubs)
|
||||||
|
3. **Data Adapter** - NT8 bar/market data conversion
|
||||||
|
4. **Execution Adapter** - Fill/update callback handling
|
||||||
|
5. **Deployment Automation** - Script to copy files to NT8
|
||||||
|
6. **Minimal Test Strategy** - Simple validation strategy
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🏗️ Implementation Architecture
|
||||||
|
|
||||||
|
### Layer Separation Strategy
|
||||||
|
|
||||||
|
```
|
||||||
|
┌─────────────────────────────────────────────────────────────┐
|
||||||
|
│ NinjaTrader 8 Platform │
|
||||||
|
│ (Strategy base class, Order objects, Instrument, etc.) │
|
||||||
|
└────────────────────┬────────────────────────────────────────┘
|
||||||
|
│
|
||||||
|
↓ Inherits & Implements
|
||||||
|
┌─────────────────────────────────────────────────────────────┐
|
||||||
|
│ NT8StrategyBase (NEW) │
|
||||||
|
│ • Inherits: NinjaTrader.NinjaScript.Strategies.Strategy │
|
||||||
|
│ • Implements: NT8 lifecycle (OnStateChange, OnBarUpdate) │
|
||||||
|
│ • Bridges: NT8 events → SDK components │
|
||||||
|
│ • Location: Deployed directly to NT8 (not in DLL) │
|
||||||
|
└────────────────────┬────────────────────────────────────────┘
|
||||||
|
│
|
||||||
|
↓ Uses
|
||||||
|
┌─────────────────────────────────────────────────────────────┐
|
||||||
|
│ NT8ExecutionAdapter (NEW) │
|
||||||
|
│ • Order submission: SDK OrderRequest → NT8 EnterLong/Short │
|
||||||
|
│ • Order management: NT8 Order tracking │
|
||||||
|
│ • Fill handling: NT8 Execution → SDK OrderStatus │
|
||||||
|
│ • Location: NT8.Adapters.dll │
|
||||||
|
└────────────────────┬────────────────────────────────────────┘
|
||||||
|
│
|
||||||
|
↓ Coordinates
|
||||||
|
┌─────────────────────────────────────────────────────────────┐
|
||||||
|
│ NT8.Core.dll │
|
||||||
|
│ • All SDK business logic (already complete) │
|
||||||
|
│ • Risk, Sizing, OMS, Analytics, Intelligence │
|
||||||
|
│ • Location: NT8 Custom\bin folder │
|
||||||
|
└─────────────────────────────────────────────────────────────┘
|
||||||
|
```
|
||||||
|
|
||||||
|
### Why This Architecture?
|
||||||
|
|
||||||
|
1. **NT8StrategyBase deployed as .cs file** - NT8 must compile it to access platform APIs
|
||||||
|
2. **NT8ExecutionAdapter in DLL** - Reusable adapter logic, testable
|
||||||
|
3. **Core SDK in DLL** - All business logic stays in tested, versioned SDK
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📦 Deliverables (6 Major Components)
|
||||||
|
|
||||||
|
### Component 1: NT8ExecutionAdapter.cs
|
||||||
|
**Location:** `src/NT8.Adapters/NinjaTrader/NT8ExecutionAdapter.cs`
|
||||||
|
**Purpose:** Bridge between SDK OrderRequest and NT8 Order objects
|
||||||
|
**Time:** 3-4 hours
|
||||||
|
|
||||||
|
**Key Responsibilities:**
|
||||||
|
- Accept SDK `OrderRequest`, create NT8 `Order` objects
|
||||||
|
- Submit orders via NT8 `EnterLong()`, `EnterShort()`, `ExitLong()`, `ExitShort()`
|
||||||
|
- Track NT8 orders and map to SDK order IDs
|
||||||
|
- Handle NT8 `OnOrderUpdate()` callbacks
|
||||||
|
- Handle NT8 `OnExecutionUpdate()` callbacks
|
||||||
|
- Thread-safe order state management
|
||||||
|
|
||||||
|
**Interface:**
|
||||||
|
```csharp
|
||||||
|
public class NT8ExecutionAdapter
|
||||||
|
{
|
||||||
|
// Submit order to NT8
|
||||||
|
public string SubmitOrder(
|
||||||
|
NinjaTrader.NinjaScript.Strategies.Strategy strategy,
|
||||||
|
OrderRequest request);
|
||||||
|
|
||||||
|
// Cancel order in NT8
|
||||||
|
public bool CancelOrder(
|
||||||
|
NinjaTrader.NinjaScript.Strategies.Strategy strategy,
|
||||||
|
string orderId);
|
||||||
|
|
||||||
|
// Process NT8 order update
|
||||||
|
public void ProcessOrderUpdate(
|
||||||
|
NinjaTrader.Cbi.Order order,
|
||||||
|
double limitPrice,
|
||||||
|
double stopPrice,
|
||||||
|
int quantity,
|
||||||
|
int filled,
|
||||||
|
double averageFillPrice,
|
||||||
|
NinjaTrader.Cbi.OrderState orderState,
|
||||||
|
DateTime time,
|
||||||
|
NinjaTrader.Cbi.ErrorCode errorCode,
|
||||||
|
string nativeError);
|
||||||
|
|
||||||
|
// Process NT8 execution
|
||||||
|
public void ProcessExecution(
|
||||||
|
NinjaTrader.Cbi.Execution execution);
|
||||||
|
|
||||||
|
// Get order status
|
||||||
|
public OrderStatus GetOrderStatus(string orderId);
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
**Dependencies:**
|
||||||
|
- Requires reference to `NinjaTrader.Core.dll`
|
||||||
|
- Requires reference to `NinjaTrader.Cbi.dll`
|
||||||
|
- Uses SDK `OrderRequest`, `OrderStatus`, `OrderState`
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Component 2: NT8DataAdapter.cs
|
||||||
|
**Location:** `src/NT8.Adapters/NinjaTrader/NT8DataAdapter.cs`
|
||||||
|
**Purpose:** Convert NT8 market data to SDK format
|
||||||
|
**Time:** 2 hours
|
||||||
|
|
||||||
|
**Key Responsibilities:**
|
||||||
|
- Convert NT8 bars to SDK `BarData`
|
||||||
|
- Convert NT8 account info to SDK `AccountInfo`
|
||||||
|
- Convert NT8 position to SDK `Position`
|
||||||
|
- Convert NT8 instrument to SDK `Instrument`
|
||||||
|
|
||||||
|
**Interface:**
|
||||||
|
```csharp
|
||||||
|
public class NT8DataAdapter
|
||||||
|
{
|
||||||
|
// Convert NT8 bar to SDK format
|
||||||
|
public static BarData ConvertBar(
|
||||||
|
NinjaTrader.Data.Bars bars,
|
||||||
|
int barsAgo);
|
||||||
|
|
||||||
|
// Convert NT8 account to SDK format
|
||||||
|
public static AccountInfo ConvertAccount(
|
||||||
|
NinjaTrader.Cbi.Account account);
|
||||||
|
|
||||||
|
// Convert NT8 position to SDK format
|
||||||
|
public static Position ConvertPosition(
|
||||||
|
NinjaTrader.Cbi.Position position);
|
||||||
|
|
||||||
|
// Build strategy context
|
||||||
|
public static StrategyContext BuildContext(
|
||||||
|
NinjaTrader.NinjaScript.Strategies.Strategy strategy,
|
||||||
|
AccountInfo account,
|
||||||
|
Position position);
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Component 3: NT8StrategyBase.cs
|
||||||
|
**Location:** `src/NT8.Adapters/Strategies/NT8StrategyBase.cs`
|
||||||
|
**Purpose:** Base class for all NT8-integrated strategies
|
||||||
|
**Time:** 4-5 hours
|
||||||
|
**Deployment:** Copied to NT8 as .cs file (not compiled into DLL)
|
||||||
|
|
||||||
|
**Key Responsibilities:**
|
||||||
|
- Inherit from `NinjaTrader.NinjaScript.Strategies.Strategy`
|
||||||
|
- Implement NT8 lifecycle methods
|
||||||
|
- Create and manage SDK components
|
||||||
|
- Bridge NT8 events to SDK
|
||||||
|
- Handle errors and logging
|
||||||
|
|
||||||
|
**Lifecycle Implementation:**
|
||||||
|
```csharp
|
||||||
|
public abstract class NT8StrategyBase
|
||||||
|
: NinjaTrader.NinjaScript.Strategies.Strategy
|
||||||
|
{
|
||||||
|
protected IStrategy _sdkStrategy;
|
||||||
|
protected IRiskManager _riskManager;
|
||||||
|
protected IPositionSizer _positionSizer;
|
||||||
|
protected NT8ExecutionAdapter _executionAdapter;
|
||||||
|
protected ILogger _logger;
|
||||||
|
|
||||||
|
protected override void OnStateChange()
|
||||||
|
{
|
||||||
|
switch (State)
|
||||||
|
{
|
||||||
|
case State.SetDefaults:
|
||||||
|
// Set strategy defaults
|
||||||
|
break;
|
||||||
|
|
||||||
|
case State.Configure:
|
||||||
|
// Add data series, indicators
|
||||||
|
break;
|
||||||
|
|
||||||
|
case State.DataLoaded:
|
||||||
|
// Initialize SDK components
|
||||||
|
InitializeSdkComponents();
|
||||||
|
break;
|
||||||
|
|
||||||
|
case State.Historical:
|
||||||
|
case State.Transition:
|
||||||
|
case State.Realtime:
|
||||||
|
// Strategy ready for trading
|
||||||
|
break;
|
||||||
|
|
||||||
|
case State.Terminated:
|
||||||
|
// Cleanup
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
protected override void OnBarUpdate()
|
||||||
|
{
|
||||||
|
if (CurrentBar < BarsRequiredToTrade) return;
|
||||||
|
|
||||||
|
// Convert NT8 bar to SDK
|
||||||
|
var barData = NT8DataAdapter.ConvertBar(Bars, 0);
|
||||||
|
var context = NT8DataAdapter.BuildContext(this, account, position);
|
||||||
|
|
||||||
|
// Call SDK strategy
|
||||||
|
var intent = _sdkStrategy.OnBar(barData, context);
|
||||||
|
|
||||||
|
if (intent != null)
|
||||||
|
{
|
||||||
|
ProcessIntent(intent, context);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
protected override void OnOrderUpdate(
|
||||||
|
Order order, double limitPrice, double stopPrice,
|
||||||
|
int quantity, int filled, double averageFillPrice,
|
||||||
|
OrderState orderState, DateTime time,
|
||||||
|
ErrorCode errorCode, string nativeError)
|
||||||
|
{
|
||||||
|
_executionAdapter.ProcessOrderUpdate(
|
||||||
|
order, limitPrice, stopPrice, quantity, filled,
|
||||||
|
averageFillPrice, orderState, time, errorCode, nativeError);
|
||||||
|
}
|
||||||
|
|
||||||
|
protected override void OnExecutionUpdate(
|
||||||
|
Execution execution, string executionId,
|
||||||
|
double price, int quantity,
|
||||||
|
MarketPosition marketPosition, string orderId,
|
||||||
|
DateTime time)
|
||||||
|
{
|
||||||
|
_executionAdapter.ProcessExecution(execution);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Abstract methods for derived strategies
|
||||||
|
protected abstract IStrategy CreateSdkStrategy();
|
||||||
|
protected abstract void ConfigureStrategyParameters();
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Component 4: SimpleORBNT8.cs
|
||||||
|
**Location:** `src/NT8.Adapters/Strategies/SimpleORBNT8.cs`
|
||||||
|
**Purpose:** Concrete SimpleORB implementation for NT8
|
||||||
|
**Time:** 1-2 hours
|
||||||
|
**Deployment:** Copied to NT8 as .cs file
|
||||||
|
|
||||||
|
**Implementation:**
|
||||||
|
```csharp
|
||||||
|
public class SimpleORBNT8 : NT8StrategyBase
|
||||||
|
{
|
||||||
|
#region User-Configurable Parameters
|
||||||
|
|
||||||
|
[NinjaScriptProperty]
|
||||||
|
[Display(Name = "Opening Range Minutes", GroupName = "Strategy")]
|
||||||
|
public int OpeningRangeMinutes { get; set; }
|
||||||
|
|
||||||
|
[NinjaScriptProperty]
|
||||||
|
[Display(Name = "Std Dev Multiplier", GroupName = "Strategy")]
|
||||||
|
public double StdDevMultiplier { get; set; }
|
||||||
|
|
||||||
|
[NinjaScriptProperty]
|
||||||
|
[Display(Name = "Stop Ticks", GroupName = "Risk")]
|
||||||
|
public int StopTicks { get; set; }
|
||||||
|
|
||||||
|
[NinjaScriptProperty]
|
||||||
|
[Display(Name = "Target Ticks", GroupName = "Risk")]
|
||||||
|
public int TargetTicks { get; set; }
|
||||||
|
|
||||||
|
[NinjaScriptProperty]
|
||||||
|
[Display(Name = "Daily Loss Limit", GroupName = "Risk")]
|
||||||
|
public double DailyLossLimit { get; set; }
|
||||||
|
|
||||||
|
#endregion
|
||||||
|
|
||||||
|
protected override void OnStateChange()
|
||||||
|
{
|
||||||
|
if (State == State.SetDefaults)
|
||||||
|
{
|
||||||
|
Name = "Simple ORB NT8";
|
||||||
|
Description = "Opening Range Breakout with SDK integration";
|
||||||
|
Calculate = Calculate.OnBarClose;
|
||||||
|
|
||||||
|
// Default parameters
|
||||||
|
OpeningRangeMinutes = 30;
|
||||||
|
StdDevMultiplier = 1.0;
|
||||||
|
StopTicks = 8;
|
||||||
|
TargetTicks = 16;
|
||||||
|
DailyLossLimit = 1000.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
base.OnStateChange();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected override IStrategy CreateSdkStrategy()
|
||||||
|
{
|
||||||
|
return new NT8.Strategies.Examples.SimpleORBStrategy(
|
||||||
|
OpeningRangeMinutes,
|
||||||
|
StdDevMultiplier);
|
||||||
|
}
|
||||||
|
|
||||||
|
protected override void ConfigureStrategyParameters()
|
||||||
|
{
|
||||||
|
_strategyConfig.RiskSettings.DailyLossLimit = DailyLossLimit;
|
||||||
|
_strategyConfig.RiskSettings.MaxTradeRisk = StopTicks * Instrument.MasterInstrument.PointValue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Component 5: MinimalTestStrategy.cs
|
||||||
|
**Location:** `src/NT8.Adapters/Strategies/MinimalTestStrategy.cs`
|
||||||
|
**Purpose:** Simple test strategy to validate integration
|
||||||
|
**Time:** 30 minutes
|
||||||
|
|
||||||
|
**Implementation:**
|
||||||
|
```csharp
|
||||||
|
public class MinimalTestStrategy
|
||||||
|
: NinjaTrader.NinjaScript.Strategies.Strategy
|
||||||
|
{
|
||||||
|
protected override void OnStateChange()
|
||||||
|
{
|
||||||
|
if (State == State.SetDefaults)
|
||||||
|
{
|
||||||
|
Name = "Minimal Test";
|
||||||
|
Description = "Validates NT8 integration without SDK";
|
||||||
|
Calculate = Calculate.OnBarClose;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
protected override void OnBarUpdate()
|
||||||
|
{
|
||||||
|
if (CurrentBar < 20) return;
|
||||||
|
|
||||||
|
// Just log, no trading
|
||||||
|
Print(string.Format("{0}: O={1:F2} H={2:F2} L={3:F2} C={4:F2} V={5}",
|
||||||
|
Time[0].ToString("HH:mm:ss"),
|
||||||
|
Open[0], High[0], Low[0], Close[0], Volume[0]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Component 6: Deploy-To-NT8.ps1
|
||||||
|
**Location:** `deployment/Deploy-To-NT8.ps1`
|
||||||
|
**Purpose:** Automate deployment to NinjaTrader 8
|
||||||
|
**Time:** 1 hour
|
||||||
|
|
||||||
|
**Script:**
|
||||||
|
```powershell
|
||||||
|
# NT8 SDK Deployment Script
|
||||||
|
param(
|
||||||
|
[switch]$BuildFirst = $true,
|
||||||
|
[switch]$RunTests = $true,
|
||||||
|
[switch]$CopyStrategies = $true
|
||||||
|
)
|
||||||
|
|
||||||
|
$ErrorActionPreference = "Stop"
|
||||||
|
$sdkRoot = "C:\dev\nt8-sdk"
|
||||||
|
$nt8Custom = "$env:USERPROFILE\Documents\NinjaTrader 8\bin\Custom"
|
||||||
|
$nt8Strategies = "$nt8Custom\Strategies"
|
||||||
|
|
||||||
|
Write-Host "NT8 SDK Deployment Script" -ForegroundColor Cyan
|
||||||
|
Write-Host "=" * 60
|
||||||
|
|
||||||
|
# Step 1: Build
|
||||||
|
if ($BuildFirst) {
|
||||||
|
Write-Host "`n[1/5] Building SDK..." -ForegroundColor Yellow
|
||||||
|
|
||||||
|
Push-Location $sdkRoot
|
||||||
|
dotnet clean --configuration Release | Out-Null
|
||||||
|
$buildResult = dotnet build --configuration Release
|
||||||
|
|
||||||
|
if ($LASTEXITCODE -ne 0) {
|
||||||
|
Write-Host "Build FAILED!" -ForegroundColor Red
|
||||||
|
Pop-Location
|
||||||
|
exit 1
|
||||||
|
}
|
||||||
|
|
||||||
|
Write-Host "Build succeeded" -ForegroundColor Green
|
||||||
|
Pop-Location
|
||||||
|
}
|
||||||
|
|
||||||
|
# Step 2: Run Tests
|
||||||
|
if ($RunTests) {
|
||||||
|
Write-Host "`n[2/5] Running tests..." -ForegroundColor Yellow
|
||||||
|
|
||||||
|
Push-Location $sdkRoot
|
||||||
|
$testResult = dotnet test --configuration Release --no-build
|
||||||
|
|
||||||
|
if ($LASTEXITCODE -ne 0) {
|
||||||
|
Write-Host "Tests FAILED!" -ForegroundColor Red
|
||||||
|
Pop-Location
|
||||||
|
exit 1
|
||||||
|
}
|
||||||
|
|
||||||
|
Write-Host "All tests passed" -ForegroundColor Green
|
||||||
|
Pop-Location
|
||||||
|
}
|
||||||
|
|
||||||
|
# Step 3: Copy Core DLL
|
||||||
|
Write-Host "`n[3/5] Copying SDK DLLs..." -ForegroundColor Yellow
|
||||||
|
|
||||||
|
$coreDll = "$sdkRoot\src\NT8.Core\bin\Release\net48\NT8.Core.dll"
|
||||||
|
$corePdb = "$sdkRoot\src\NT8.Core\bin\Release\net48\NT8.Core.pdb"
|
||||||
|
|
||||||
|
Copy-Item $coreDll $nt8Custom -Force
|
||||||
|
Copy-Item $corePdb $nt8Custom -Force
|
||||||
|
|
||||||
|
Write-Host "Copied NT8.Core.dll and .pdb" -ForegroundColor Green
|
||||||
|
|
||||||
|
# Step 4: Copy Dependencies
|
||||||
|
Write-Host "`n[4/5] Copying dependencies..." -ForegroundColor Yellow
|
||||||
|
|
||||||
|
$depsPath = "$sdkRoot\src\NT8.Core\bin\Release\net48"
|
||||||
|
$deps = @(
|
||||||
|
"Microsoft.Extensions.*.dll",
|
||||||
|
"System.Memory.dll",
|
||||||
|
"System.Buffers.dll"
|
||||||
|
)
|
||||||
|
|
||||||
|
foreach ($dep in $deps) {
|
||||||
|
Get-ChildItem "$depsPath\$dep" -ErrorAction SilentlyContinue |
|
||||||
|
Copy-Item -Destination $nt8Custom -Force
|
||||||
|
}
|
||||||
|
|
||||||
|
Write-Host "Copied dependencies" -ForegroundColor Green
|
||||||
|
|
||||||
|
# Step 5: Copy Strategies
|
||||||
|
if ($CopyStrategies) {
|
||||||
|
Write-Host "`n[5/5] Copying strategies..." -ForegroundColor Yellow
|
||||||
|
|
||||||
|
$strategyFiles = @(
|
||||||
|
"$sdkRoot\src\NT8.Adapters\Strategies\NT8StrategyBase.cs",
|
||||||
|
"$sdkRoot\src\NT8.Adapters\Strategies\SimpleORBNT8.cs",
|
||||||
|
"$sdkRoot\src\NT8.Adapters\Strategies\MinimalTestStrategy.cs"
|
||||||
|
)
|
||||||
|
|
||||||
|
foreach ($file in $strategyFiles) {
|
||||||
|
if (Test-Path $file) {
|
||||||
|
Copy-Item $file $nt8Strategies -Force
|
||||||
|
Write-Host " Copied $(Split-Path $file -Leaf)" -ForegroundColor Green
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Write-Host "`n" + ("=" * 60) -ForegroundColor Cyan
|
||||||
|
Write-Host "Deployment Complete!" -ForegroundColor Green
|
||||||
|
Write-Host "`nNext steps:" -ForegroundColor Yellow
|
||||||
|
Write-Host "1. Open NinjaTrader 8"
|
||||||
|
Write-Host "2. Tools -> NinjaScript Editor (F5)"
|
||||||
|
Write-Host "3. Compile -> Compile All (F5)"
|
||||||
|
Write-Host "4. Verify compilation succeeds"
|
||||||
|
Write-Host "5. Create new strategy instance on chart"
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🔄 Implementation Sequence
|
||||||
|
|
||||||
|
### Phase A: Foundation (4-5 hours)
|
||||||
|
**Goal:** Build adapter infrastructure
|
||||||
|
|
||||||
|
1. **Create NT8DataAdapter.cs** (2 hours)
|
||||||
|
- Implement bar conversion
|
||||||
|
- Implement account conversion
|
||||||
|
- Implement position conversion
|
||||||
|
- Implement context builder
|
||||||
|
- Write unit tests (20+ tests)
|
||||||
|
|
||||||
|
2. **Create NT8ExecutionAdapter.cs** (2-3 hours)
|
||||||
|
- Implement order submission logic
|
||||||
|
- Implement order state tracking
|
||||||
|
- Implement callback processing
|
||||||
|
- Write unit tests (30+ tests)
|
||||||
|
|
||||||
|
**Verification:**
|
||||||
|
```bash
|
||||||
|
dotnet test --filter "FullyQualifiedName~NT8DataAdapter"
|
||||||
|
dotnet test --filter "FullyQualifiedName~NT8ExecutionAdapter"
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Phase B: Strategy Base (4-5 hours)
|
||||||
|
**Goal:** Build NT8 strategy base class
|
||||||
|
|
||||||
|
3. **Create NT8StrategyBase.cs** (3-4 hours)
|
||||||
|
- Implement state change lifecycle
|
||||||
|
- Implement OnBarUpdate integration
|
||||||
|
- Implement order callback handling
|
||||||
|
- Add error handling and logging
|
||||||
|
- Add component initialization
|
||||||
|
|
||||||
|
4. **Create SimpleORBNT8.cs** (1 hour)
|
||||||
|
- Implement concrete strategy
|
||||||
|
- Add NT8 property decorators
|
||||||
|
- Configure strategy parameters
|
||||||
|
|
||||||
|
**Manual Verification:**
|
||||||
|
- Copy to NT8 Strategies folder
|
||||||
|
- Open NinjaScript Editor
|
||||||
|
- Verify no compilation errors
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Phase C: Testing & Deployment (3-4 hours)
|
||||||
|
**Goal:** Validate and deploy
|
||||||
|
|
||||||
|
5. **Create MinimalTestStrategy.cs** (30 min)
|
||||||
|
- Simple logging strategy
|
||||||
|
- No SDK dependencies
|
||||||
|
- Validates NT8 integration basics
|
||||||
|
|
||||||
|
6. **Create Deploy-To-NT8.ps1** (1 hour)
|
||||||
|
- Automate build
|
||||||
|
- Automate file copying
|
||||||
|
- Add verification steps
|
||||||
|
|
||||||
|
7. **Integration Testing** (2-3 hours)
|
||||||
|
- Deploy to NT8
|
||||||
|
- Compile in NT8
|
||||||
|
- Enable MinimalTestStrategy on chart (verify basic NT8 integration)
|
||||||
|
- Enable SimpleORBNT8 on chart (verify full SDK integration)
|
||||||
|
- Run on sim data for 1 hour
|
||||||
|
- Verify risk controls
|
||||||
|
- Verify order submission
|
||||||
|
- Document any issues
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## ✅ Verification Checklist
|
||||||
|
|
||||||
|
### Build Verification
|
||||||
|
- [ ] `dotnet build --configuration Release` succeeds
|
||||||
|
- [ ] `dotnet test --configuration Release` all 240+ tests pass
|
||||||
|
- [ ] Zero build warnings for new adapter code
|
||||||
|
- [ ] NT8.Core.dll builds successfully
|
||||||
|
- [ ] Dependencies copy correctly
|
||||||
|
|
||||||
|
### NT8 Compilation Verification
|
||||||
|
- [ ] NinjaScript Editor opens without errors
|
||||||
|
- [ ] "Compile All" succeeds with zero errors
|
||||||
|
- [ ] Zero warnings for NT8StrategyBase.cs
|
||||||
|
- [ ] Zero warnings for SimpleORBNT8.cs
|
||||||
|
- [ ] MinimalTestStrategy.cs compiles
|
||||||
|
- [ ] All strategies visible in strategy dropdown
|
||||||
|
|
||||||
|
### Runtime Verification (Simulation)
|
||||||
|
- [ ] MinimalTestStrategy enables on chart without errors
|
||||||
|
- [ ] MinimalTestStrategy logs bars correctly
|
||||||
|
- [ ] SimpleORBNT8 enables on chart without errors
|
||||||
|
- [ ] SimpleORBNT8 initializes SDK components
|
||||||
|
- [ ] Opening range calculated correctly
|
||||||
|
- [ ] Risk validation triggers
|
||||||
|
- [ ] Orders submit to simulation account
|
||||||
|
- [ ] Fills process correctly
|
||||||
|
- [ ] Stops and targets placed correctly
|
||||||
|
- [ ] Strategy runs for 1+ hours without errors
|
||||||
|
- [ ] Daily loss limit triggers correctly
|
||||||
|
- [ ] Emergency flatten works
|
||||||
|
|
||||||
|
### Performance Verification
|
||||||
|
- [ ] OnBarUpdate executes in <200ms
|
||||||
|
- [ ] Order submission in <5ms (excluding NT8)
|
||||||
|
- [ ] No memory leaks over 1+ hour run
|
||||||
|
- [ ] Thread-safe operation confirmed
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📊 Success Metrics
|
||||||
|
|
||||||
|
### Must Have (Release Blockers)
|
||||||
|
- ✅ Zero compilation errors in NT8
|
||||||
|
- ✅ Zero runtime exceptions for 1+ hours
|
||||||
|
- ✅ All risk controls working correctly
|
||||||
|
- ✅ Orders execute as expected
|
||||||
|
- ✅ Position tracking accurate
|
||||||
|
- ✅ All 240+ SDK tests still passing
|
||||||
|
|
||||||
|
### Should Have (Quality Targets)
|
||||||
|
- ✅ <200ms tick-to-trade latency
|
||||||
|
- ✅ <5ms order submission time
|
||||||
|
- ✅ 95%+ test coverage on new adapters
|
||||||
|
- ✅ Zero memory leaks
|
||||||
|
- ✅ Comprehensive error logging
|
||||||
|
|
||||||
|
### Nice to Have (Future Enhancements)
|
||||||
|
- ⭕ Automated NT8 integration tests
|
||||||
|
- ⭕ Performance profiling tools
|
||||||
|
- ⭕ Replay testing framework
|
||||||
|
- ⭕ Multi-strategy coordination
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🚨 Risk Mitigation
|
||||||
|
|
||||||
|
### Critical Risks
|
||||||
|
|
||||||
|
**Risk 1: NT8 API Changes**
|
||||||
|
- *Mitigation:* Reference exact NT8 version (8.0.20.1+)
|
||||||
|
- *Fallback:* Version compatibility matrix
|
||||||
|
|
||||||
|
**Risk 2: Thread Safety Issues**
|
||||||
|
- *Mitigation:* Comprehensive locking in adapters
|
||||||
|
- *Testing:* Stress test with rapid order submission
|
||||||
|
|
||||||
|
**Risk 3: Order State Synchronization**
|
||||||
|
- *Mitigation:* Correlation IDs for SDK↔NT8 mapping
|
||||||
|
- *Testing:* Partial fill scenarios
|
||||||
|
|
||||||
|
**Risk 4: Memory Leaks**
|
||||||
|
- *Mitigation:* Proper disposal in OnStateTerminated
|
||||||
|
- *Testing:* Long-running tests (4+ hours)
|
||||||
|
|
||||||
|
### Contingency Plans
|
||||||
|
|
||||||
|
**If NT8 Compilation Fails:**
|
||||||
|
1. Deploy MinimalTestStrategy only (no SDK)
|
||||||
|
2. Verify NT8 setup is correct
|
||||||
|
3. Add SDK components incrementally
|
||||||
|
4. Check DLL references
|
||||||
|
|
||||||
|
**If Orders Don't Submit:**
|
||||||
|
1. Check connection status
|
||||||
|
2. Verify account is in simulation
|
||||||
|
3. Check NT8 error logs
|
||||||
|
4. Validate order request format
|
||||||
|
|
||||||
|
**If Performance Issues:**
|
||||||
|
1. Profile OnBarUpdate
|
||||||
|
2. Reduce logging verbosity
|
||||||
|
3. Optimize hot paths
|
||||||
|
4. Consider async processing
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📝 Development Notes
|
||||||
|
|
||||||
|
### NT8-Specific Constraints
|
||||||
|
|
||||||
|
1. **Must use .NET Framework 4.8** (not .NET Core)
|
||||||
|
2. **Must use C# 5.0 syntax** (no modern features)
|
||||||
|
3. **Strategy classes must be public** and in correct namespace
|
||||||
|
4. **Properties need [NinjaScriptProperty]** attribute for UI
|
||||||
|
5. **No async/await in OnBarUpdate** (performance)
|
||||||
|
6. **Must not block NT8 UI thread** (<200ms execution)
|
||||||
|
|
||||||
|
### Coding Standards
|
||||||
|
|
||||||
|
All code must follow existing SDK patterns:
|
||||||
|
- XML documentation on all public members
|
||||||
|
- Comprehensive error handling
|
||||||
|
- Defensive validation
|
||||||
|
- Thread-safe operations
|
||||||
|
- Logging at appropriate levels
|
||||||
|
- Unit tests for all logic
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📚 Reference Documentation
|
||||||
|
|
||||||
|
- **NinjaTrader 8 Help Guide:** https://ninjatrader.com/support/helpGuides/nt8/
|
||||||
|
- **NinjaScript Reference:** https://ninjatrader.com/support/helpGuides/nt8/?ninjascript.htm
|
||||||
|
- **NT8 SDK Project Knowledge:** See project knowledge search
|
||||||
|
- **Architecture:** `/docs/ARCHITECTURE.md`
|
||||||
|
- **API Reference:** `/docs/API_REFERENCE.md`
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🎯 Next Steps
|
||||||
|
|
||||||
|
### Immediate Actions (Today)
|
||||||
|
1. ✅ Review this implementation plan
|
||||||
|
2. ✅ Confirm approach and estimates
|
||||||
|
3. ⏭️ Begin Phase A: Foundation (NT8DataAdapter)
|
||||||
|
|
||||||
|
### This Week
|
||||||
|
- Day 1: Phase A - Adapters (4-5 hours)
|
||||||
|
- Day 2: Phase B - Strategy Base (4-5 hours)
|
||||||
|
- Day 3: Phase C - Testing & Deployment (3-4 hours)
|
||||||
|
- Day 4: Bug fixes and refinement (2-3 hours)
|
||||||
|
- Day 5: Documentation and handoff (1-2 hours)
|
||||||
|
|
||||||
|
### Success Criteria Met When:
|
||||||
|
- SimpleORBNT8 runs successfully in NT8 simulation for 24+ hours
|
||||||
|
- All risk controls validated
|
||||||
|
- Zero critical bugs
|
||||||
|
- Complete documentation
|
||||||
|
- Deployment automated
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**Total Estimated Time:** 12-16 hours
|
||||||
|
**Critical Path:** Phase A → Phase B → Phase C
|
||||||
|
**Can Start Immediately:** Yes, all dependencies documented
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**Let's build this properly and get NT8 SDK running in NinjaTrader! 🚀**
|
||||||
260
PROJECT_HANDOVER.md
Normal file
260
PROJECT_HANDOVER.md
Normal file
@@ -0,0 +1,260 @@
|
|||||||
|
# NT8 SDK Project - Comprehensive Recap & Handover
|
||||||
|
|
||||||
|
**Document Version:** 2.0
|
||||||
|
**Date:** February 16, 2026
|
||||||
|
**Current Phase:** Phase 5 Complete
|
||||||
|
**Project Completion:** ~85%
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📋 Executive Summary
|
||||||
|
|
||||||
|
The NT8 SDK is an **institutional-grade algorithmic trading framework** for NinjaTrader 8, designed for automated futures trading (ES, NQ, MES, MNQ, CL, GC). Successfully completed **Phases 0-5** implementing core trading infrastructure, advanced risk management, intelligent position sizing, market microstructure awareness, intelligence layer with confluence scoring, and comprehensive analytics & reporting.
|
||||||
|
|
||||||
|
**Current State:** Production-ready core trading engine with 240+ passing tests, complete analytics layer, ready for production hardening.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🎯 Project Vision & Purpose
|
||||||
|
|
||||||
|
### Core Mission
|
||||||
|
Build an institutional-grade trading SDK that:
|
||||||
|
- **Protects Capital First** - Multi-tier risk management before profit
|
||||||
|
- **Makes Intelligent Decisions** - Grade trades based on multiple factors
|
||||||
|
- **Executes Professionally** - Sub-200ms latency, thread-safe operations
|
||||||
|
- **Measures Everything** - Comprehensive analytics and attribution
|
||||||
|
|
||||||
|
### Why This Matters
|
||||||
|
- This is **production trading software** where bugs = real financial losses
|
||||||
|
- System runs **24/5** during market hours
|
||||||
|
- **Institutional-grade quality** required (not hobbyist code)
|
||||||
|
- Must be **deterministic** for backtesting and auditing
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## ✅ Completed Phases (0-5)
|
||||||
|
|
||||||
|
### Phase 0: Foundation (30 minutes)
|
||||||
|
**Status:** ✅ Complete
|
||||||
|
**Deliverables:** Repository structure, build system, .NET Framework 4.8 setup
|
||||||
|
|
||||||
|
### Phase 1: Basic OMS (2 hours)
|
||||||
|
**Status:** ✅ Complete
|
||||||
|
**Tests:** 34 passing
|
||||||
|
**Code:** ~1,500 lines
|
||||||
|
**Deliverables:** Order state machine, basic order manager, NT8 adapter interface
|
||||||
|
|
||||||
|
### Phase 2: Enhanced Risk & Sizing (3 hours)
|
||||||
|
**Status:** ✅ Complete
|
||||||
|
**Tests:** 90+ passing
|
||||||
|
**Code:** ~3,000 lines
|
||||||
|
**Deliverables:** Multi-tier risk management, intelligent position sizing, optimal-f calculator
|
||||||
|
|
||||||
|
### Phase 3: Market Microstructure & Execution (3-4 hours)
|
||||||
|
**Status:** ✅ Complete
|
||||||
|
**Tests:** 120+ passing
|
||||||
|
**Code:** ~3,500 lines
|
||||||
|
**Deliverables:** Liquidity monitoring, execution quality tracking, slippage calculation
|
||||||
|
|
||||||
|
### Phase 4: Intelligence & Grading (4-5 hours)
|
||||||
|
**Status:** ✅ Complete
|
||||||
|
**Tests:** 150+ passing
|
||||||
|
**Code:** ~4,000 lines
|
||||||
|
**Deliverables:** Confluence scoring, regime detection, grade-based filtering, risk mode management
|
||||||
|
|
||||||
|
### Phase 5: Analytics & Reporting (3-4 hours)
|
||||||
|
**Status:** ✅ **COMPLETE - 2026-02-16**
|
||||||
|
**Tests:** 240+ passing (90 new analytics tests)
|
||||||
|
**Code:** ~5,000 lines
|
||||||
|
**Deliverables:**
|
||||||
|
- Trade lifecycle tracking & recording
|
||||||
|
- Performance metrics (Sharpe, Sortino, win rate, profit factor)
|
||||||
|
- Multi-dimensional P&L attribution (by grade, regime, time, strategy)
|
||||||
|
- Drawdown analysis with period detection
|
||||||
|
- Grade/Regime/Confluence performance insights
|
||||||
|
- Daily/Weekly/Monthly reporting
|
||||||
|
- Parameter optimization tools
|
||||||
|
- Monte Carlo simulation
|
||||||
|
- Portfolio optimization
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📊 Current Metrics
|
||||||
|
|
||||||
|
- **Total Production Code:** ~20,000 lines
|
||||||
|
- **Total Tests:** 240+
|
||||||
|
- **Test Pass Rate:** 100%
|
||||||
|
- **Code Coverage:** >85%
|
||||||
|
- **Performance:** All benchmarks exceeded
|
||||||
|
- **Analytics Components:** 15 major modules
|
||||||
|
- **Zero Critical Warnings:** Legacy warnings only (unchanged baseline)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🎯 Recommended Next Steps
|
||||||
|
|
||||||
|
### Option 1: Production Hardening (Recommended)
|
||||||
|
**Focus:** Make the system production-ready for live trading
|
||||||
|
|
||||||
|
**Priority Tasks:**
|
||||||
|
1. **CI/CD Pipeline**
|
||||||
|
- Automated build verification on commit
|
||||||
|
- Automated test execution
|
||||||
|
- Code coverage reporting
|
||||||
|
- Deployment automation to NinjaTrader 8
|
||||||
|
|
||||||
|
2. **Integration Testing Enhancement**
|
||||||
|
- End-to-end workflow tests
|
||||||
|
- Multi-component integration scenarios
|
||||||
|
- Performance benchmarking suite
|
||||||
|
- Stress testing under load
|
||||||
|
|
||||||
|
3. **Monitoring & Observability**
|
||||||
|
- Structured logging enhancements
|
||||||
|
- Health check endpoints
|
||||||
|
- Performance metrics collection
|
||||||
|
- Alert system for risk breaches
|
||||||
|
|
||||||
|
4. **Configuration Management**
|
||||||
|
- JSON-based configuration system
|
||||||
|
- Environment-specific configs (dev/sim/prod)
|
||||||
|
- Runtime parameter validation
|
||||||
|
- Configuration hot-reload capability
|
||||||
|
|
||||||
|
5. **Error Recovery & Resilience**
|
||||||
|
- Graceful degradation patterns
|
||||||
|
- Circuit breaker implementations
|
||||||
|
- Retry policies with exponential backoff
|
||||||
|
- Dead letter queue for failed orders
|
||||||
|
|
||||||
|
**Estimated Time:** 2-3 weeks with focused effort
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Option 2: Golden Strategy Implementation
|
||||||
|
**Focus:** Build reference strategy to validate all modules
|
||||||
|
|
||||||
|
**Deliverable:** Complete SimpleORBStrategy implementation that:
|
||||||
|
- Uses all Phase 1-5 components
|
||||||
|
- Demonstrates best practices
|
||||||
|
- Serves as template for future strategies
|
||||||
|
- Includes comprehensive backtesting
|
||||||
|
|
||||||
|
**Estimated Time:** 1 week
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Option 3: Advanced Features (Future Enhancements)
|
||||||
|
**Focus:** Add sophisticated trading capabilities
|
||||||
|
|
||||||
|
**Potential Additions:**
|
||||||
|
- Smart order routing across venues
|
||||||
|
- Advanced order types (Iceberg, TWAP, VWAP)
|
||||||
|
- ML model integration framework
|
||||||
|
- Multi-timeframe analysis
|
||||||
|
- Correlation-based portfolio management
|
||||||
|
|
||||||
|
**Estimated Time:** 2-4 weeks per major feature
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📁 Repository Structure
|
||||||
|
|
||||||
|
```
|
||||||
|
C:\dev\nt8-sdk\
|
||||||
|
├── src/
|
||||||
|
│ ├── NT8.Core/ # Core business logic (20,000 lines)
|
||||||
|
│ │ ├── Analytics/ ✅ Phase 5 - Trade analytics & reporting
|
||||||
|
│ │ ├── Intelligence/ ✅ Phase 4 - Confluence & grading
|
||||||
|
│ │ ├── Execution/ ✅ Phase 3 - Execution quality
|
||||||
|
│ │ ├── MarketData/ ✅ Phase 3 - Market microstructure
|
||||||
|
│ │ ├── Sizing/ ✅ Phase 2 - Position sizing
|
||||||
|
│ │ ├── Risk/ ✅ Phase 2 - Risk management
|
||||||
|
│ │ ├── OMS/ ✅ Phase 1 - Order management
|
||||||
|
│ │ ├── Common/ ✅ Phase 0 - Core interfaces
|
||||||
|
│ │ └── Logging/ ✅ Phase 0 - Logging infrastructure
|
||||||
|
│ ├── NT8.Adapters/ # NinjaTrader 8 integration
|
||||||
|
│ ├── NT8.Strategies/ # Strategy implementations
|
||||||
|
│ └── NT8.Contracts/ # API contracts
|
||||||
|
├── tests/
|
||||||
|
│ ├── NT8.Core.Tests/ # 240+ unit tests
|
||||||
|
│ ├── NT8.Integration.Tests/ # Integration test suite
|
||||||
|
│ └── NT8.Performance.Tests/ # Performance benchmarks
|
||||||
|
├── docs/ # Complete documentation
|
||||||
|
│ ├── Phase5_Completion_Report.md # NEW: Analytics completion
|
||||||
|
│ ├── ARCHITECTURE.md
|
||||||
|
│ ├── API_REFERENCE.md
|
||||||
|
│ └── DEPLOYMENT_GUIDE.md
|
||||||
|
└── .kilocode/ # AI development rules
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🔑 Key Architecture Highlights
|
||||||
|
|
||||||
|
### Risk-First Design
|
||||||
|
All trading operations flow through multi-tier risk validation before execution. No shortcuts, no bypasses.
|
||||||
|
|
||||||
|
### Thread-Safe Operations
|
||||||
|
Comprehensive locking patterns protect all shared state from concurrent access issues.
|
||||||
|
|
||||||
|
### Deterministic Replay
|
||||||
|
Complete audit trail with correlation IDs enables exact replay of historical sessions.
|
||||||
|
|
||||||
|
### Modular Component Design
|
||||||
|
Clean separation between Core (business logic), Adapters (NT8 integration), and Strategies (trading logic).
|
||||||
|
|
||||||
|
### Analytics-Driven Optimization
|
||||||
|
Full attribution and performance measurement enables data-driven strategy improvement.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 📞 Support & Documentation
|
||||||
|
|
||||||
|
- **Architecture Guide:** `docs/ARCHITECTURE.md`
|
||||||
|
- **API Reference:** `docs/API_REFERENCE.md`
|
||||||
|
- **Deployment Guide:** `docs/DEPLOYMENT_GUIDE.md`
|
||||||
|
- **Quick Start:** `docs/QUICK_START.md`
|
||||||
|
- **Phase Reports:** `docs/Phase*_Completion_Report.md`
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🎉 Phase 5 Highlights
|
||||||
|
|
||||||
|
### What Was Built
|
||||||
|
- **15 major analytics components** covering the complete analytics lifecycle
|
||||||
|
- **90 new tests** bringing total to 240+ with 100% pass rate
|
||||||
|
- **Multi-dimensional attribution** enabling detailed performance breakdown
|
||||||
|
- **Optimization toolkit** for systematic strategy improvement
|
||||||
|
- **Production-ready reporting** with daily/weekly/monthly summaries
|
||||||
|
|
||||||
|
### Key Capabilities Added
|
||||||
|
1. **Trade Lifecycle Tracking** - Complete entry/exit/partial-fill capture
|
||||||
|
2. **Performance Measurement** - Sharpe, Sortino, win rate, profit factor, expectancy
|
||||||
|
3. **Attribution Analysis** - By grade, regime, time-of-day, strategy
|
||||||
|
4. **Drawdown Analysis** - Period detection, recovery metrics, risk assessment
|
||||||
|
5. **Confluence Validation** - Factor analysis, weighting optimization
|
||||||
|
6. **Parameter Optimization** - Grid search, walk-forward, sensitivity analysis
|
||||||
|
7. **Monte Carlo Simulation** - Confidence intervals, risk-of-ruin calculations
|
||||||
|
8. **Portfolio Optimization** - Multi-strategy allocation, portfolio-level metrics
|
||||||
|
|
||||||
|
### Technical Excellence
|
||||||
|
- ✅ Thread-safe in-memory storage
|
||||||
|
- ✅ Zero interface modifications (backward compatible)
|
||||||
|
- ✅ Comprehensive XML documentation
|
||||||
|
- ✅ C# 5.0 / .NET Framework 4.8 compliant
|
||||||
|
- ✅ Performance optimized (minimal allocations in hot paths)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🚀 Project Status: PHASE 5 COMPLETE
|
||||||
|
|
||||||
|
**The NT8 SDK now has a complete, production-grade analytics layer ready for institutional trading.**
|
||||||
|
|
||||||
|
Next recommended action: **Production Hardening** to prepare for live deployment.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**Document Prepared:** February 16, 2026
|
||||||
|
**Last Updated:** February 17, 2026
|
||||||
|
**Version:** 2.0
|
||||||
740
Phase5_Implementation_Guide.md
Normal file
740
Phase5_Implementation_Guide.md
Normal file
@@ -0,0 +1,740 @@
|
|||||||
|
# Phase 5: Analytics & Reporting - Implementation Guide
|
||||||
|
|
||||||
|
**Estimated Time:** 3-4 hours
|
||||||
|
**Complexity:** Medium
|
||||||
|
**Dependencies:** Phase 4 Complete ✅
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Implementation Overview
|
||||||
|
|
||||||
|
Phase 5 adds comprehensive analytics and reporting capabilities. This is the "observe, measure, and optimize" layer that helps understand performance, identify what's working, and continuously improve the trading system.
|
||||||
|
|
||||||
|
**Core Concept:** What gets measured gets improved. Track everything, attribute performance, find patterns.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Phase A: Trade Analytics Foundation (45 minutes)
|
||||||
|
|
||||||
|
### Task A1: Create AnalyticsModels.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/AnalyticsModels.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- `TradeRecord` record - Complete trade lifecycle
|
||||||
|
- `TradeMetrics` record - Per-trade performance metrics
|
||||||
|
- `PerformanceSnapshot` record - Point-in-time performance
|
||||||
|
- `AttributionBreakdown` record - P&L attribution
|
||||||
|
- `AnalyticsPeriod` enum - Daily/Weekly/Monthly/AllTime
|
||||||
|
|
||||||
|
**TradeRecord:**
|
||||||
|
```csharp
|
||||||
|
public record TradeRecord(
|
||||||
|
string TradeId,
|
||||||
|
string Symbol,
|
||||||
|
string StrategyName,
|
||||||
|
DateTime EntryTime,
|
||||||
|
DateTime? ExitTime,
|
||||||
|
OrderSide Side,
|
||||||
|
int Quantity,
|
||||||
|
double EntryPrice,
|
||||||
|
double? ExitPrice,
|
||||||
|
double RealizedPnL,
|
||||||
|
double UnrealizedPnL,
|
||||||
|
TradeGrade Grade,
|
||||||
|
double ConfluenceScore,
|
||||||
|
RiskMode RiskMode,
|
||||||
|
VolatilityRegime VolatilityRegime,
|
||||||
|
TrendRegime TrendRegime,
|
||||||
|
int StopTicks,
|
||||||
|
int TargetTicks,
|
||||||
|
double RMultiple,
|
||||||
|
TimeSpan Duration,
|
||||||
|
Dictionary<string, object> Metadata
|
||||||
|
);
|
||||||
|
```
|
||||||
|
|
||||||
|
**TradeMetrics:**
|
||||||
|
```csharp
|
||||||
|
public record TradeMetrics(
|
||||||
|
string TradeId,
|
||||||
|
double PnL,
|
||||||
|
double RMultiple,
|
||||||
|
double MAE, // Maximum Adverse Excursion
|
||||||
|
double MFE, // Maximum Favorable Excursion
|
||||||
|
double Slippage,
|
||||||
|
double Commission,
|
||||||
|
double NetPnL,
|
||||||
|
bool IsWinner,
|
||||||
|
TimeSpan HoldTime,
|
||||||
|
double ROI, // Return on Investment
|
||||||
|
Dictionary<string, object> CustomMetrics
|
||||||
|
);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task A2: Create TradeRecorder.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/TradeRecorder.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Record complete trade lifecycle
|
||||||
|
- Track entry, exit, fills, modifications
|
||||||
|
- Calculate trade metrics (MAE, MFE, R-multiple)
|
||||||
|
- Thread-safe trade storage
|
||||||
|
- Query interface for historical trades
|
||||||
|
|
||||||
|
**Key Features:**
|
||||||
|
- Real-time trade tracking
|
||||||
|
- Automatic metric calculation
|
||||||
|
- Historical trade database (in-memory)
|
||||||
|
- Export to CSV/JSON
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public void RecordEntry(string tradeId, StrategyIntent intent, OrderFill fill, ConfluenceScore score, RiskMode mode);
|
||||||
|
public void RecordExit(string tradeId, OrderFill fill);
|
||||||
|
public void RecordPartialFill(string tradeId, OrderFill fill);
|
||||||
|
public TradeRecord GetTrade(string tradeId);
|
||||||
|
public List<TradeRecord> GetTrades(DateTime start, DateTime end);
|
||||||
|
public List<TradeRecord> GetTradesByGrade(TradeGrade grade);
|
||||||
|
public List<TradeRecord> GetTradesByStrategy(string strategyName);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task A3: Create PerformanceCalculator.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/PerformanceCalculator.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Calculate performance metrics
|
||||||
|
- Win rate, profit factor, expectancy
|
||||||
|
- Sharpe ratio, Sortino ratio
|
||||||
|
- Maximum drawdown, recovery factor
|
||||||
|
- Risk-adjusted returns
|
||||||
|
|
||||||
|
**Performance Metrics:**
|
||||||
|
```csharp
|
||||||
|
Total Trades
|
||||||
|
Win Rate = Wins / Total
|
||||||
|
Loss Rate = Losses / Total
|
||||||
|
Average Win = Sum(Winning Trades) / Wins
|
||||||
|
Average Loss = Sum(Losing Trades) / Losses
|
||||||
|
Profit Factor = Gross Profit / Gross Loss
|
||||||
|
Expectancy = (Win% × AvgWin) - (Loss% × AvgLoss)
|
||||||
|
|
||||||
|
Sharpe Ratio = (Mean Return - Risk Free Rate) / Std Dev Returns
|
||||||
|
Sortino Ratio = (Mean Return - Risk Free Rate) / Downside Dev
|
||||||
|
Max Drawdown = Max(Peak - Trough) / Peak
|
||||||
|
Recovery Factor = Net Profit / Max Drawdown
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public PerformanceMetrics Calculate(List<TradeRecord> trades);
|
||||||
|
public double CalculateWinRate(List<TradeRecord> trades);
|
||||||
|
public double CalculateProfitFactor(List<TradeRecord> trades);
|
||||||
|
public double CalculateExpectancy(List<TradeRecord> trades);
|
||||||
|
public double CalculateSharpeRatio(List<TradeRecord> trades, double riskFreeRate);
|
||||||
|
public double CalculateMaxDrawdown(List<TradeRecord> trades);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Phase B: P&L Attribution (60 minutes)
|
||||||
|
|
||||||
|
### Task B1: Create AttributionModels.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/AttributionModels.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- `AttributionDimension` enum - Strategy/Grade/Regime/Time
|
||||||
|
- `AttributionSlice` record - P&L by dimension
|
||||||
|
- `AttributionReport` record - Complete attribution
|
||||||
|
- `ContributionAnalysis` record - Factor contributions
|
||||||
|
|
||||||
|
**AttributionSlice:**
|
||||||
|
```csharp
|
||||||
|
public record AttributionSlice(
|
||||||
|
string DimensionName,
|
||||||
|
string DimensionValue,
|
||||||
|
double TotalPnL,
|
||||||
|
double AvgPnL,
|
||||||
|
int TradeCount,
|
||||||
|
double WinRate,
|
||||||
|
double ProfitFactor,
|
||||||
|
double Contribution // % of total P&L
|
||||||
|
);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task B2: Create PnLAttributor.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/PnLAttributor.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Attribute P&L by strategy
|
||||||
|
- Attribute P&L by trade grade
|
||||||
|
- Attribute P&L by regime (volatility/trend)
|
||||||
|
- Attribute P&L by time of day
|
||||||
|
- Multi-dimensional attribution
|
||||||
|
|
||||||
|
**Attribution Examples:**
|
||||||
|
|
||||||
|
**By Grade:**
|
||||||
|
```
|
||||||
|
A+ Trades: $2,500 (50% of total, 10 trades, 80% win rate)
|
||||||
|
A Trades: $1,200 (24% of total, 15 trades, 70% win rate)
|
||||||
|
B Trades: $800 (16% of total, 20 trades, 60% win rate)
|
||||||
|
C Trades: $500 (10% of total, 25 trades, 52% win rate)
|
||||||
|
D Trades: -$1,000 (rejected most, 5 taken, 20% win rate)
|
||||||
|
```
|
||||||
|
|
||||||
|
**By Regime:**
|
||||||
|
```
|
||||||
|
Low Vol Trending: $3,000 (60%)
|
||||||
|
Normal Vol Trend: $1,500 (30%)
|
||||||
|
High Vol Range: -$500 (-10%)
|
||||||
|
Extreme Vol: $0 (no trades taken)
|
||||||
|
```
|
||||||
|
|
||||||
|
**By Time:**
|
||||||
|
```
|
||||||
|
First Hour (9:30-10:30): $2,000 (40%)
|
||||||
|
Mid-Day (10:30-14:00): $500 (10%)
|
||||||
|
Last Hour (15:00-16:00): $2,500 (50%)
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public AttributionReport AttributeByGrade(List<TradeRecord> trades);
|
||||||
|
public AttributionReport AttributeByRegime(List<TradeRecord> trades);
|
||||||
|
public AttributionReport AttributeByStrategy(List<TradeRecord> trades);
|
||||||
|
public AttributionReport AttributeByTimeOfDay(List<TradeRecord> trades);
|
||||||
|
public AttributionReport AttributeMultiDimensional(List<TradeRecord> trades, List<AttributionDimension> dimensions);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task B3: Create DrawdownAnalyzer.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/DrawdownAnalyzer.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Track equity curve
|
||||||
|
- Identify drawdown periods
|
||||||
|
- Calculate drawdown metrics
|
||||||
|
- Attribute drawdowns to causes
|
||||||
|
- Recovery time analysis
|
||||||
|
|
||||||
|
**Drawdown Metrics:**
|
||||||
|
```csharp
|
||||||
|
Max Drawdown Amount
|
||||||
|
Max Drawdown %
|
||||||
|
Current Drawdown
|
||||||
|
Average Drawdown
|
||||||
|
Number of Drawdowns
|
||||||
|
Longest Drawdown Duration
|
||||||
|
Average Recovery Time
|
||||||
|
Drawdown Frequency
|
||||||
|
Underwater Periods
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public DrawdownReport Analyze(List<TradeRecord> trades);
|
||||||
|
public List<DrawdownPeriod> IdentifyDrawdowns(List<TradeRecord> trades);
|
||||||
|
public DrawdownAttribution AttributeDrawdown(DrawdownPeriod period);
|
||||||
|
public double CalculateRecoveryTime(DrawdownPeriod period);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Phase C: Grade & Regime Analysis (60 minutes)
|
||||||
|
|
||||||
|
### Task C1: Create GradePerformanceAnalyzer.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/GradePerformanceAnalyzer.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Performance metrics by grade
|
||||||
|
- Grade accuracy analysis
|
||||||
|
- Optimal grade thresholds
|
||||||
|
- Grade distribution analysis
|
||||||
|
|
||||||
|
**Grade Performance Report:**
|
||||||
|
```csharp
|
||||||
|
A+ Trades:
|
||||||
|
Count: 25
|
||||||
|
Win Rate: 84%
|
||||||
|
Avg P&L: $250
|
||||||
|
Profit Factor: 4.2
|
||||||
|
Expectancy: $210
|
||||||
|
Total P&L: $5,250
|
||||||
|
% of Total: 52%
|
||||||
|
|
||||||
|
Grade Accuracy:
|
||||||
|
A+ predictions: 84% actually profitable
|
||||||
|
A predictions: 72% actually profitable
|
||||||
|
B predictions: 61% actually profitable
|
||||||
|
C predictions: 48% actually profitable
|
||||||
|
|
||||||
|
Optimal Threshold:
|
||||||
|
Current: Accept B+ and above
|
||||||
|
Suggested: Accept A- and above (based on expectancy)
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public GradePerformanceReport AnalyzeByGrade(List<TradeRecord> trades);
|
||||||
|
public double CalculateGradeAccuracy(TradeGrade grade, List<TradeRecord> trades);
|
||||||
|
public TradeGrade FindOptimalThreshold(List<TradeRecord> trades);
|
||||||
|
public Dictionary<TradeGrade, PerformanceMetrics> GetMetricsByGrade(List<TradeRecord> trades);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task C2: Create RegimePerformanceAnalyzer.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/RegimePerformanceAnalyzer.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Performance by volatility regime
|
||||||
|
- Performance by trend regime
|
||||||
|
- Combined regime analysis
|
||||||
|
- Regime transition impact
|
||||||
|
|
||||||
|
**Regime Performance:**
|
||||||
|
```csharp
|
||||||
|
Low Volatility:
|
||||||
|
Uptrend: $3,000 (15 trades, 73% win rate)
|
||||||
|
Range: $500 (8 trades, 50% win rate)
|
||||||
|
Downtrend: -$200 (5 trades, 40% win rate)
|
||||||
|
|
||||||
|
Normal Volatility:
|
||||||
|
Uptrend: $2,500 (20 trades, 65% win rate)
|
||||||
|
Range: $0 (12 trades, 50% win rate)
|
||||||
|
Downtrend: -$500 (7 trades, 29% win rate)
|
||||||
|
|
||||||
|
High Volatility:
|
||||||
|
All: -$300 (avoid trading in high vol)
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public RegimePerformanceReport AnalyzeByRegime(List<TradeRecord> trades);
|
||||||
|
public PerformanceMetrics GetPerformance(VolatilityRegime volRegime, TrendRegime trendRegime, List<TradeRecord> trades);
|
||||||
|
public List<RegimeTransitionImpact> AnalyzeTransitions(List<TradeRecord> trades);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task C3: Create ConfluenceValidator.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/ConfluenceValidator.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Validate confluence score accuracy
|
||||||
|
- Factor importance analysis
|
||||||
|
- Factor correlation to outcomes
|
||||||
|
- Recommended factor weights
|
||||||
|
|
||||||
|
**Confluence Validation:**
|
||||||
|
```csharp
|
||||||
|
Factor Performance Analysis:
|
||||||
|
|
||||||
|
ORB Validity Factor:
|
||||||
|
High (>0.8): 75% win rate, $180 avg
|
||||||
|
Medium (0.5-0.8): 58% win rate, $80 avg
|
||||||
|
Low (<0.5): 42% win rate, -$30 avg
|
||||||
|
Importance: HIGH (0.35 weight recommended)
|
||||||
|
|
||||||
|
Trend Alignment:
|
||||||
|
High: 68% win rate, $150 avg
|
||||||
|
Medium: 55% win rate, $60 avg
|
||||||
|
Low: 48% win rate, $20 avg
|
||||||
|
Importance: MEDIUM (0.25 weight recommended)
|
||||||
|
|
||||||
|
Current Weights vs Recommended:
|
||||||
|
ORB Validity: 0.25 → 0.35 (increase)
|
||||||
|
Trend: 0.20 → 0.25 (increase)
|
||||||
|
Volatility: 0.20 → 0.15 (decrease)
|
||||||
|
Timing: 0.20 → 0.15 (decrease)
|
||||||
|
Quality: 0.15 → 0.10 (decrease)
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public FactorAnalysisReport AnalyzeFactor(FactorType factor, List<TradeRecord> trades);
|
||||||
|
public Dictionary<FactorType, double> CalculateFactorImportance(List<TradeRecord> trades);
|
||||||
|
public Dictionary<FactorType, double> RecommendWeights(List<TradeRecord> trades);
|
||||||
|
public bool ValidateScore(ConfluenceScore score, TradeOutcome outcome);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Phase D: Reporting & Visualization (45 minutes)
|
||||||
|
|
||||||
|
### Task D1: Create ReportModels.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/ReportModels.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- `DailyReport` record - Daily performance summary
|
||||||
|
- `WeeklyReport` record - Weekly performance
|
||||||
|
- `MonthlyReport` record - Monthly performance
|
||||||
|
- `TradeBlotter` record - Trade log format
|
||||||
|
- `EquityCurve` record - Equity progression
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task D2: Create ReportGenerator.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/ReportGenerator.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Generate daily/weekly/monthly reports
|
||||||
|
- Trade blotter with filtering
|
||||||
|
- Equity curve data
|
||||||
|
- Performance summary
|
||||||
|
- Export to multiple formats (text, CSV, JSON)
|
||||||
|
|
||||||
|
**Report Example:**
|
||||||
|
```
|
||||||
|
=== Daily Performance Report ===
|
||||||
|
Date: 2026-02-16
|
||||||
|
|
||||||
|
Summary:
|
||||||
|
Total Trades: 8
|
||||||
|
Winning Trades: 6 (75%)
|
||||||
|
Losing Trades: 2 (25%)
|
||||||
|
Total P&L: $1,250
|
||||||
|
Average P&L: $156
|
||||||
|
Largest Win: $450
|
||||||
|
Largest Loss: -$120
|
||||||
|
|
||||||
|
Grade Distribution:
|
||||||
|
A+: 2 trades, $900 P&L
|
||||||
|
A: 3 trades, $550 P&L
|
||||||
|
B: 2 trades, $100 P&L
|
||||||
|
C: 1 trade, -$300 P&L (rejected most C grades)
|
||||||
|
|
||||||
|
Risk Mode:
|
||||||
|
Started: PCP
|
||||||
|
Ended: ECP (elevated after +$1,250)
|
||||||
|
Transitions: 1 (PCP→ECP at +$500)
|
||||||
|
|
||||||
|
Top Contributing Factor:
|
||||||
|
ORB Validity (avg 0.87 for winners)
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public DailyReport GenerateDailyReport(DateTime date, List<TradeRecord> trades);
|
||||||
|
public WeeklyReport GenerateWeeklyReport(DateTime weekStart, List<TradeRecord> trades);
|
||||||
|
public string ExportToText(Report report);
|
||||||
|
public string ExportToCsv(List<TradeRecord> trades);
|
||||||
|
public string ExportToJson(Report report);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task D3: Create TradeBlotter.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/TradeBlotter.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Filterable trade log
|
||||||
|
- Sort by any column
|
||||||
|
- Search functionality
|
||||||
|
- Export capability
|
||||||
|
- Real-time updates
|
||||||
|
|
||||||
|
**Blotter Columns:**
|
||||||
|
```
|
||||||
|
| Time | Symbol | Side | Qty | Entry | Exit | P&L | R-Mult | Grade | Regime | Duration |
|
||||||
|
|--------|--------|------|-----|-------|-------|--------|--------|-------|--------|----------|
|
||||||
|
| 10:05 | ES | Long | 3 | 4205 | 4221 | +$600 | 2.0R | A+ | LowVol | 45m |
|
||||||
|
| 10:35 | ES | Long | 2 | 4210 | 4218 | +$200 | 1.0R | A | Normal | 28m |
|
||||||
|
| 11:20 | ES | Short| 2 | 4215 | 4209 | +$150 | 0.75R | B+ | Normal | 15m |
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public List<TradeRecord> FilterByDate(DateTime start, DateTime end);
|
||||||
|
public List<TradeRecord> FilterBySymbol(string symbol);
|
||||||
|
public List<TradeRecord> FilterByGrade(TradeGrade grade);
|
||||||
|
public List<TradeRecord> FilterByPnL(double minPnL, double maxPnL);
|
||||||
|
public List<TradeRecord> SortBy(string column, SortDirection direction);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Phase E: Optimization Tools (60 minutes)
|
||||||
|
|
||||||
|
### Task E1: Create ParameterOptimizer.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/ParameterOptimizer.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Parameter sensitivity analysis
|
||||||
|
- Walk-forward optimization
|
||||||
|
- Grid search optimization
|
||||||
|
- Optimal parameter discovery
|
||||||
|
|
||||||
|
**Optimization Example:**
|
||||||
|
```csharp
|
||||||
|
Parameter: ORB Minutes (15, 30, 45, 60)
|
||||||
|
|
||||||
|
Results:
|
||||||
|
15 min: $2,500 (but high variance)
|
||||||
|
30 min: $5,200 (current - OPTIMAL)
|
||||||
|
45 min: $3,800
|
||||||
|
60 min: $1,200 (too conservative)
|
||||||
|
|
||||||
|
Recommendation: Keep at 30 minutes
|
||||||
|
|
||||||
|
Parameter: Stop Ticks (6, 8, 10, 12)
|
||||||
|
|
||||||
|
Results:
|
||||||
|
6 ticks: $3,000 (61% win rate, tight stops)
|
||||||
|
8 ticks: $5,200 (current - OPTIMAL, 68% win rate)
|
||||||
|
10 ticks: $4,800 (65% win rate, too wide)
|
||||||
|
12 ticks: $4,000 (63% win rate, too wide)
|
||||||
|
|
||||||
|
Recommendation: Keep at 8 ticks
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public OptimizationResult OptimizeParameter(string paramName, List<double> values, List<TradeRecord> trades);
|
||||||
|
public GridSearchResult GridSearch(Dictionary<string, List<double>> parameters, List<TradeRecord> trades);
|
||||||
|
public WalkForwardResult WalkForwardTest(StrategyConfig config, List<BarData> historicalData);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task E2: Create MonteCarloSimulator.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/MonteCarloSimulator.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Monte Carlo scenario generation
|
||||||
|
- Risk of ruin calculation
|
||||||
|
- Confidence intervals
|
||||||
|
- Worst-case scenario analysis
|
||||||
|
|
||||||
|
**Monte Carlo Analysis:**
|
||||||
|
```csharp
|
||||||
|
Based on 10,000 simulations of 100 trades:
|
||||||
|
|
||||||
|
Expected Return: $12,500
|
||||||
|
95% Confidence Interval: $8,000 - $18,000
|
||||||
|
Worst Case (5th percentile): $3,500
|
||||||
|
Best Case (95th percentile): $22,000
|
||||||
|
|
||||||
|
Risk of Ruin (25% drawdown): 2.3%
|
||||||
|
Risk of Ruin (50% drawdown): 0.1%
|
||||||
|
|
||||||
|
Max Drawdown Distribution:
|
||||||
|
10th percentile: 8%
|
||||||
|
25th percentile: 12%
|
||||||
|
50th percentile (median): 18%
|
||||||
|
75th percentile: 25%
|
||||||
|
90th percentile: 32%
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public MonteCarloResult Simulate(List<TradeRecord> historicalTrades, int numSimulations, int numTrades);
|
||||||
|
public double CalculateRiskOfRuin(List<TradeRecord> trades, double drawdownThreshold);
|
||||||
|
public ConfidenceInterval CalculateConfidenceInterval(MonteCarloResult result, double confidenceLevel);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task E3: Create PortfolioOptimizer.cs
|
||||||
|
**Location:** `src/NT8.Core/Analytics/PortfolioOptimizer.cs`
|
||||||
|
|
||||||
|
**Deliverables:**
|
||||||
|
- Optimal strategy allocation
|
||||||
|
- Correlation-based diversification
|
||||||
|
- Risk-parity allocation
|
||||||
|
- Sharpe-optimal portfolio
|
||||||
|
|
||||||
|
**Portfolio Optimization:**
|
||||||
|
```csharp
|
||||||
|
Current Allocation:
|
||||||
|
ORB Strategy: 100%
|
||||||
|
|
||||||
|
Optimal Allocation (if you had multiple strategies):
|
||||||
|
ORB Strategy: 60%
|
||||||
|
VWAP Bounce: 25%
|
||||||
|
Mean Reversion: 15%
|
||||||
|
|
||||||
|
Expected Results:
|
||||||
|
Current Sharpe: 1.8
|
||||||
|
Optimized Sharpe: 2.3
|
||||||
|
Correlation Benefit: 0.5 Sharpe increase
|
||||||
|
```
|
||||||
|
|
||||||
|
**Methods:**
|
||||||
|
```csharp
|
||||||
|
public AllocationResult OptimizeAllocation(List<StrategyPerformance> strategies);
|
||||||
|
public double CalculatePortfolioSharpe(Dictionary<string, double> allocation, List<StrategyPerformance> strategies);
|
||||||
|
public Dictionary<string, double> RiskParityAllocation(List<StrategyPerformance> strategies);
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Phase F: Comprehensive Testing (60 minutes)
|
||||||
|
|
||||||
|
### Task F1: TradeRecorderTests.cs
|
||||||
|
**Location:** `tests/NT8.Core.Tests/Analytics/TradeRecorderTests.cs`
|
||||||
|
|
||||||
|
**Minimum:** 15 tests
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task F2: PerformanceCalculatorTests.cs
|
||||||
|
**Location:** `tests/NT8.Core.Tests/Analytics/PerformanceCalculatorTests.cs`
|
||||||
|
|
||||||
|
**Minimum:** 20 tests
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task F3: PnLAttributorTests.cs
|
||||||
|
**Location:** `tests/NT8.Core.Tests/Analytics/PnLAttributorTests.cs`
|
||||||
|
|
||||||
|
**Minimum:** 18 tests
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task F4: GradePerformanceAnalyzerTests.cs
|
||||||
|
**Location:** `tests/NT8.Core.Tests/Analytics/GradePerformanceAnalyzerTests.cs`
|
||||||
|
|
||||||
|
**Minimum:** 15 tests
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task F5: OptimizationTests.cs
|
||||||
|
**Location:** `tests/NT8.Core.Tests/Analytics/OptimizationTests.cs`
|
||||||
|
|
||||||
|
**Minimum:** 12 tests
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task F6: Phase5IntegrationTests.cs
|
||||||
|
**Location:** `tests/NT8.Integration.Tests/Phase5IntegrationTests.cs`
|
||||||
|
|
||||||
|
**Minimum:** 10 tests
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Phase G: Verification (30 minutes)
|
||||||
|
|
||||||
|
### Task G1: Build Verification
|
||||||
|
**Command:** `.\verify-build.bat`
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
### Task G2: Documentation
|
||||||
|
- Create Phase5_Completion_Report.md
|
||||||
|
- Update API_REFERENCE.md
|
||||||
|
- Add analytics examples
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Success Criteria
|
||||||
|
|
||||||
|
### Code Quality
|
||||||
|
- ✅ C# 5.0 syntax only
|
||||||
|
- ✅ Thread-safe
|
||||||
|
- ✅ XML docs
|
||||||
|
- ✅ No breaking changes
|
||||||
|
|
||||||
|
### Testing
|
||||||
|
- ✅ >180 total tests passing
|
||||||
|
- ✅ >80% coverage
|
||||||
|
- ✅ All analytics scenarios tested
|
||||||
|
|
||||||
|
### Functionality
|
||||||
|
- ✅ Trade recording works
|
||||||
|
- ✅ Performance metrics accurate
|
||||||
|
- ✅ Attribution functional
|
||||||
|
- ✅ Reports generate correctly
|
||||||
|
- ✅ Optimization tools operational
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## File Creation Checklist
|
||||||
|
|
||||||
|
### New Files (17):
|
||||||
|
**Analytics (13):**
|
||||||
|
- [ ] `src/NT8.Core/Analytics/AnalyticsModels.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/TradeRecorder.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/PerformanceCalculator.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/AttributionModels.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/PnLAttributor.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/DrawdownAnalyzer.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/GradePerformanceAnalyzer.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/RegimePerformanceAnalyzer.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/ConfluenceValidator.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/ReportModels.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/ReportGenerator.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/TradeBlotter.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/ParameterOptimizer.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/MonteCarloSimulator.cs`
|
||||||
|
- [ ] `src/NT8.Core/Analytics/PortfolioOptimizer.cs`
|
||||||
|
|
||||||
|
**Tests (6):**
|
||||||
|
- [ ] `tests/NT8.Core.Tests/Analytics/TradeRecorderTests.cs`
|
||||||
|
- [ ] `tests/NT8.Core.Tests/Analytics/PerformanceCalculatorTests.cs`
|
||||||
|
- [ ] `tests/NT8.Core.Tests/Analytics/PnLAttributorTests.cs`
|
||||||
|
- [ ] `tests/NT8.Core.Tests/Analytics/GradePerformanceAnalyzerTests.cs`
|
||||||
|
- [ ] `tests/NT8.Core.Tests/Analytics/OptimizationTests.cs`
|
||||||
|
- [ ] `tests/NT8.Integration.Tests/Phase5IntegrationTests.cs`
|
||||||
|
|
||||||
|
**Total:** 19 new files
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Estimated Timeline
|
||||||
|
|
||||||
|
| Phase | Tasks | Time | Cumulative |
|
||||||
|
|-------|-------|------|------------|
|
||||||
|
| **A** | Trade Analytics | 45 min | 0:45 |
|
||||||
|
| **B** | P&L Attribution | 60 min | 1:45 |
|
||||||
|
| **C** | Grade/Regime Analysis | 60 min | 2:45 |
|
||||||
|
| **D** | Reporting | 45 min | 3:30 |
|
||||||
|
| **E** | Optimization | 60 min | 4:30 |
|
||||||
|
| **F** | Testing | 60 min | 5:30 |
|
||||||
|
| **G** | Verification | 30 min | 6:00 |
|
||||||
|
|
||||||
|
**Total:** 6 hours (budget 3-4 hours for Kilocode efficiency)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Ready to Start?
|
||||||
|
|
||||||
|
**Paste into Kilocode Code Mode:**
|
||||||
|
|
||||||
|
```
|
||||||
|
I'm ready to implement Phase 5: Analytics & Reporting.
|
||||||
|
|
||||||
|
Follow Phase5_Implementation_Guide.md starting with Phase A, Task A1.
|
||||||
|
|
||||||
|
CRITICAL REQUIREMENTS:
|
||||||
|
- C# 5.0 syntax ONLY
|
||||||
|
- Thread-safe with locks on shared state
|
||||||
|
- XML docs on all public members
|
||||||
|
- NO interface modifications
|
||||||
|
- NO breaking changes to Phase 1-4
|
||||||
|
|
||||||
|
File Creation Permissions:
|
||||||
|
✅ CREATE in: src/NT8.Core/Analytics/
|
||||||
|
✅ CREATE in: tests/NT8.Core.Tests/Analytics/
|
||||||
|
❌ FORBIDDEN: Any interface files, Phase 1-4 core implementations
|
||||||
|
|
||||||
|
Start with Task A1: Create AnalyticsModels.cs in src/NT8.Core/Analytics/
|
||||||
|
|
||||||
|
After each file:
|
||||||
|
1. Build (Ctrl+Shift+B)
|
||||||
|
2. Verify zero errors
|
||||||
|
3. Continue to next task
|
||||||
|
|
||||||
|
Let's begin with AnalyticsModels.cs!
|
||||||
|
```
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**Phase 5 will complete your analytics layer!** 📊
|
||||||
@@ -1,5 +1,22 @@
|
|||||||
# AI Agent Task Breakdown for NT8 Integration
|
# AI Agent Task Breakdown for NT8 Integration
|
||||||
|
|
||||||
|
## Current Execution Status (Updated 2026-02-16)
|
||||||
|
|
||||||
|
- [x] Task 1: Base NT8 Strategy Wrapper completed
|
||||||
|
- [x] Task 2: NT8 Data Conversion Layer completed
|
||||||
|
- [x] Task 3: Simple ORB NT8 Wrapper completed
|
||||||
|
- [x] Task 4: NT8 Order Execution Adapter completed
|
||||||
|
- [x] Task 5: NT8 Logging Adapter completed
|
||||||
|
- [x] Task 6: Deployment System completed
|
||||||
|
- [x] Task 7: Integration Tests completed
|
||||||
|
|
||||||
|
### Recent Validation Snapshot
|
||||||
|
|
||||||
|
- [x] [`verify-build.bat`](verify-build.bat) passing
|
||||||
|
- [x] Integration tests passing
|
||||||
|
- [x] Core tests passing
|
||||||
|
- [x] Performance tests passing
|
||||||
|
|
||||||
## Phase 1A Tasks (Priority Order)
|
## Phase 1A Tasks (Priority Order)
|
||||||
|
|
||||||
### Task 1: Create Base NT8 Strategy Wrapper ⭐ CRITICAL
|
### Task 1: Create Base NT8 Strategy Wrapper ⭐ CRITICAL
|
||||||
|
|||||||
124
docs/Phase5_Completion_Report.md
Normal file
124
docs/Phase5_Completion_Report.md
Normal file
@@ -0,0 +1,124 @@
|
|||||||
|
# Phase 5 Completion Report - Analytics & Reporting
|
||||||
|
|
||||||
|
**Project:** NT8 SDK
|
||||||
|
**Phase:** 5 - Analytics & Reporting
|
||||||
|
**Completion Date:** 2026-02-16
|
||||||
|
**Status:** Completed
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Scope Delivered
|
||||||
|
|
||||||
|
Phase 5 analytics deliverables were implemented across the analytics module and test projects.
|
||||||
|
|
||||||
|
### Analytics Layer
|
||||||
|
|
||||||
|
- `src/NT8.Core/Analytics/AnalyticsModels.cs`
|
||||||
|
- `src/NT8.Core/Analytics/TradeRecorder.cs`
|
||||||
|
- `src/NT8.Core/Analytics/PerformanceCalculator.cs`
|
||||||
|
- `src/NT8.Core/Analytics/AttributionModels.cs`
|
||||||
|
- `src/NT8.Core/Analytics/PnLAttributor.cs`
|
||||||
|
- `src/NT8.Core/Analytics/DrawdownAnalyzer.cs`
|
||||||
|
- `src/NT8.Core/Analytics/GradePerformanceAnalyzer.cs`
|
||||||
|
- `src/NT8.Core/Analytics/RegimePerformanceAnalyzer.cs`
|
||||||
|
- `src/NT8.Core/Analytics/ConfluenceValidator.cs`
|
||||||
|
- `src/NT8.Core/Analytics/ReportModels.cs`
|
||||||
|
- `src/NT8.Core/Analytics/ReportGenerator.cs`
|
||||||
|
- `src/NT8.Core/Analytics/TradeBlotter.cs`
|
||||||
|
- `src/NT8.Core/Analytics/ParameterOptimizer.cs`
|
||||||
|
- `src/NT8.Core/Analytics/MonteCarloSimulator.cs`
|
||||||
|
- `src/NT8.Core/Analytics/PortfolioOptimizer.cs`
|
||||||
|
|
||||||
|
### Test Coverage
|
||||||
|
|
||||||
|
- `tests/NT8.Core.Tests/Analytics/TradeRecorderTests.cs` (15 tests)
|
||||||
|
- `tests/NT8.Core.Tests/Analytics/PerformanceCalculatorTests.cs` (20 tests)
|
||||||
|
- `tests/NT8.Core.Tests/Analytics/PnLAttributorTests.cs` (18 tests)
|
||||||
|
- `tests/NT8.Core.Tests/Analytics/GradePerformanceAnalyzerTests.cs` (15 tests)
|
||||||
|
- `tests/NT8.Core.Tests/Analytics/OptimizationTests.cs` (12 tests)
|
||||||
|
- `tests/NT8.Integration.Tests/Phase5IntegrationTests.cs` (10 tests)
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Functional Outcomes
|
||||||
|
|
||||||
|
### Trade Lifecycle Analytics
|
||||||
|
|
||||||
|
- Full entry/exit/partial-fill capture implemented in `TradeRecorder`.
|
||||||
|
- Derived metrics include PnL, R-multiple, MAE/MFE approximations, hold time, and normalized result structures.
|
||||||
|
- Thread-safe in-memory storage implemented via lock-protected collections.
|
||||||
|
|
||||||
|
### Performance Measurement
|
||||||
|
|
||||||
|
- Aggregate metrics implemented in `PerformanceCalculator`:
|
||||||
|
- Win/loss rates
|
||||||
|
- Profit factor
|
||||||
|
- Expectancy
|
||||||
|
- Sharpe ratio
|
||||||
|
- Sortino ratio
|
||||||
|
- Maximum drawdown
|
||||||
|
|
||||||
|
### Attribution & Drawdown
|
||||||
|
|
||||||
|
- Multi-axis attribution implemented in `PnLAttributor`:
|
||||||
|
- Grade
|
||||||
|
- Strategy
|
||||||
|
- Regime
|
||||||
|
- Time-of-day
|
||||||
|
- Multi-dimensional breakdowns
|
||||||
|
- Drawdown analysis implemented in `DrawdownAnalyzer` with period detection and recovery metrics.
|
||||||
|
|
||||||
|
### Grade/Regime/Confluence Insights
|
||||||
|
|
||||||
|
- Grade-level edge and threshold analysis implemented in `GradePerformanceAnalyzer`.
|
||||||
|
- Regime segmentation and transition analysis implemented in `RegimePerformanceAnalyzer`.
|
||||||
|
- Confluence factor validation, weighting recommendations, and score validation implemented in `ConfluenceValidator`.
|
||||||
|
|
||||||
|
### Reporting & Export
|
||||||
|
|
||||||
|
- Daily/weekly/monthly reporting models and generation in `ReportModels` and `ReportGenerator`.
|
||||||
|
- Export support added for text/CSV/JSON.
|
||||||
|
- Real-time filter/sort trade ledger behavior implemented in `TradeBlotter`.
|
||||||
|
|
||||||
|
### Optimization Tooling
|
||||||
|
|
||||||
|
- Parameter sensitivity, grid-search, and walk-forward scaffolding in `ParameterOptimizer`.
|
||||||
|
- Monte Carlo simulation, confidence intervals, and risk-of-ruin calculations in `MonteCarloSimulator`.
|
||||||
|
- Allocation heuristics and portfolio-level Sharpe estimation in `PortfolioOptimizer`.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Verification
|
||||||
|
|
||||||
|
Build and test verification was executed with:
|
||||||
|
|
||||||
|
```bat
|
||||||
|
.\verify-build.bat
|
||||||
|
```
|
||||||
|
|
||||||
|
Observed result:
|
||||||
|
|
||||||
|
- Build succeeded for all projects.
|
||||||
|
- Test suites passed, including analytics additions.
|
||||||
|
- Existing warnings (CS1998 in legacy mock/test files) remain unchanged from prior baseline.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Compliance Notes
|
||||||
|
|
||||||
|
- Public analytics APIs documented.
|
||||||
|
- No interface signatures modified.
|
||||||
|
- New implementation isolated to analytics scope and analytics test scope.
|
||||||
|
- Thread-safety patterns applied to shared mutable analytics state.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Known Follow-Up Opportunities
|
||||||
|
|
||||||
|
- Tighten MAE/MFE calculations with tick-level excursions when full intratrade path data is available.
|
||||||
|
- Expand walk-forward optimizer to support richer objective functions and validation windows.
|
||||||
|
- Add richer portfolio covariance modeling for larger strategy sets.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
**Phase 5 is complete and verified.**
|
||||||
@@ -1,4 +1,5 @@
|
|||||||
using System;
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
using NT8.Core.Common.Interfaces;
|
using NT8.Core.Common.Interfaces;
|
||||||
using NT8.Core.Common.Models;
|
using NT8.Core.Common.Models;
|
||||||
using NT8.Core.Risk;
|
using NT8.Core.Risk;
|
||||||
@@ -12,9 +13,11 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public class NT8Adapter : INT8Adapter
|
public class NT8Adapter : INT8Adapter
|
||||||
{
|
{
|
||||||
|
private readonly object _lock = new object();
|
||||||
private readonly NT8DataAdapter _dataAdapter;
|
private readonly NT8DataAdapter _dataAdapter;
|
||||||
private readonly NT8OrderAdapter _orderAdapter;
|
private readonly NT8OrderAdapter _orderAdapter;
|
||||||
private readonly NT8LoggingAdapter _loggingAdapter;
|
private readonly NT8LoggingAdapter _loggingAdapter;
|
||||||
|
private readonly List<NT8OrderExecutionRecord> _executionHistory;
|
||||||
private IRiskManager _riskManager;
|
private IRiskManager _riskManager;
|
||||||
private IPositionSizer _positionSizer;
|
private IPositionSizer _positionSizer;
|
||||||
|
|
||||||
@@ -26,6 +29,7 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
_dataAdapter = new NT8DataAdapter();
|
_dataAdapter = new NT8DataAdapter();
|
||||||
_orderAdapter = new NT8OrderAdapter();
|
_orderAdapter = new NT8OrderAdapter();
|
||||||
_loggingAdapter = new NT8LoggingAdapter();
|
_loggingAdapter = new NT8LoggingAdapter();
|
||||||
|
_executionHistory = new List<NT8OrderExecutionRecord>();
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -67,10 +71,32 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public void ExecuteIntent(StrategyIntent intent, SizingResult sizing)
|
public void ExecuteIntent(StrategyIntent intent, SizingResult sizing)
|
||||||
{
|
{
|
||||||
|
if (intent == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException("intent");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sizing == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException("sizing");
|
||||||
|
}
|
||||||
|
|
||||||
// In a full implementation, this would execute the order through NT8
|
// In a full implementation, this would execute the order through NT8
|
||||||
// For now, we'll just log what would be executed
|
// For now, we'll just log what would be executed
|
||||||
_loggingAdapter.LogInformation("Executing intent: {0} {1} contracts at {2} ticks stop",
|
_loggingAdapter.LogInformation("Executing intent: {0} {1} contracts at {2} ticks stop",
|
||||||
intent.Side, sizing.Contracts, intent.StopTicks);
|
intent.Side, sizing.Contracts, intent.StopTicks);
|
||||||
|
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
_executionHistory.Add(new NT8OrderExecutionRecord(
|
||||||
|
intent.Symbol,
|
||||||
|
intent.Side,
|
||||||
|
intent.EntryType,
|
||||||
|
sizing.Contracts,
|
||||||
|
intent.StopTicks,
|
||||||
|
intent.TargetTicks,
|
||||||
|
DateTime.UtcNow));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -88,5 +114,17 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
{
|
{
|
||||||
_orderAdapter.OnExecutionUpdate(executionId, orderId, price, quantity, marketPosition, time);
|
_orderAdapter.OnExecutionUpdate(executionId, orderId, price, quantity, marketPosition, time);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets execution history captured by the order adapter.
|
||||||
|
/// </summary>
|
||||||
|
/// <returns>Execution history snapshot.</returns>
|
||||||
|
public IList<NT8OrderExecutionRecord> GetExecutionHistory()
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
return new List<NT8OrderExecutionRecord>(_executionHistory);
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -13,7 +13,7 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public BarData ConvertToSdkBar(string symbol, DateTime time, double open, double high, double low, double close, long volume, int barSizeMinutes)
|
public BarData ConvertToSdkBar(string symbol, DateTime time, double open, double high, double low, double close, long volume, int barSizeMinutes)
|
||||||
{
|
{
|
||||||
return new BarData(symbol, time, open, high, low, close, volume, TimeSpan.FromMinutes(barSizeMinutes));
|
return NT8DataConverter.ConvertBar(symbol, time, open, high, low, close, volume, barSizeMinutes);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -21,7 +21,7 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public AccountInfo ConvertToSdkAccount(double equity, double buyingPower, double dailyPnL, double maxDrawdown, DateTime lastUpdate)
|
public AccountInfo ConvertToSdkAccount(double equity, double buyingPower, double dailyPnL, double maxDrawdown, DateTime lastUpdate)
|
||||||
{
|
{
|
||||||
return new AccountInfo(equity, buyingPower, dailyPnL, maxDrawdown, lastUpdate);
|
return NT8DataConverter.ConvertAccount(equity, buyingPower, dailyPnL, maxDrawdown, lastUpdate);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -29,7 +29,7 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public Position ConvertToSdkPosition(string symbol, int quantity, double averagePrice, double unrealizedPnL, double realizedPnL, DateTime lastUpdate)
|
public Position ConvertToSdkPosition(string symbol, int quantity, double averagePrice, double unrealizedPnL, double realizedPnL, DateTime lastUpdate)
|
||||||
{
|
{
|
||||||
return new Position(symbol, quantity, averagePrice, unrealizedPnL, realizedPnL, lastUpdate);
|
return NT8DataConverter.ConvertPosition(symbol, quantity, averagePrice, unrealizedPnL, realizedPnL, lastUpdate);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -37,7 +37,7 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public MarketSession ConvertToSdkSession(DateTime sessionStart, DateTime sessionEnd, bool isRth, string sessionName)
|
public MarketSession ConvertToSdkSession(DateTime sessionStart, DateTime sessionEnd, bool isRth, string sessionName)
|
||||||
{
|
{
|
||||||
return new MarketSession(sessionStart, sessionEnd, isRth, sessionName);
|
return NT8DataConverter.ConvertSession(sessionStart, sessionEnd, isRth, sessionName);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -45,7 +45,7 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public StrategyContext ConvertToSdkContext(string symbol, DateTime currentTime, Position currentPosition, AccountInfo account, MarketSession session, System.Collections.Generic.Dictionary<string, object> customData)
|
public StrategyContext ConvertToSdkContext(string symbol, DateTime currentTime, Position currentPosition, AccountInfo account, MarketSession session, System.Collections.Generic.Dictionary<string, object> customData)
|
||||||
{
|
{
|
||||||
return new StrategyContext(symbol, currentTime, currentPosition, account, session, customData);
|
return NT8DataConverter.ConvertContext(symbol, currentTime, currentPosition, account, session, customData);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,4 +1,5 @@
|
|||||||
using System;
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
using NT8.Core.Common.Models;
|
using NT8.Core.Common.Models;
|
||||||
using NT8.Core.Risk;
|
using NT8.Core.Risk;
|
||||||
using NT8.Core.Sizing;
|
using NT8.Core.Sizing;
|
||||||
@@ -10,16 +11,43 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public class NT8OrderAdapter
|
public class NT8OrderAdapter
|
||||||
{
|
{
|
||||||
|
private readonly object _lock = new object();
|
||||||
private IRiskManager _riskManager;
|
private IRiskManager _riskManager;
|
||||||
private IPositionSizer _positionSizer;
|
private IPositionSizer _positionSizer;
|
||||||
|
private readonly List<NT8OrderExecutionRecord> _executionHistory;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Constructor for NT8OrderAdapter.
|
||||||
|
/// </summary>
|
||||||
|
public NT8OrderAdapter()
|
||||||
|
{
|
||||||
|
_executionHistory = new List<NT8OrderExecutionRecord>();
|
||||||
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Initialize the order adapter with required components
|
/// Initialize the order adapter with required components
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public void Initialize(IRiskManager riskManager, IPositionSizer positionSizer)
|
public void Initialize(IRiskManager riskManager, IPositionSizer positionSizer)
|
||||||
{
|
{
|
||||||
_riskManager = riskManager;
|
if (riskManager == null)
|
||||||
_positionSizer = positionSizer;
|
{
|
||||||
|
throw new ArgumentNullException("riskManager");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (positionSizer == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException("positionSizer");
|
||||||
|
}
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
_riskManager = riskManager;
|
||||||
|
_positionSizer = positionSizer;
|
||||||
|
}
|
||||||
|
catch (Exception)
|
||||||
|
{
|
||||||
|
throw;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -27,31 +55,70 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public void ExecuteIntent(StrategyIntent intent, StrategyContext context, StrategyConfig config)
|
public void ExecuteIntent(StrategyIntent intent, StrategyContext context, StrategyConfig config)
|
||||||
{
|
{
|
||||||
|
if (intent == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException("intent");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (context == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException("context");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (config == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException("config");
|
||||||
|
}
|
||||||
|
|
||||||
if (_riskManager == null || _positionSizer == null)
|
if (_riskManager == null || _positionSizer == null)
|
||||||
{
|
{
|
||||||
throw new InvalidOperationException("Adapter not initialized. Call Initialize() first.");
|
throw new InvalidOperationException("Adapter not initialized. Call Initialize() first.");
|
||||||
}
|
}
|
||||||
|
|
||||||
// Validate the intent through risk management
|
try
|
||||||
var riskDecision = _riskManager.ValidateOrder(intent, context, config.RiskSettings);
|
|
||||||
if (!riskDecision.Allow)
|
|
||||||
{
|
{
|
||||||
// Log rejection and return
|
// Validate the intent through risk management
|
||||||
// In a real implementation, we would use a proper logging system
|
var riskDecision = _riskManager.ValidateOrder(intent, context, config.RiskSettings);
|
||||||
return;
|
if (!riskDecision.Allow)
|
||||||
}
|
{
|
||||||
|
// Risk rejected the order flow.
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
// Calculate position size
|
// Calculate position size
|
||||||
var sizingResult = _positionSizer.CalculateSize(intent, context, config.SizingSettings);
|
var sizingResult = _positionSizer.CalculateSize(intent, context, config.SizingSettings);
|
||||||
if (sizingResult.Contracts <= 0)
|
if (sizingResult.Contracts <= 0)
|
||||||
|
{
|
||||||
|
// No tradable size produced.
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// In a real implementation, this would call NT8's order execution methods.
|
||||||
|
ExecuteInNT8(intent, sizingResult);
|
||||||
|
}
|
||||||
|
catch (Exception)
|
||||||
{
|
{
|
||||||
// Log that no position size was calculated
|
throw;
|
||||||
return;
|
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// In a real implementation, this would call NT8's order execution methods
|
/// <summary>
|
||||||
// For now, we'll just log what would be executed
|
/// Gets a snapshot of executions submitted through this adapter.
|
||||||
ExecuteInNT8(intent, sizingResult);
|
/// </summary>
|
||||||
|
/// <returns>Execution history snapshot.</returns>
|
||||||
|
public IList<NT8OrderExecutionRecord> GetExecutionHistory()
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
return new List<NT8OrderExecutionRecord>(_executionHistory);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception)
|
||||||
|
{
|
||||||
|
throw;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -59,10 +126,32 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
private void ExecuteInNT8(StrategyIntent intent, SizingResult sizing)
|
private void ExecuteInNT8(StrategyIntent intent, SizingResult sizing)
|
||||||
{
|
{
|
||||||
|
if (intent == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException("intent");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sizing == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException("sizing");
|
||||||
|
}
|
||||||
|
|
||||||
// This is where the actual NT8 order execution would happen
|
// This is where the actual NT8 order execution would happen
|
||||||
// In a real implementation, this would call NT8's EnterLong/EnterShort methods
|
// In a real implementation, this would call NT8's EnterLong/EnterShort methods
|
||||||
// along with SetStopLoss, SetProfitTarget, etc.
|
// along with SetStopLoss, SetProfitTarget, etc.
|
||||||
|
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
_executionHistory.Add(new NT8OrderExecutionRecord(
|
||||||
|
intent.Symbol,
|
||||||
|
intent.Side,
|
||||||
|
intent.EntryType,
|
||||||
|
sizing.Contracts,
|
||||||
|
intent.StopTicks,
|
||||||
|
intent.TargetTicks,
|
||||||
|
DateTime.UtcNow));
|
||||||
|
}
|
||||||
|
|
||||||
// Example of what this might look like in NT8:
|
// Example of what this might look like in NT8:
|
||||||
/*
|
/*
|
||||||
if (intent.Side == OrderSide.Buy)
|
if (intent.Side == OrderSide.Buy)
|
||||||
@@ -91,11 +180,22 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public void OnOrderUpdate(string orderId, double limitPrice, double stopPrice, int quantity, int filled, double averageFillPrice, string orderState, DateTime time, string errorCode, string nativeError)
|
public void OnOrderUpdate(string orderId, double limitPrice, double stopPrice, int quantity, int filled, double averageFillPrice, string orderState, DateTime time, string errorCode, string nativeError)
|
||||||
{
|
{
|
||||||
// Pass order updates to risk manager for tracking
|
if (string.IsNullOrWhiteSpace(orderId))
|
||||||
if (_riskManager != null)
|
|
||||||
{
|
{
|
||||||
// In a real implementation, we would convert NT8 order data to SDK format
|
throw new ArgumentException("orderId");
|
||||||
// and pass it to the risk manager
|
}
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
// Pass order updates to risk manager for tracking.
|
||||||
|
if (_riskManager != null)
|
||||||
|
{
|
||||||
|
// In a real implementation, convert NT8 order data to SDK models.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception)
|
||||||
|
{
|
||||||
|
throw;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -104,12 +204,83 @@ namespace NT8.Adapters.NinjaTrader
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public void OnExecutionUpdate(string executionId, string orderId, double price, int quantity, string marketPosition, DateTime time)
|
public void OnExecutionUpdate(string executionId, string orderId, double price, int quantity, string marketPosition, DateTime time)
|
||||||
{
|
{
|
||||||
// Pass execution updates to risk manager for P&L tracking
|
if (string.IsNullOrWhiteSpace(executionId))
|
||||||
if (_riskManager != null)
|
|
||||||
{
|
{
|
||||||
// In a real implementation, we would convert NT8 execution data to SDK format
|
throw new ArgumentException("executionId");
|
||||||
// and pass it to the risk manager
|
}
|
||||||
|
|
||||||
|
if (string.IsNullOrWhiteSpace(orderId))
|
||||||
|
{
|
||||||
|
throw new ArgumentException("orderId");
|
||||||
|
}
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
// Pass execution updates to risk manager for P&L tracking.
|
||||||
|
if (_riskManager != null)
|
||||||
|
{
|
||||||
|
// In a real implementation, convert NT8 execution data to SDK models.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception)
|
||||||
|
{
|
||||||
|
throw;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Execution record captured by NT8OrderAdapter for diagnostics and tests.
|
||||||
|
/// </summary>
|
||||||
|
public class NT8OrderExecutionRecord
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Trading symbol.
|
||||||
|
/// </summary>
|
||||||
|
public string Symbol { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Order side.
|
||||||
|
/// </summary>
|
||||||
|
public OrderSide Side { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Entry order type.
|
||||||
|
/// </summary>
|
||||||
|
public OrderType EntryType { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Executed contract quantity.
|
||||||
|
/// </summary>
|
||||||
|
public int Contracts { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Stop-loss distance in ticks.
|
||||||
|
/// </summary>
|
||||||
|
public int StopTicks { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Profit target distance in ticks.
|
||||||
|
/// </summary>
|
||||||
|
public int? TargetTicks { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Timestamp when the execution was recorded.
|
||||||
|
/// </summary>
|
||||||
|
public DateTime Timestamp { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Constructor for NT8OrderExecutionRecord.
|
||||||
|
/// </summary>
|
||||||
|
public NT8OrderExecutionRecord(string symbol, OrderSide side, OrderType entryType, int contracts, int stopTicks, int? targetTicks, DateTime timestamp)
|
||||||
|
{
|
||||||
|
Symbol = symbol;
|
||||||
|
Side = side;
|
||||||
|
EntryType = entryType;
|
||||||
|
Contracts = contracts;
|
||||||
|
StopTicks = stopTicks;
|
||||||
|
TargetTicks = targetTicks;
|
||||||
|
Timestamp = timestamp;
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -2,6 +2,7 @@ using System;
|
|||||||
using System.Collections.Generic;
|
using System.Collections.Generic;
|
||||||
using NT8.Core.Common.Interfaces;
|
using NT8.Core.Common.Interfaces;
|
||||||
using NT8.Core.Common.Models;
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Logging;
|
||||||
using NT8.Core.Risk;
|
using NT8.Core.Risk;
|
||||||
using NT8.Core.Sizing;
|
using NT8.Core.Sizing;
|
||||||
using NT8.Adapters.NinjaTrader;
|
using NT8.Adapters.NinjaTrader;
|
||||||
@@ -14,6 +15,8 @@ namespace NT8.Adapters.Wrappers
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public abstract class BaseNT8StrategyWrapper
|
public abstract class BaseNT8StrategyWrapper
|
||||||
{
|
{
|
||||||
|
private readonly object _lock = new object();
|
||||||
|
|
||||||
#region SDK Components
|
#region SDK Components
|
||||||
|
|
||||||
protected IStrategy _sdkStrategy;
|
protected IStrategy _sdkStrategy;
|
||||||
@@ -21,6 +24,7 @@ namespace NT8.Adapters.Wrappers
|
|||||||
protected IPositionSizer _positionSizer;
|
protected IPositionSizer _positionSizer;
|
||||||
protected NT8Adapter _nt8Adapter;
|
protected NT8Adapter _nt8Adapter;
|
||||||
protected StrategyConfig _strategyConfig;
|
protected StrategyConfig _strategyConfig;
|
||||||
|
protected ILogger _logger;
|
||||||
|
|
||||||
#endregion
|
#endregion
|
||||||
|
|
||||||
@@ -55,8 +59,13 @@ namespace NT8.Adapters.Wrappers
|
|||||||
TargetTicks = 20;
|
TargetTicks = 20;
|
||||||
RiskAmount = 100.0;
|
RiskAmount = 100.0;
|
||||||
|
|
||||||
// Initialize SDK components
|
// Initialize SDK components with default implementations.
|
||||||
InitializeSdkComponents();
|
// Derived wrappers can replace these through InitializeSdkComponents.
|
||||||
|
_logger = new BasicLogger("BaseNT8StrategyWrapper");
|
||||||
|
_riskManager = new BasicRiskManager(_logger);
|
||||||
|
_positionSizer = new BasicPositionSizer(_logger);
|
||||||
|
|
||||||
|
InitializeSdkComponents(_riskManager, _positionSizer, _logger);
|
||||||
}
|
}
|
||||||
|
|
||||||
#endregion
|
#endregion
|
||||||
@@ -77,12 +86,38 @@ namespace NT8.Adapters.Wrappers
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public void ProcessBarUpdate(BarData barData, StrategyContext context)
|
public void ProcessBarUpdate(BarData barData, StrategyContext context)
|
||||||
{
|
{
|
||||||
// Call SDK strategy logic
|
if (barData == null)
|
||||||
var intent = _sdkStrategy.OnBar(barData, context);
|
throw new ArgumentNullException("barData");
|
||||||
if (intent != null)
|
if (context == null)
|
||||||
|
throw new ArgumentNullException("context");
|
||||||
|
|
||||||
|
try
|
||||||
{
|
{
|
||||||
// Convert SDK results to NT8 actions
|
StrategyIntent intent;
|
||||||
ExecuteIntent(intent, context);
|
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
if (_sdkStrategy == null)
|
||||||
|
{
|
||||||
|
throw new InvalidOperationException("SDK strategy has not been initialized.");
|
||||||
|
}
|
||||||
|
|
||||||
|
intent = _sdkStrategy.OnBar(barData, context);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (intent != null)
|
||||||
|
{
|
||||||
|
ExecuteIntent(intent, context);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
if (_logger != null)
|
||||||
|
{
|
||||||
|
_logger.LogError("Failed processing bar update for {0}: {1}", context.Symbol, ex.Message);
|
||||||
|
}
|
||||||
|
|
||||||
|
throw;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -93,19 +128,31 @@ namespace NT8.Adapters.Wrappers
|
|||||||
/// <summary>
|
/// <summary>
|
||||||
/// Initialize SDK components
|
/// Initialize SDK components
|
||||||
/// </summary>
|
/// </summary>
|
||||||
private void InitializeSdkComponents()
|
protected virtual void InitializeSdkComponents(IRiskManager riskManager, IPositionSizer positionSizer, ILogger logger)
|
||||||
{
|
{
|
||||||
// In a real implementation, these would be injected or properly instantiated
|
if (riskManager == null)
|
||||||
// For now, we'll create placeholder instances
|
throw new ArgumentNullException("riskManager");
|
||||||
_riskManager = null; // This would be properly instantiated
|
if (positionSizer == null)
|
||||||
_positionSizer = null; // This would be properly instantiated
|
throw new ArgumentNullException("positionSizer");
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_riskManager = riskManager;
|
||||||
|
_positionSizer = positionSizer;
|
||||||
|
_logger = logger;
|
||||||
|
|
||||||
// Create NT8 adapter
|
|
||||||
_nt8Adapter = new NT8Adapter();
|
_nt8Adapter = new NT8Adapter();
|
||||||
_nt8Adapter.Initialize(_riskManager, _positionSizer);
|
_nt8Adapter.Initialize(_riskManager, _positionSizer);
|
||||||
|
|
||||||
// Create SDK strategy
|
CreateSdkConfiguration();
|
||||||
|
|
||||||
_sdkStrategy = CreateSdkStrategy();
|
_sdkStrategy = CreateSdkStrategy();
|
||||||
|
if (_sdkStrategy == null)
|
||||||
|
throw new InvalidOperationException("CreateSdkStrategy returned null.");
|
||||||
|
|
||||||
|
_sdkStrategy.Initialize(_strategyConfig, null, _logger);
|
||||||
|
|
||||||
|
_logger.LogInformation("Base NT8 strategy wrapper initialized for symbol {0}", _strategyConfig.Symbol);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -145,13 +192,36 @@ namespace NT8.Adapters.Wrappers
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
private void ExecuteIntent(StrategyIntent intent, StrategyContext context)
|
private void ExecuteIntent(StrategyIntent intent, StrategyContext context)
|
||||||
{
|
{
|
||||||
// Calculate position size
|
if (intent == null)
|
||||||
var sizingResult = _positionSizer != null ?
|
throw new ArgumentNullException("intent");
|
||||||
_positionSizer.CalculateSize(intent, context, _strategyConfig.SizingSettings) :
|
if (context == null)
|
||||||
new SizingResult(1, RiskAmount, SizingMethod.FixedDollarRisk, new Dictionary<string, object>());
|
throw new ArgumentNullException("context");
|
||||||
|
|
||||||
// Execute through NT8 adapter
|
try
|
||||||
_nt8Adapter.ExecuteIntent(intent, sizingResult);
|
{
|
||||||
|
SizingResult sizingResult;
|
||||||
|
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
if (_positionSizer == null)
|
||||||
|
{
|
||||||
|
throw new InvalidOperationException("Position sizer has not been initialized.");
|
||||||
|
}
|
||||||
|
|
||||||
|
sizingResult = _positionSizer.CalculateSize(intent, context, _strategyConfig.SizingSettings);
|
||||||
|
}
|
||||||
|
|
||||||
|
_nt8Adapter.ExecuteIntent(intent, sizingResult);
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
if (_logger != null)
|
||||||
|
{
|
||||||
|
_logger.LogError("Failed executing intent for {0}: {1}", intent.Symbol, ex.Message);
|
||||||
|
}
|
||||||
|
|
||||||
|
throw;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#endregion
|
#endregion
|
||||||
|
|||||||
@@ -3,6 +3,7 @@ using System.Collections.Generic;
|
|||||||
using NT8.Core.Common.Interfaces;
|
using NT8.Core.Common.Interfaces;
|
||||||
using NT8.Core.Common.Models;
|
using NT8.Core.Common.Models;
|
||||||
using NT8.Core.Logging;
|
using NT8.Core.Logging;
|
||||||
|
using NT8.Adapters.NinjaTrader;
|
||||||
|
|
||||||
namespace NT8.Adapters.Wrappers
|
namespace NT8.Adapters.Wrappers
|
||||||
{
|
{
|
||||||
@@ -26,16 +27,6 @@ namespace NT8.Adapters.Wrappers
|
|||||||
|
|
||||||
#endregion
|
#endregion
|
||||||
|
|
||||||
#region Strategy State
|
|
||||||
|
|
||||||
private DateTime _openingRangeStart;
|
|
||||||
private double _openingRangeHigh;
|
|
||||||
private double _openingRangeLow;
|
|
||||||
private bool _openingRangeCalculated;
|
|
||||||
private double _rangeSize;
|
|
||||||
|
|
||||||
#endregion
|
|
||||||
|
|
||||||
#region Constructor
|
#region Constructor
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
@@ -45,19 +36,28 @@ namespace NT8.Adapters.Wrappers
|
|||||||
{
|
{
|
||||||
OpeningRangeMinutes = 30;
|
OpeningRangeMinutes = 30;
|
||||||
StdDevMultiplier = 1.0;
|
StdDevMultiplier = 1.0;
|
||||||
_openingRangeCalculated = false;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endregion
|
#endregion
|
||||||
|
|
||||||
#region Base Class Implementation
|
#region Base Class Implementation
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Exposes adapter reference for integration test assertions.
|
||||||
|
/// </summary>
|
||||||
|
public NT8Adapter GetAdapterForTesting()
|
||||||
|
{
|
||||||
|
return _nt8Adapter;
|
||||||
|
}
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Create the SDK strategy implementation
|
/// Create the SDK strategy implementation
|
||||||
/// </summary>
|
/// </summary>
|
||||||
protected override IStrategy CreateSdkStrategy()
|
protected override IStrategy CreateSdkStrategy()
|
||||||
{
|
{
|
||||||
return new SimpleORBStrategy();
|
var openingRangeMinutes = OpeningRangeMinutes > 0 ? OpeningRangeMinutes : 30;
|
||||||
|
var stdDevMultiplier = StdDevMultiplier > 0.0 ? StdDevMultiplier : 1.0;
|
||||||
|
return new SimpleORBStrategy(openingRangeMinutes, stdDevMultiplier);
|
||||||
}
|
}
|
||||||
|
|
||||||
#endregion
|
#endregion
|
||||||
@@ -69,10 +69,43 @@ namespace NT8.Adapters.Wrappers
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
private class SimpleORBStrategy : IStrategy
|
private class SimpleORBStrategy : IStrategy
|
||||||
{
|
{
|
||||||
|
private readonly int _openingRangeMinutes;
|
||||||
|
private readonly double _stdDevMultiplier;
|
||||||
|
|
||||||
|
private ILogger _logger;
|
||||||
|
private DateTime _currentSessionDate;
|
||||||
|
private DateTime _openingRangeStart;
|
||||||
|
private DateTime _openingRangeEnd;
|
||||||
|
private double _openingRangeHigh;
|
||||||
|
private double _openingRangeLow;
|
||||||
|
private bool _openingRangeReady;
|
||||||
|
private bool _tradeTaken;
|
||||||
|
|
||||||
public StrategyMetadata Metadata { get; private set; }
|
public StrategyMetadata Metadata { get; private set; }
|
||||||
|
|
||||||
public SimpleORBStrategy()
|
public SimpleORBStrategy(int openingRangeMinutes, double stdDevMultiplier)
|
||||||
{
|
{
|
||||||
|
if (openingRangeMinutes <= 0)
|
||||||
|
{
|
||||||
|
throw new ArgumentException("openingRangeMinutes");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (stdDevMultiplier <= 0.0)
|
||||||
|
{
|
||||||
|
throw new ArgumentException("stdDevMultiplier");
|
||||||
|
}
|
||||||
|
|
||||||
|
_openingRangeMinutes = openingRangeMinutes;
|
||||||
|
_stdDevMultiplier = stdDevMultiplier;
|
||||||
|
|
||||||
|
_currentSessionDate = DateTime.MinValue;
|
||||||
|
_openingRangeStart = DateTime.MinValue;
|
||||||
|
_openingRangeEnd = DateTime.MinValue;
|
||||||
|
_openingRangeHigh = Double.MinValue;
|
||||||
|
_openingRangeLow = Double.MaxValue;
|
||||||
|
_openingRangeReady = false;
|
||||||
|
_tradeTaken = false;
|
||||||
|
|
||||||
Metadata = new StrategyMetadata(
|
Metadata = new StrategyMetadata(
|
||||||
name: "Simple ORB",
|
name: "Simple ORB",
|
||||||
description: "Opening Range Breakout strategy",
|
description: "Opening Range Breakout strategy",
|
||||||
@@ -85,15 +118,90 @@ namespace NT8.Adapters.Wrappers
|
|||||||
|
|
||||||
public void Initialize(StrategyConfig config, IMarketDataProvider dataProvider, ILogger logger)
|
public void Initialize(StrategyConfig config, IMarketDataProvider dataProvider, ILogger logger)
|
||||||
{
|
{
|
||||||
// Initialize strategy with configuration
|
if (logger == null)
|
||||||
// In a real implementation, we would store references to the data provider and logger
|
{
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
}
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
_logger.LogInformation("SimpleORBStrategy initialized with OR period {0} minutes and multiplier {1:F2}", _openingRangeMinutes, _stdDevMultiplier);
|
||||||
}
|
}
|
||||||
|
|
||||||
public StrategyIntent OnBar(BarData bar, StrategyContext context)
|
public StrategyIntent OnBar(BarData bar, StrategyContext context)
|
||||||
{
|
{
|
||||||
// This is where the actual strategy logic would go
|
if (bar == null)
|
||||||
// For this example, we'll just return null to indicate no trade
|
{
|
||||||
return null;
|
throw new ArgumentNullException("bar");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (context == null)
|
||||||
|
{
|
||||||
|
throw new ArgumentNullException("context");
|
||||||
|
}
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (_currentSessionDate != context.CurrentTime.Date)
|
||||||
|
{
|
||||||
|
ResetSession(context.Session.SessionStart);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (bar.Time <= _openingRangeEnd)
|
||||||
|
{
|
||||||
|
UpdateOpeningRange(bar);
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!_openingRangeReady)
|
||||||
|
{
|
||||||
|
if (_openingRangeHigh > _openingRangeLow)
|
||||||
|
{
|
||||||
|
_openingRangeReady = true;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (_tradeTaken)
|
||||||
|
{
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
var openingRange = _openingRangeHigh - _openingRangeLow;
|
||||||
|
var volatilityBuffer = openingRange * (_stdDevMultiplier - 1.0);
|
||||||
|
if (volatilityBuffer < 0)
|
||||||
|
{
|
||||||
|
volatilityBuffer = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
var longTrigger = _openingRangeHigh + volatilityBuffer;
|
||||||
|
var shortTrigger = _openingRangeLow - volatilityBuffer;
|
||||||
|
|
||||||
|
if (bar.Close > longTrigger)
|
||||||
|
{
|
||||||
|
_tradeTaken = true;
|
||||||
|
return CreateIntent(context.Symbol, OrderSide.Buy, openingRange, bar.Close);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (bar.Close < shortTrigger)
|
||||||
|
{
|
||||||
|
_tradeTaken = true;
|
||||||
|
return CreateIntent(context.Symbol, OrderSide.Sell, openingRange, bar.Close);
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
if (_logger != null)
|
||||||
|
{
|
||||||
|
_logger.LogError("SimpleORBStrategy OnBar failed: {0}", ex.Message);
|
||||||
|
}
|
||||||
|
|
||||||
|
throw;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
public StrategyIntent OnTick(TickData tick, StrategyContext context)
|
public StrategyIntent OnTick(TickData tick, StrategyContext context)
|
||||||
@@ -104,12 +212,66 @@ namespace NT8.Adapters.Wrappers
|
|||||||
|
|
||||||
public Dictionary<string, object> GetParameters()
|
public Dictionary<string, object> GetParameters()
|
||||||
{
|
{
|
||||||
return new Dictionary<string, object>();
|
var parameters = new Dictionary<string, object>();
|
||||||
|
parameters.Add("opening_range_minutes", _openingRangeMinutes);
|
||||||
|
parameters.Add("std_dev_multiplier", _stdDevMultiplier);
|
||||||
|
return parameters;
|
||||||
}
|
}
|
||||||
|
|
||||||
public void SetParameters(Dictionary<string, object> parameters)
|
public void SetParameters(Dictionary<string, object> parameters)
|
||||||
{
|
{
|
||||||
// Set strategy parameters from configuration
|
// Parameters are constructor-bound for deterministic behavior in this wrapper.
|
||||||
|
// Method retained for interface compatibility.
|
||||||
|
}
|
||||||
|
|
||||||
|
private void ResetSession(DateTime sessionStart)
|
||||||
|
{
|
||||||
|
_currentSessionDate = sessionStart.Date;
|
||||||
|
_openingRangeStart = sessionStart;
|
||||||
|
_openingRangeEnd = sessionStart.AddMinutes(_openingRangeMinutes);
|
||||||
|
_openingRangeHigh = Double.MinValue;
|
||||||
|
_openingRangeLow = Double.MaxValue;
|
||||||
|
_openingRangeReady = false;
|
||||||
|
_tradeTaken = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void UpdateOpeningRange(BarData bar)
|
||||||
|
{
|
||||||
|
if (bar.High > _openingRangeHigh)
|
||||||
|
{
|
||||||
|
_openingRangeHigh = bar.High;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (bar.Low < _openingRangeLow)
|
||||||
|
{
|
||||||
|
_openingRangeLow = bar.Low;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private StrategyIntent CreateIntent(string symbol, OrderSide side, double openingRange, double lastPrice)
|
||||||
|
{
|
||||||
|
var metadata = new Dictionary<string, object>();
|
||||||
|
metadata.Add("orb_high", _openingRangeHigh);
|
||||||
|
metadata.Add("orb_low", _openingRangeLow);
|
||||||
|
metadata.Add("orb_range", openingRange);
|
||||||
|
metadata.Add("trigger_price", lastPrice);
|
||||||
|
metadata.Add("multiplier", _stdDevMultiplier);
|
||||||
|
|
||||||
|
if (_logger != null)
|
||||||
|
{
|
||||||
|
_logger.LogInformation("SimpleORBStrategy generated {0} intent for {1}. OR High={2:F2}, OR Low={3:F2}, Last={4:F2}", side, symbol, _openingRangeHigh, _openingRangeLow, lastPrice);
|
||||||
|
}
|
||||||
|
|
||||||
|
return new StrategyIntent(
|
||||||
|
symbol,
|
||||||
|
side,
|
||||||
|
OrderType.Market,
|
||||||
|
null,
|
||||||
|
8,
|
||||||
|
16,
|
||||||
|
0.75,
|
||||||
|
"ORB breakout signal",
|
||||||
|
metadata);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
393
src/NT8.Core/Analytics/AnalyticsModels.cs
Normal file
393
src/NT8.Core/Analytics/AnalyticsModels.cs
Normal file
@@ -0,0 +1,393 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Time period used for analytics aggregation.
|
||||||
|
/// </summary>
|
||||||
|
public enum AnalyticsPeriod
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Daily period.
|
||||||
|
/// </summary>
|
||||||
|
Daily,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Weekly period.
|
||||||
|
/// </summary>
|
||||||
|
Weekly,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Monthly period.
|
||||||
|
/// </summary>
|
||||||
|
Monthly,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Lifetime period.
|
||||||
|
/// </summary>
|
||||||
|
AllTime
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Represents one complete trade lifecycle.
|
||||||
|
/// </summary>
|
||||||
|
public class TradeRecord
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Trade identifier.
|
||||||
|
/// </summary>
|
||||||
|
public string TradeId { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trading symbol.
|
||||||
|
/// </summary>
|
||||||
|
public string Symbol { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Strategy name.
|
||||||
|
/// </summary>
|
||||||
|
public string StrategyName { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Entry timestamp.
|
||||||
|
/// </summary>
|
||||||
|
public DateTime EntryTime { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Exit timestamp.
|
||||||
|
/// </summary>
|
||||||
|
public DateTime? ExitTime { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trade side.
|
||||||
|
/// </summary>
|
||||||
|
public OrderSide Side { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Quantity.
|
||||||
|
/// </summary>
|
||||||
|
public int Quantity { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Average entry price.
|
||||||
|
/// </summary>
|
||||||
|
public double EntryPrice { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Average exit price.
|
||||||
|
/// </summary>
|
||||||
|
public double? ExitPrice { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Realized PnL.
|
||||||
|
/// </summary>
|
||||||
|
public double RealizedPnL { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Unrealized PnL.
|
||||||
|
/// </summary>
|
||||||
|
public double UnrealizedPnL { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Confluence grade at entry.
|
||||||
|
/// </summary>
|
||||||
|
public TradeGrade Grade { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Confluence weighted score at entry.
|
||||||
|
/// </summary>
|
||||||
|
public double ConfluenceScore { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Risk mode at entry.
|
||||||
|
/// </summary>
|
||||||
|
public RiskMode RiskMode { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Volatility regime at entry.
|
||||||
|
/// </summary>
|
||||||
|
public VolatilityRegime VolatilityRegime { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trend regime at entry.
|
||||||
|
/// </summary>
|
||||||
|
public TrendRegime TrendRegime { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Stop distance in ticks.
|
||||||
|
/// </summary>
|
||||||
|
public int StopTicks { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Target distance in ticks.
|
||||||
|
/// </summary>
|
||||||
|
public int TargetTicks { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// R multiple for the trade.
|
||||||
|
/// </summary>
|
||||||
|
public double RMultiple { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trade duration.
|
||||||
|
/// </summary>
|
||||||
|
public TimeSpan Duration { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Metadata bag.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<string, object> Metadata { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Creates a new trade record.
|
||||||
|
/// </summary>
|
||||||
|
public TradeRecord()
|
||||||
|
{
|
||||||
|
Metadata = new Dictionary<string, object>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Per-trade metrics.
|
||||||
|
/// </summary>
|
||||||
|
public class TradeMetrics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Trade identifier.
|
||||||
|
/// </summary>
|
||||||
|
public string TradeId { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gross PnL.
|
||||||
|
/// </summary>
|
||||||
|
public double PnL { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// R multiple.
|
||||||
|
/// </summary>
|
||||||
|
public double RMultiple { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Maximum adverse excursion.
|
||||||
|
/// </summary>
|
||||||
|
public double MAE { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Maximum favorable excursion.
|
||||||
|
/// </summary>
|
||||||
|
public double MFE { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Slippage amount.
|
||||||
|
/// </summary>
|
||||||
|
public double Slippage { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Commission amount.
|
||||||
|
/// </summary>
|
||||||
|
public double Commission { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Net PnL.
|
||||||
|
/// </summary>
|
||||||
|
public double NetPnL { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Whether trade is a winner.
|
||||||
|
/// </summary>
|
||||||
|
public bool IsWinner { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Hold time.
|
||||||
|
/// </summary>
|
||||||
|
public TimeSpan HoldTime { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Return on investment.
|
||||||
|
/// </summary>
|
||||||
|
public double ROI { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Custom metrics bag.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<string, object> CustomMetrics { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Creates a trade metrics model.
|
||||||
|
/// </summary>
|
||||||
|
public TradeMetrics()
|
||||||
|
{
|
||||||
|
CustomMetrics = new Dictionary<string, object>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Point-in-time portfolio performance snapshot.
|
||||||
|
/// </summary>
|
||||||
|
public class PerformanceSnapshot
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Snapshot time.
|
||||||
|
/// </summary>
|
||||||
|
public DateTime Timestamp { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Equity value.
|
||||||
|
/// </summary>
|
||||||
|
public double Equity { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Cumulative PnL.
|
||||||
|
/// </summary>
|
||||||
|
public double CumulativePnL { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Drawdown percentage.
|
||||||
|
/// </summary>
|
||||||
|
public double DrawdownPercent { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Open positions count.
|
||||||
|
/// </summary>
|
||||||
|
public int OpenPositions { get; set; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// PnL attribution breakdown container.
|
||||||
|
/// </summary>
|
||||||
|
public class AttributionBreakdown
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Attribution dimension.
|
||||||
|
/// </summary>
|
||||||
|
public string Dimension { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Total PnL.
|
||||||
|
/// </summary>
|
||||||
|
public double TotalPnL { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Dimension values with contribution amount.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<string, double> Contributions { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Creates a breakdown model.
|
||||||
|
/// </summary>
|
||||||
|
public AttributionBreakdown()
|
||||||
|
{
|
||||||
|
Contributions = new Dictionary<string, double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Aggregate performance metrics for a trade set.
|
||||||
|
/// </summary>
|
||||||
|
public class PerformanceMetrics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Total trade count.
|
||||||
|
/// </summary>
|
||||||
|
public int TotalTrades { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Win count.
|
||||||
|
/// </summary>
|
||||||
|
public int Wins { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Loss count.
|
||||||
|
/// </summary>
|
||||||
|
public int Losses { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Win rate [0,1].
|
||||||
|
/// </summary>
|
||||||
|
public double WinRate { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Loss rate [0,1].
|
||||||
|
/// </summary>
|
||||||
|
public double LossRate { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gross profit.
|
||||||
|
/// </summary>
|
||||||
|
public double GrossProfit { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gross loss absolute value.
|
||||||
|
/// </summary>
|
||||||
|
public double GrossLoss { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Net profit.
|
||||||
|
/// </summary>
|
||||||
|
public double NetProfit { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Average win.
|
||||||
|
/// </summary>
|
||||||
|
public double AverageWin { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Average loss absolute value.
|
||||||
|
/// </summary>
|
||||||
|
public double AverageLoss { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Profit factor.
|
||||||
|
/// </summary>
|
||||||
|
public double ProfitFactor { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Expectancy.
|
||||||
|
/// </summary>
|
||||||
|
public double Expectancy { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Sharpe ratio.
|
||||||
|
/// </summary>
|
||||||
|
public double SharpeRatio { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Sortino ratio.
|
||||||
|
/// </summary>
|
||||||
|
public double SortinoRatio { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Max drawdown percent.
|
||||||
|
/// </summary>
|
||||||
|
public double MaxDrawdownPercent { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Recovery factor.
|
||||||
|
/// </summary>
|
||||||
|
public double RecoveryFactor { get; set; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trade outcome classification.
|
||||||
|
/// </summary>
|
||||||
|
public enum TradeOutcome
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Winning trade.
|
||||||
|
/// </summary>
|
||||||
|
Win,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Losing trade.
|
||||||
|
/// </summary>
|
||||||
|
Loss,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Flat trade.
|
||||||
|
/// </summary>
|
||||||
|
Breakeven
|
||||||
|
}
|
||||||
|
}
|
||||||
303
src/NT8.Core/Analytics/AttributionModels.cs
Normal file
303
src/NT8.Core/Analytics/AttributionModels.cs
Normal file
@@ -0,0 +1,303 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Dimensions used for PnL attribution analysis.
|
||||||
|
/// </summary>
|
||||||
|
public enum AttributionDimension
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Strategy-level attribution.
|
||||||
|
/// </summary>
|
||||||
|
Strategy,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trade grade attribution.
|
||||||
|
/// </summary>
|
||||||
|
Grade,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Volatility and trend regime attribution.
|
||||||
|
/// </summary>
|
||||||
|
Regime,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Time-of-day attribution.
|
||||||
|
/// </summary>
|
||||||
|
Time,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Symbol attribution.
|
||||||
|
/// </summary>
|
||||||
|
Symbol,
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Risk mode attribution.
|
||||||
|
/// </summary>
|
||||||
|
RiskMode
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// PnL and performance slice for one dimension value.
|
||||||
|
/// </summary>
|
||||||
|
public class AttributionSlice
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Dimension display name.
|
||||||
|
/// </summary>
|
||||||
|
public string DimensionName { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Value of the dimension.
|
||||||
|
/// </summary>
|
||||||
|
public string DimensionValue { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Total PnL in the slice.
|
||||||
|
/// </summary>
|
||||||
|
public double TotalPnL { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Average PnL per trade.
|
||||||
|
/// </summary>
|
||||||
|
public double AvgPnL { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Number of trades in slice.
|
||||||
|
/// </summary>
|
||||||
|
public int TradeCount { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Win rate in range [0,1].
|
||||||
|
/// </summary>
|
||||||
|
public double WinRate { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Profit factor ratio.
|
||||||
|
/// </summary>
|
||||||
|
public double ProfitFactor { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Contribution to total PnL in range [-1,+1] or more if negative totals.
|
||||||
|
/// </summary>
|
||||||
|
public double Contribution { get; set; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Full attribution report for one dimension analysis.
|
||||||
|
/// </summary>
|
||||||
|
public class AttributionReport
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Dimension used for the report.
|
||||||
|
/// </summary>
|
||||||
|
public AttributionDimension Dimension { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Report generation time.
|
||||||
|
/// </summary>
|
||||||
|
public DateTime GeneratedAtUtc { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Total trades in scope.
|
||||||
|
/// </summary>
|
||||||
|
public int TotalTrades { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Total PnL in scope.
|
||||||
|
/// </summary>
|
||||||
|
public double TotalPnL { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Attribution slices.
|
||||||
|
/// </summary>
|
||||||
|
public List<AttributionSlice> Slices { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Additional metadata.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<string, object> Metadata { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Creates a new attribution report.
|
||||||
|
/// </summary>
|
||||||
|
public AttributionReport()
|
||||||
|
{
|
||||||
|
GeneratedAtUtc = DateTime.UtcNow;
|
||||||
|
Slices = new List<AttributionSlice>();
|
||||||
|
Metadata = new Dictionary<string, object>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Contribution analysis model for factor-level effects.
|
||||||
|
/// </summary>
|
||||||
|
public class ContributionAnalysis
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Factor name.
|
||||||
|
/// </summary>
|
||||||
|
public string Factor { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Aggregate contribution value.
|
||||||
|
/// </summary>
|
||||||
|
public double ContributionValue { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Contribution percentage.
|
||||||
|
/// </summary>
|
||||||
|
public double ContributionPercent { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Statistical confidence in range [0,1].
|
||||||
|
/// </summary>
|
||||||
|
public double Confidence { get; set; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Drawdown period definition.
|
||||||
|
/// </summary>
|
||||||
|
public class DrawdownPeriod
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Drawdown start time.
|
||||||
|
/// </summary>
|
||||||
|
public DateTime StartTime { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Drawdown trough time.
|
||||||
|
/// </summary>
|
||||||
|
public DateTime TroughTime { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Recovery time if recovered.
|
||||||
|
/// </summary>
|
||||||
|
public DateTime? RecoveryTime { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Peak equity value.
|
||||||
|
/// </summary>
|
||||||
|
public double PeakEquity { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trough equity value.
|
||||||
|
/// </summary>
|
||||||
|
public double TroughEquity { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Drawdown amount.
|
||||||
|
/// </summary>
|
||||||
|
public double DrawdownAmount { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Drawdown percentage.
|
||||||
|
/// </summary>
|
||||||
|
public double DrawdownPercent { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Duration until trough.
|
||||||
|
/// </summary>
|
||||||
|
public TimeSpan DurationToTrough { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Duration to recovery.
|
||||||
|
/// </summary>
|
||||||
|
public TimeSpan? DurationToRecovery { get; set; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Drawdown attribution details.
|
||||||
|
/// </summary>
|
||||||
|
public class DrawdownAttribution
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Primary cause descriptor.
|
||||||
|
/// </summary>
|
||||||
|
public string PrimaryCause { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trade count involved.
|
||||||
|
/// </summary>
|
||||||
|
public int TradeCount { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Worst symbol contributor.
|
||||||
|
/// </summary>
|
||||||
|
public string WorstSymbol { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Worst strategy contributor.
|
||||||
|
/// </summary>
|
||||||
|
public string WorstStrategy { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Grade-level contributors.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<string, double> GradeContributions { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Creates drawdown attribution model.
|
||||||
|
/// </summary>
|
||||||
|
public DrawdownAttribution()
|
||||||
|
{
|
||||||
|
GradeContributions = new Dictionary<string, double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Aggregate drawdown report.
|
||||||
|
/// </summary>
|
||||||
|
public class DrawdownReport
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Maximum drawdown amount.
|
||||||
|
/// </summary>
|
||||||
|
public double MaxDrawdownAmount { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Maximum drawdown percentage.
|
||||||
|
/// </summary>
|
||||||
|
public double MaxDrawdownPercent { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Current drawdown amount.
|
||||||
|
/// </summary>
|
||||||
|
public double CurrentDrawdownAmount { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Average drawdown percentage.
|
||||||
|
/// </summary>
|
||||||
|
public double AverageDrawdownPercent { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Number of drawdowns.
|
||||||
|
/// </summary>
|
||||||
|
public int NumberOfDrawdowns { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Longest drawdown duration.
|
||||||
|
/// </summary>
|
||||||
|
public TimeSpan LongestDuration { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Average recovery time.
|
||||||
|
/// </summary>
|
||||||
|
public TimeSpan AverageRecoveryTime { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Drawdown periods.
|
||||||
|
/// </summary>
|
||||||
|
public List<DrawdownPeriod> DrawdownPeriods { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Creates a drawdown report.
|
||||||
|
/// </summary>
|
||||||
|
public DrawdownReport()
|
||||||
|
{
|
||||||
|
DrawdownPeriods = new List<DrawdownPeriod>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
303
src/NT8.Core/Analytics/ConfluenceValidator.cs
Normal file
303
src/NT8.Core/Analytics/ConfluenceValidator.cs
Normal file
@@ -0,0 +1,303 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Factor-level analysis report.
|
||||||
|
/// </summary>
|
||||||
|
public class FactorAnalysisReport
|
||||||
|
{
|
||||||
|
public FactorType Factor { get; set; }
|
||||||
|
public double CorrelationToPnL { get; set; }
|
||||||
|
public double Importance { get; set; }
|
||||||
|
public Dictionary<string, double> BucketWinRate { get; set; }
|
||||||
|
public Dictionary<string, double> BucketAvgPnL { get; set; }
|
||||||
|
|
||||||
|
public FactorAnalysisReport()
|
||||||
|
{
|
||||||
|
BucketWinRate = new Dictionary<string, double>();
|
||||||
|
BucketAvgPnL = new Dictionary<string, double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Validates confluence score quality and recommends weight adjustments.
|
||||||
|
/// </summary>
|
||||||
|
public class ConfluenceValidator
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
|
||||||
|
public ConfluenceValidator(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Analyzes one factor against trade outcomes.
|
||||||
|
/// </summary>
|
||||||
|
public FactorAnalysisReport AnalyzeFactor(FactorType factor, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var report = new FactorAnalysisReport();
|
||||||
|
report.Factor = factor;
|
||||||
|
|
||||||
|
var values = ExtractFactorValues(factor, trades);
|
||||||
|
report.CorrelationToPnL = Correlation(values, trades.Select(t => t.RealizedPnL).ToList());
|
||||||
|
report.Importance = Math.Abs(report.CorrelationToPnL);
|
||||||
|
|
||||||
|
var low = new List<int>();
|
||||||
|
var medium = new List<int>();
|
||||||
|
var high = new List<int>();
|
||||||
|
|
||||||
|
for (var i = 0; i < values.Count; i++)
|
||||||
|
{
|
||||||
|
var v = values[i];
|
||||||
|
if (v < 0.5)
|
||||||
|
low.Add(i);
|
||||||
|
else if (v < 0.8)
|
||||||
|
medium.Add(i);
|
||||||
|
else
|
||||||
|
high.Add(i);
|
||||||
|
}
|
||||||
|
|
||||||
|
AddBucket(report, "Low", low, trades);
|
||||||
|
AddBucket(report, "Medium", medium, trades);
|
||||||
|
AddBucket(report, "High", high, trades);
|
||||||
|
|
||||||
|
return report;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("AnalyzeFactor failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Estimates factor importance values normalized to 1.0.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<FactorType, double> CalculateFactorImportance(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var result = new Dictionary<FactorType, double>();
|
||||||
|
var raw = new Dictionary<FactorType, double>();
|
||||||
|
var total = 0.0;
|
||||||
|
|
||||||
|
var supported = new[]
|
||||||
|
{
|
||||||
|
FactorType.Setup,
|
||||||
|
FactorType.Trend,
|
||||||
|
FactorType.Volatility,
|
||||||
|
FactorType.Timing,
|
||||||
|
FactorType.ExecutionQuality
|
||||||
|
};
|
||||||
|
|
||||||
|
foreach (var factor in supported)
|
||||||
|
{
|
||||||
|
var analysis = AnalyzeFactor(factor, trades);
|
||||||
|
var score = Math.Max(0.0001, analysis.Importance);
|
||||||
|
raw.Add(factor, score);
|
||||||
|
total += score;
|
||||||
|
}
|
||||||
|
|
||||||
|
foreach (var kvp in raw)
|
||||||
|
{
|
||||||
|
result.Add(kvp.Key, kvp.Value / total);
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateFactorImportance failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Recommends confluence weights based on observed importance.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<FactorType, double> RecommendWeights(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var importance = CalculateFactorImportance(trades);
|
||||||
|
return importance;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("RecommendWeights failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Validates whether score implies expected outcome.
|
||||||
|
/// </summary>
|
||||||
|
public bool ValidateScore(ConfluenceScore score, TradeOutcome outcome)
|
||||||
|
{
|
||||||
|
if (score == null)
|
||||||
|
throw new ArgumentNullException("score");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (score.WeightedScore >= 0.7)
|
||||||
|
return outcome == TradeOutcome.Win;
|
||||||
|
if (score.WeightedScore <= 0.4)
|
||||||
|
return outcome == TradeOutcome.Loss;
|
||||||
|
|
||||||
|
return outcome != TradeOutcome.Breakeven;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("ValidateScore failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static void AddBucket(FactorAnalysisReport report, string bucket, List<int> indices, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (indices.Count == 0)
|
||||||
|
{
|
||||||
|
report.BucketWinRate[bucket] = 0.0;
|
||||||
|
report.BucketAvgPnL[bucket] = 0.0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var selected = indices.Select(i => trades[i]).ToList();
|
||||||
|
report.BucketWinRate[bucket] = (double)selected.Count(t => t.RealizedPnL > 0.0) / selected.Count;
|
||||||
|
report.BucketAvgPnL[bucket] = selected.Average(t => t.RealizedPnL);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static List<double> ExtractFactorValues(FactorType factor, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
var values = new List<double>();
|
||||||
|
foreach (var trade in trades)
|
||||||
|
{
|
||||||
|
switch (factor)
|
||||||
|
{
|
||||||
|
case FactorType.Setup:
|
||||||
|
values.Add(trade.ConfluenceScore);
|
||||||
|
break;
|
||||||
|
case FactorType.Trend:
|
||||||
|
values.Add(TrendScore(trade.TrendRegime));
|
||||||
|
break;
|
||||||
|
case FactorType.Volatility:
|
||||||
|
values.Add(VolatilityScore(trade.VolatilityRegime));
|
||||||
|
break;
|
||||||
|
case FactorType.Timing:
|
||||||
|
values.Add(TimingScore(trade.EntryTime));
|
||||||
|
break;
|
||||||
|
case FactorType.ExecutionQuality:
|
||||||
|
values.Add(ExecutionQualityScore(trade));
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
values.Add(0.5);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return values;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double TrendScore(TrendRegime trend)
|
||||||
|
{
|
||||||
|
switch (trend)
|
||||||
|
{
|
||||||
|
case TrendRegime.StrongUp:
|
||||||
|
case TrendRegime.StrongDown:
|
||||||
|
return 0.9;
|
||||||
|
case TrendRegime.WeakUp:
|
||||||
|
case TrendRegime.WeakDown:
|
||||||
|
return 0.7;
|
||||||
|
default:
|
||||||
|
return 0.5;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double VolatilityScore(VolatilityRegime volatility)
|
||||||
|
{
|
||||||
|
switch (volatility)
|
||||||
|
{
|
||||||
|
case VolatilityRegime.Low:
|
||||||
|
case VolatilityRegime.BelowNormal:
|
||||||
|
return 0.8;
|
||||||
|
case VolatilityRegime.Normal:
|
||||||
|
return 0.6;
|
||||||
|
case VolatilityRegime.Elevated:
|
||||||
|
return 0.4;
|
||||||
|
default:
|
||||||
|
return 0.2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double TimingScore(DateTime timestamp)
|
||||||
|
{
|
||||||
|
var t = timestamp.TimeOfDay;
|
||||||
|
if (t < new TimeSpan(10, 30, 0))
|
||||||
|
return 0.8;
|
||||||
|
if (t < new TimeSpan(14, 0, 0))
|
||||||
|
return 0.5;
|
||||||
|
if (t < new TimeSpan(16, 0, 0))
|
||||||
|
return 0.7;
|
||||||
|
return 0.3;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double ExecutionQualityScore(TradeRecord trade)
|
||||||
|
{
|
||||||
|
if (trade.StopTicks <= 0)
|
||||||
|
return 0.5;
|
||||||
|
|
||||||
|
var scaled = trade.RMultiple / 3.0;
|
||||||
|
if (scaled < 0.0)
|
||||||
|
scaled = 0.0;
|
||||||
|
if (scaled > 1.0)
|
||||||
|
scaled = 1.0;
|
||||||
|
return scaled;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static double Correlation(List<double> xs, List<double> ys)
|
||||||
|
{
|
||||||
|
if (xs.Count != ys.Count || xs.Count < 2)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
var xAvg = xs.Average();
|
||||||
|
var yAvg = ys.Average();
|
||||||
|
var sumXY = 0.0;
|
||||||
|
var sumXX = 0.0;
|
||||||
|
var sumYY = 0.0;
|
||||||
|
|
||||||
|
for (var i = 0; i < xs.Count; i++)
|
||||||
|
{
|
||||||
|
var dx = xs[i] - xAvg;
|
||||||
|
var dy = ys[i] - yAvg;
|
||||||
|
sumXY += dx * dy;
|
||||||
|
sumXX += dx * dx;
|
||||||
|
sumYY += dy * dy;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sumXX <= 0.0 || sumYY <= 0.0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
return sumXY / Math.Sqrt(sumXX * sumYY);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
206
src/NT8.Core/Analytics/DrawdownAnalyzer.cs
Normal file
206
src/NT8.Core/Analytics/DrawdownAnalyzer.cs
Normal file
@@ -0,0 +1,206 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Analyzes drawdown behavior from trade history.
|
||||||
|
/// </summary>
|
||||||
|
public class DrawdownAnalyzer
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Initializes analyzer.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="logger">Logger dependency.</param>
|
||||||
|
public DrawdownAnalyzer(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Runs full drawdown analysis.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Drawdown report.</returns>
|
||||||
|
public DrawdownReport Analyze(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var periods = IdentifyDrawdowns(trades);
|
||||||
|
var report = new DrawdownReport();
|
||||||
|
report.DrawdownPeriods = periods;
|
||||||
|
report.NumberOfDrawdowns = periods.Count;
|
||||||
|
report.MaxDrawdownAmount = periods.Count > 0 ? periods.Max(p => p.DrawdownAmount) : 0.0;
|
||||||
|
report.MaxDrawdownPercent = periods.Count > 0 ? periods.Max(p => p.DrawdownPercent) : 0.0;
|
||||||
|
report.CurrentDrawdownAmount = periods.Count > 0 && !periods[periods.Count - 1].RecoveryTime.HasValue
|
||||||
|
? periods[periods.Count - 1].DrawdownAmount
|
||||||
|
: 0.0;
|
||||||
|
report.AverageDrawdownPercent = periods.Count > 0 ? periods.Average(p => p.DrawdownPercent) : 0.0;
|
||||||
|
report.LongestDuration = periods.Count > 0 ? periods.Max(p => p.DurationToTrough) : TimeSpan.Zero;
|
||||||
|
|
||||||
|
var recovered = periods.Where(p => p.DurationToRecovery.HasValue).Select(p => p.DurationToRecovery.Value).ToList();
|
||||||
|
if (recovered.Count > 0)
|
||||||
|
{
|
||||||
|
report.AverageRecoveryTime = TimeSpan.FromTicks((long)recovered.Average(t => t.Ticks));
|
||||||
|
}
|
||||||
|
|
||||||
|
return report;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("Drawdown Analyze failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Identifies drawdown periods from ordered trades.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Drawdown periods.</returns>
|
||||||
|
public List<DrawdownPeriod> IdentifyDrawdowns(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var ordered = trades
|
||||||
|
.OrderBy(t => t.ExitTime.HasValue ? t.ExitTime.Value : t.EntryTime)
|
||||||
|
.ToList();
|
||||||
|
|
||||||
|
var periods = new List<DrawdownPeriod>();
|
||||||
|
var equity = 0.0;
|
||||||
|
var peak = 0.0;
|
||||||
|
DateTime peakTime = DateTime.MinValue;
|
||||||
|
DrawdownPeriod active = null;
|
||||||
|
|
||||||
|
foreach (var trade in ordered)
|
||||||
|
{
|
||||||
|
var eventTime = trade.ExitTime.HasValue ? trade.ExitTime.Value : trade.EntryTime;
|
||||||
|
equity += trade.RealizedPnL;
|
||||||
|
|
||||||
|
if (equity >= peak)
|
||||||
|
{
|
||||||
|
peak = equity;
|
||||||
|
peakTime = eventTime;
|
||||||
|
|
||||||
|
if (active != null)
|
||||||
|
{
|
||||||
|
active.RecoveryTime = eventTime;
|
||||||
|
active.DurationToRecovery = active.RecoveryTime.Value - active.StartTime;
|
||||||
|
periods.Add(active);
|
||||||
|
active = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
var drawdownAmount = peak - equity;
|
||||||
|
var drawdownPercent = peak > 0.0 ? (drawdownAmount / peak) * 100.0 : drawdownAmount;
|
||||||
|
|
||||||
|
if (active == null)
|
||||||
|
{
|
||||||
|
active = new DrawdownPeriod();
|
||||||
|
active.StartTime = peakTime == DateTime.MinValue ? eventTime : peakTime;
|
||||||
|
active.PeakEquity = peak;
|
||||||
|
active.TroughTime = eventTime;
|
||||||
|
active.TroughEquity = equity;
|
||||||
|
active.DrawdownAmount = drawdownAmount;
|
||||||
|
active.DrawdownPercent = drawdownPercent;
|
||||||
|
active.DurationToTrough = eventTime - active.StartTime;
|
||||||
|
}
|
||||||
|
else if (equity <= active.TroughEquity)
|
||||||
|
{
|
||||||
|
active.TroughTime = eventTime;
|
||||||
|
active.TroughEquity = equity;
|
||||||
|
active.DrawdownAmount = drawdownAmount;
|
||||||
|
active.DrawdownPercent = drawdownPercent;
|
||||||
|
active.DurationToTrough = eventTime - active.StartTime;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (active != null)
|
||||||
|
{
|
||||||
|
periods.Add(active);
|
||||||
|
}
|
||||||
|
|
||||||
|
return periods;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("IdentifyDrawdowns failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Attributes one drawdown period to likely causes.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="period">Drawdown period.</param>
|
||||||
|
/// <returns>Attribution details.</returns>
|
||||||
|
public DrawdownAttribution AttributeDrawdown(DrawdownPeriod period)
|
||||||
|
{
|
||||||
|
if (period == null)
|
||||||
|
throw new ArgumentNullException("period");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var attribution = new DrawdownAttribution();
|
||||||
|
|
||||||
|
if (period.DrawdownPercent >= 20.0)
|
||||||
|
attribution.PrimaryCause = "SevereLossCluster";
|
||||||
|
else if (period.DrawdownPercent >= 10.0)
|
||||||
|
attribution.PrimaryCause = "ModerateLossCluster";
|
||||||
|
else
|
||||||
|
attribution.PrimaryCause = "NormalVariance";
|
||||||
|
|
||||||
|
attribution.TradeCount = 0;
|
||||||
|
attribution.WorstSymbol = string.Empty;
|
||||||
|
attribution.WorstStrategy = string.Empty;
|
||||||
|
attribution.GradeContributions.Add("Unknown", period.DrawdownAmount);
|
||||||
|
|
||||||
|
return attribution;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("AttributeDrawdown failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates recovery time in days for a drawdown period.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="period">Drawdown period.</param>
|
||||||
|
/// <returns>Recovery time in days, -1 if unrecovered.</returns>
|
||||||
|
public double CalculateRecoveryTime(DrawdownPeriod period)
|
||||||
|
{
|
||||||
|
if (period == null)
|
||||||
|
throw new ArgumentNullException("period");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (!period.RecoveryTime.HasValue)
|
||||||
|
return -1.0;
|
||||||
|
|
||||||
|
return (period.RecoveryTime.Value - period.StartTime).TotalDays;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateRecoveryTime failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
194
src/NT8.Core/Analytics/GradePerformanceAnalyzer.cs
Normal file
194
src/NT8.Core/Analytics/GradePerformanceAnalyzer.cs
Normal file
@@ -0,0 +1,194 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Grade-level aggregate analysis report.
|
||||||
|
/// </summary>
|
||||||
|
public class GradePerformanceReport
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Metrics by grade.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<TradeGrade, PerformanceMetrics> MetricsByGrade { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Accuracy by grade.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<TradeGrade, double> GradeAccuracy { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Suggested threshold.
|
||||||
|
/// </summary>
|
||||||
|
public TradeGrade SuggestedThreshold { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Creates a report instance.
|
||||||
|
/// </summary>
|
||||||
|
public GradePerformanceReport()
|
||||||
|
{
|
||||||
|
MetricsByGrade = new Dictionary<TradeGrade, PerformanceMetrics>();
|
||||||
|
GradeAccuracy = new Dictionary<TradeGrade, double>();
|
||||||
|
SuggestedThreshold = TradeGrade.F;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Analyzes performance by confluence grade.
|
||||||
|
/// </summary>
|
||||||
|
public class GradePerformanceAnalyzer
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
private readonly PerformanceCalculator _calculator;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Initializes analyzer.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="logger">Logger dependency.</param>
|
||||||
|
public GradePerformanceAnalyzer(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
_calculator = new PerformanceCalculator(logger);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Produces grade-level performance report.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Performance report.</returns>
|
||||||
|
public GradePerformanceReport AnalyzeByGrade(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var report = new GradePerformanceReport();
|
||||||
|
foreach (TradeGrade grade in Enum.GetValues(typeof(TradeGrade)))
|
||||||
|
{
|
||||||
|
var subset = trades.Where(t => t.Grade == grade).ToList();
|
||||||
|
report.MetricsByGrade[grade] = _calculator.Calculate(subset);
|
||||||
|
report.GradeAccuracy[grade] = CalculateGradeAccuracy(grade, trades);
|
||||||
|
}
|
||||||
|
|
||||||
|
report.SuggestedThreshold = FindOptimalThreshold(trades);
|
||||||
|
return report;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("AnalyzeByGrade failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates percentage of profitable trades for a grade.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="grade">Target grade.</param>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Accuracy in range [0,1].</returns>
|
||||||
|
public double CalculateGradeAccuracy(TradeGrade grade, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var subset = trades.Where(t => t.Grade == grade).ToList();
|
||||||
|
if (subset.Count == 0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
var winners = subset.Count(t => t.RealizedPnL > 0.0);
|
||||||
|
return (double)winners / subset.Count;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateGradeAccuracy failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Finds threshold with best expectancy for accepted grades and above.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Suggested threshold grade.</returns>
|
||||||
|
public TradeGrade FindOptimalThreshold(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var ordered = new List<TradeGrade>
|
||||||
|
{
|
||||||
|
TradeGrade.APlus,
|
||||||
|
TradeGrade.A,
|
||||||
|
TradeGrade.B,
|
||||||
|
TradeGrade.C,
|
||||||
|
TradeGrade.D,
|
||||||
|
TradeGrade.F
|
||||||
|
};
|
||||||
|
|
||||||
|
var bestGrade = TradeGrade.F;
|
||||||
|
var bestExpectancy = double.MinValue;
|
||||||
|
|
||||||
|
foreach (var threshold in ordered)
|
||||||
|
{
|
||||||
|
var accepted = trades.Where(t => (int)t.Grade >= (int)threshold).ToList();
|
||||||
|
if (accepted.Count == 0)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
var expectancy = _calculator.CalculateExpectancy(accepted);
|
||||||
|
if (expectancy > bestExpectancy)
|
||||||
|
{
|
||||||
|
bestExpectancy = expectancy;
|
||||||
|
bestGrade = threshold;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return bestGrade;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("FindOptimalThreshold failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets metrics grouped by grade.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Metrics by grade.</returns>
|
||||||
|
public Dictionary<TradeGrade, PerformanceMetrics> GetMetricsByGrade(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var result = new Dictionary<TradeGrade, PerformanceMetrics>();
|
||||||
|
foreach (TradeGrade grade in Enum.GetValues(typeof(TradeGrade)))
|
||||||
|
{
|
||||||
|
var subset = trades.Where(t => t.Grade == grade).ToList();
|
||||||
|
result.Add(grade, _calculator.Calculate(subset));
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GetMetricsByGrade failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
163
src/NT8.Core/Analytics/MonteCarloSimulator.cs
Normal file
163
src/NT8.Core/Analytics/MonteCarloSimulator.cs
Normal file
@@ -0,0 +1,163 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Confidence interval model.
|
||||||
|
/// </summary>
|
||||||
|
public class ConfidenceInterval
|
||||||
|
{
|
||||||
|
public double ConfidenceLevel { get; set; }
|
||||||
|
public double LowerBound { get; set; }
|
||||||
|
public double UpperBound { get; set; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Monte Carlo simulation output.
|
||||||
|
/// </summary>
|
||||||
|
public class MonteCarloResult
|
||||||
|
{
|
||||||
|
public int NumSimulations { get; set; }
|
||||||
|
public int NumTradesPerSimulation { get; set; }
|
||||||
|
public List<double> FinalPnLDistribution { get; set; }
|
||||||
|
public List<double> MaxDrawdownDistribution { get; set; }
|
||||||
|
public double MeanFinalPnL { get; set; }
|
||||||
|
|
||||||
|
public MonteCarloResult()
|
||||||
|
{
|
||||||
|
FinalPnLDistribution = new List<double>();
|
||||||
|
MaxDrawdownDistribution = new List<double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Monte Carlo simulator for PnL scenarios.
|
||||||
|
/// </summary>
|
||||||
|
public class MonteCarloSimulator
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
private readonly Random _random;
|
||||||
|
|
||||||
|
public MonteCarloSimulator(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
_random = new Random(1337);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Runs Monte Carlo simulation using bootstrap trade sampling.
|
||||||
|
/// </summary>
|
||||||
|
public MonteCarloResult Simulate(List<TradeRecord> historicalTrades, int numSimulations, int numTrades)
|
||||||
|
{
|
||||||
|
if (historicalTrades == null)
|
||||||
|
throw new ArgumentNullException("historicalTrades");
|
||||||
|
if (numSimulations <= 0)
|
||||||
|
throw new ArgumentException("numSimulations must be positive", "numSimulations");
|
||||||
|
if (numTrades <= 0)
|
||||||
|
throw new ArgumentException("numTrades must be positive", "numTrades");
|
||||||
|
if (historicalTrades.Count == 0)
|
||||||
|
throw new ArgumentException("historicalTrades cannot be empty", "historicalTrades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var result = new MonteCarloResult();
|
||||||
|
result.NumSimulations = numSimulations;
|
||||||
|
result.NumTradesPerSimulation = numTrades;
|
||||||
|
|
||||||
|
for (var sim = 0; sim < numSimulations; sim++)
|
||||||
|
{
|
||||||
|
var equity = 0.0;
|
||||||
|
var peak = 0.0;
|
||||||
|
var maxDd = 0.0;
|
||||||
|
|
||||||
|
for (var i = 0; i < numTrades; i++)
|
||||||
|
{
|
||||||
|
var sample = historicalTrades[_random.Next(historicalTrades.Count)];
|
||||||
|
equity += sample.RealizedPnL;
|
||||||
|
|
||||||
|
if (equity > peak)
|
||||||
|
peak = equity;
|
||||||
|
|
||||||
|
var dd = peak - equity;
|
||||||
|
if (dd > maxDd)
|
||||||
|
maxDd = dd;
|
||||||
|
}
|
||||||
|
|
||||||
|
result.FinalPnLDistribution.Add(equity);
|
||||||
|
result.MaxDrawdownDistribution.Add(maxDd);
|
||||||
|
}
|
||||||
|
|
||||||
|
result.MeanFinalPnL = result.FinalPnLDistribution.Average();
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("Monte Carlo simulate failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates risk of ruin as probability max drawdown exceeds threshold.
|
||||||
|
/// </summary>
|
||||||
|
public double CalculateRiskOfRuin(List<TradeRecord> trades, double drawdownThreshold)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
if (drawdownThreshold <= 0)
|
||||||
|
throw new ArgumentException("drawdownThreshold must be positive", "drawdownThreshold");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var result = Simulate(trades, 2000, Math.Max(30, trades.Count));
|
||||||
|
var ruined = result.MaxDrawdownDistribution.Count(d => d >= drawdownThreshold);
|
||||||
|
return (double)ruined / result.MaxDrawdownDistribution.Count;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateRiskOfRuin failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates confidence interval for final PnL distribution.
|
||||||
|
/// </summary>
|
||||||
|
public ConfidenceInterval CalculateConfidenceInterval(MonteCarloResult result, double confidenceLevel)
|
||||||
|
{
|
||||||
|
if (result == null)
|
||||||
|
throw new ArgumentNullException("result");
|
||||||
|
if (confidenceLevel <= 0.0 || confidenceLevel >= 1.0)
|
||||||
|
throw new ArgumentException("confidenceLevel must be in (0,1)", "confidenceLevel");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var sorted = result.FinalPnLDistribution.OrderBy(v => v).ToList();
|
||||||
|
if (sorted.Count == 0)
|
||||||
|
return new ConfidenceInterval { ConfidenceLevel = confidenceLevel, LowerBound = 0.0, UpperBound = 0.0 };
|
||||||
|
|
||||||
|
var alpha = 1.0 - confidenceLevel;
|
||||||
|
var lowerIndex = (int)Math.Floor((alpha / 2.0) * (sorted.Count - 1));
|
||||||
|
var upperIndex = (int)Math.Floor((1.0 - (alpha / 2.0)) * (sorted.Count - 1));
|
||||||
|
|
||||||
|
return new ConfidenceInterval
|
||||||
|
{
|
||||||
|
ConfidenceLevel = confidenceLevel,
|
||||||
|
LowerBound = sorted[Math.Max(0, lowerIndex)],
|
||||||
|
UpperBound = sorted[Math.Min(sorted.Count - 1, upperIndex)]
|
||||||
|
};
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateConfidenceInterval failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
311
src/NT8.Core/Analytics/ParameterOptimizer.cs
Normal file
311
src/NT8.Core/Analytics/ParameterOptimizer.cs
Normal file
@@ -0,0 +1,311 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Globalization;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Result for single-parameter optimization.
|
||||||
|
/// </summary>
|
||||||
|
public class OptimizationResult
|
||||||
|
{
|
||||||
|
public string ParameterName { get; set; }
|
||||||
|
public Dictionary<double, PerformanceMetrics> MetricsByValue { get; set; }
|
||||||
|
public double OptimalValue { get; set; }
|
||||||
|
|
||||||
|
public OptimizationResult()
|
||||||
|
{
|
||||||
|
MetricsByValue = new Dictionary<double, PerformanceMetrics>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Result for multi-parameter grid search.
|
||||||
|
/// </summary>
|
||||||
|
public class GridSearchResult
|
||||||
|
{
|
||||||
|
public Dictionary<string, PerformanceMetrics> MetricsByCombination { get; set; }
|
||||||
|
public Dictionary<string, double> BestParameters { get; set; }
|
||||||
|
|
||||||
|
public GridSearchResult()
|
||||||
|
{
|
||||||
|
MetricsByCombination = new Dictionary<string, PerformanceMetrics>();
|
||||||
|
BestParameters = new Dictionary<string, double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Walk-forward optimization result.
|
||||||
|
/// </summary>
|
||||||
|
public class WalkForwardResult
|
||||||
|
{
|
||||||
|
public PerformanceMetrics InSampleMetrics { get; set; }
|
||||||
|
public PerformanceMetrics OutOfSampleMetrics { get; set; }
|
||||||
|
public double StabilityScore { get; set; }
|
||||||
|
|
||||||
|
public WalkForwardResult()
|
||||||
|
{
|
||||||
|
InSampleMetrics = new PerformanceMetrics();
|
||||||
|
OutOfSampleMetrics = new PerformanceMetrics();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Parameter optimization utility.
|
||||||
|
/// </summary>
|
||||||
|
public class ParameterOptimizer
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
private readonly PerformanceCalculator _calculator;
|
||||||
|
|
||||||
|
public ParameterOptimizer(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
_calculator = new PerformanceCalculator(logger);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Optimizes one parameter by replaying filtered trade subsets.
|
||||||
|
/// </summary>
|
||||||
|
public OptimizationResult OptimizeParameter(string paramName, List<double> values, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(paramName))
|
||||||
|
throw new ArgumentNullException("paramName");
|
||||||
|
if (values == null)
|
||||||
|
throw new ArgumentNullException("values");
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var result = new OptimizationResult();
|
||||||
|
result.ParameterName = paramName;
|
||||||
|
|
||||||
|
var bestScore = double.MinValue;
|
||||||
|
var bestValue = values.Count > 0 ? values[0] : 0.0;
|
||||||
|
|
||||||
|
foreach (var value in values)
|
||||||
|
{
|
||||||
|
var sample = BuildSyntheticSubset(paramName, value, trades);
|
||||||
|
var metrics = _calculator.Calculate(sample);
|
||||||
|
result.MetricsByValue[value] = metrics;
|
||||||
|
|
||||||
|
var score = metrics.Expectancy;
|
||||||
|
if (score > bestScore)
|
||||||
|
{
|
||||||
|
bestScore = score;
|
||||||
|
bestValue = value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
result.OptimalValue = bestValue;
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("OptimizeParameter failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Runs a grid search for multiple parameters.
|
||||||
|
/// </summary>
|
||||||
|
public GridSearchResult GridSearch(Dictionary<string, List<double>> parameters, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (parameters == null)
|
||||||
|
throw new ArgumentNullException("parameters");
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var result = new GridSearchResult();
|
||||||
|
var keys = parameters.Keys.ToList();
|
||||||
|
if (keys.Count == 0)
|
||||||
|
return result;
|
||||||
|
|
||||||
|
var combos = BuildCombinations(parameters, keys, 0, new Dictionary<string, double>());
|
||||||
|
var bestScore = double.MinValue;
|
||||||
|
Dictionary<string, double> best = null;
|
||||||
|
|
||||||
|
foreach (var combo in combos)
|
||||||
|
{
|
||||||
|
var sample = trades;
|
||||||
|
foreach (var kv in combo)
|
||||||
|
{
|
||||||
|
sample = BuildSyntheticSubset(kv.Key, kv.Value, sample);
|
||||||
|
}
|
||||||
|
|
||||||
|
var metrics = _calculator.Calculate(sample);
|
||||||
|
var key = SerializeCombo(combo);
|
||||||
|
result.MetricsByCombination[key] = metrics;
|
||||||
|
|
||||||
|
if (metrics.Expectancy > bestScore)
|
||||||
|
{
|
||||||
|
bestScore = metrics.Expectancy;
|
||||||
|
best = new Dictionary<string, double>(combo);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (best != null)
|
||||||
|
result.BestParameters = best;
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GridSearch failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Performs basic walk-forward validation.
|
||||||
|
/// </summary>
|
||||||
|
public WalkForwardResult WalkForwardTest(StrategyConfig config, List<BarData> historicalData)
|
||||||
|
{
|
||||||
|
if (config == null)
|
||||||
|
throw new ArgumentNullException("config");
|
||||||
|
if (historicalData == null)
|
||||||
|
throw new ArgumentNullException("historicalData");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var mid = historicalData.Count / 2;
|
||||||
|
var inSampleBars = historicalData.Take(mid).ToList();
|
||||||
|
var outSampleBars = historicalData.Skip(mid).ToList();
|
||||||
|
|
||||||
|
var inTrades = BuildPseudoTradesFromBars(inSampleBars, config.Symbol);
|
||||||
|
var outTrades = BuildPseudoTradesFromBars(outSampleBars, config.Symbol);
|
||||||
|
|
||||||
|
var result = new WalkForwardResult();
|
||||||
|
result.InSampleMetrics = _calculator.Calculate(inTrades);
|
||||||
|
result.OutOfSampleMetrics = _calculator.Calculate(outTrades);
|
||||||
|
|
||||||
|
var inExp = result.InSampleMetrics.Expectancy;
|
||||||
|
var outExp = result.OutOfSampleMetrics.Expectancy;
|
||||||
|
var denominator = Math.Abs(inExp) > 0.000001 ? Math.Abs(inExp) : 1.0;
|
||||||
|
var drift = Math.Abs(inExp - outExp) / denominator;
|
||||||
|
result.StabilityScore = Math.Max(0.0, 1.0 - drift);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("WalkForwardTest failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static List<TradeRecord> BuildSyntheticSubset(string paramName, double value, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades.Count == 0)
|
||||||
|
return new List<TradeRecord>();
|
||||||
|
|
||||||
|
var percentile = Math.Max(0.05, Math.Min(0.95, value / (Math.Abs(value) + 1.0)));
|
||||||
|
var take = Math.Max(1, (int)Math.Round(trades.Count * percentile));
|
||||||
|
return trades
|
||||||
|
.OrderByDescending(t => t.ConfluenceScore)
|
||||||
|
.Take(take)
|
||||||
|
.Select(Clone)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
|
||||||
|
private static List<Dictionary<string, double>> BuildCombinations(
|
||||||
|
Dictionary<string, List<double>> parameters,
|
||||||
|
List<string> keys,
|
||||||
|
int index,
|
||||||
|
Dictionary<string, double> current)
|
||||||
|
{
|
||||||
|
var results = new List<Dictionary<string, double>>();
|
||||||
|
if (index >= keys.Count)
|
||||||
|
{
|
||||||
|
results.Add(new Dictionary<string, double>(current));
|
||||||
|
return results;
|
||||||
|
}
|
||||||
|
|
||||||
|
var key = keys[index];
|
||||||
|
foreach (var value in parameters[key])
|
||||||
|
{
|
||||||
|
current[key] = value;
|
||||||
|
results.AddRange(BuildCombinations(parameters, keys, index + 1, current));
|
||||||
|
}
|
||||||
|
|
||||||
|
return results;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static string SerializeCombo(Dictionary<string, double> combo)
|
||||||
|
{
|
||||||
|
return string.Join(";", combo.OrderBy(k => k.Key).Select(k => string.Format(CultureInfo.InvariantCulture, "{0}={1}", k.Key, k.Value)).ToArray());
|
||||||
|
}
|
||||||
|
|
||||||
|
private static List<TradeRecord> BuildPseudoTradesFromBars(List<BarData> bars, string symbol)
|
||||||
|
{
|
||||||
|
var trades = new List<TradeRecord>();
|
||||||
|
for (var i = 1; i < bars.Count; i++)
|
||||||
|
{
|
||||||
|
var prev = bars[i - 1];
|
||||||
|
var curr = bars[i];
|
||||||
|
|
||||||
|
var trade = new TradeRecord();
|
||||||
|
trade.TradeId = string.Format("WF-{0}", i);
|
||||||
|
trade.Symbol = symbol;
|
||||||
|
trade.StrategyName = "WalkForward";
|
||||||
|
trade.EntryTime = prev.Time;
|
||||||
|
trade.ExitTime = curr.Time;
|
||||||
|
trade.Side = curr.Close >= prev.Close ? Common.Models.OrderSide.Buy : Common.Models.OrderSide.Sell;
|
||||||
|
trade.Quantity = 1;
|
||||||
|
trade.EntryPrice = prev.Close;
|
||||||
|
trade.ExitPrice = curr.Close;
|
||||||
|
trade.RealizedPnL = curr.Close - prev.Close;
|
||||||
|
trade.UnrealizedPnL = 0.0;
|
||||||
|
trade.Grade = trade.RealizedPnL >= 0.0 ? Intelligence.TradeGrade.B : Intelligence.TradeGrade.D;
|
||||||
|
trade.ConfluenceScore = 0.6;
|
||||||
|
trade.RiskMode = Intelligence.RiskMode.PCP;
|
||||||
|
trade.VolatilityRegime = Intelligence.VolatilityRegime.Normal;
|
||||||
|
trade.TrendRegime = Intelligence.TrendRegime.Range;
|
||||||
|
trade.StopTicks = 8;
|
||||||
|
trade.TargetTicks = 16;
|
||||||
|
trade.RMultiple = trade.RealizedPnL / 8.0;
|
||||||
|
trade.Duration = trade.ExitTime.Value - trade.EntryTime;
|
||||||
|
trades.Add(trade);
|
||||||
|
}
|
||||||
|
|
||||||
|
return trades;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static TradeRecord Clone(TradeRecord input)
|
||||||
|
{
|
||||||
|
var copy = new TradeRecord();
|
||||||
|
copy.TradeId = input.TradeId;
|
||||||
|
copy.Symbol = input.Symbol;
|
||||||
|
copy.StrategyName = input.StrategyName;
|
||||||
|
copy.EntryTime = input.EntryTime;
|
||||||
|
copy.ExitTime = input.ExitTime;
|
||||||
|
copy.Side = input.Side;
|
||||||
|
copy.Quantity = input.Quantity;
|
||||||
|
copy.EntryPrice = input.EntryPrice;
|
||||||
|
copy.ExitPrice = input.ExitPrice;
|
||||||
|
copy.RealizedPnL = input.RealizedPnL;
|
||||||
|
copy.UnrealizedPnL = input.UnrealizedPnL;
|
||||||
|
copy.Grade = input.Grade;
|
||||||
|
copy.ConfluenceScore = input.ConfluenceScore;
|
||||||
|
copy.RiskMode = input.RiskMode;
|
||||||
|
copy.VolatilityRegime = input.VolatilityRegime;
|
||||||
|
copy.TrendRegime = input.TrendRegime;
|
||||||
|
copy.StopTicks = input.StopTicks;
|
||||||
|
copy.TargetTicks = input.TargetTicks;
|
||||||
|
copy.RMultiple = input.RMultiple;
|
||||||
|
copy.Duration = input.Duration;
|
||||||
|
copy.Metadata = new Dictionary<string, object>(input.Metadata);
|
||||||
|
return copy;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
269
src/NT8.Core/Analytics/PerformanceCalculator.cs
Normal file
269
src/NT8.Core/Analytics/PerformanceCalculator.cs
Normal file
@@ -0,0 +1,269 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates aggregate performance metrics for trade sets.
|
||||||
|
/// </summary>
|
||||||
|
public class PerformanceCalculator
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Initializes a new calculator instance.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="logger">Logger dependency.</param>
|
||||||
|
public PerformanceCalculator(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates all core metrics from trades.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Performance metrics snapshot.</returns>
|
||||||
|
public PerformanceMetrics Calculate(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var metrics = new PerformanceMetrics();
|
||||||
|
metrics.TotalTrades = trades.Count;
|
||||||
|
metrics.Wins = trades.Count(t => t.RealizedPnL > 0.0);
|
||||||
|
metrics.Losses = trades.Count(t => t.RealizedPnL < 0.0);
|
||||||
|
metrics.WinRate = CalculateWinRate(trades);
|
||||||
|
metrics.LossRate = metrics.TotalTrades > 0 ? (double)metrics.Losses / metrics.TotalTrades : 0.0;
|
||||||
|
|
||||||
|
metrics.GrossProfit = trades.Where(t => t.RealizedPnL > 0.0).Sum(t => t.RealizedPnL);
|
||||||
|
metrics.GrossLoss = Math.Abs(trades.Where(t => t.RealizedPnL < 0.0).Sum(t => t.RealizedPnL));
|
||||||
|
metrics.NetProfit = metrics.GrossProfit - metrics.GrossLoss;
|
||||||
|
|
||||||
|
metrics.AverageWin = metrics.Wins > 0
|
||||||
|
? trades.Where(t => t.RealizedPnL > 0.0).Average(t => t.RealizedPnL)
|
||||||
|
: 0.0;
|
||||||
|
metrics.AverageLoss = metrics.Losses > 0
|
||||||
|
? Math.Abs(trades.Where(t => t.RealizedPnL < 0.0).Average(t => t.RealizedPnL))
|
||||||
|
: 0.0;
|
||||||
|
|
||||||
|
metrics.ProfitFactor = CalculateProfitFactor(trades);
|
||||||
|
metrics.Expectancy = CalculateExpectancy(trades);
|
||||||
|
metrics.SharpeRatio = CalculateSharpeRatio(trades, 0.0);
|
||||||
|
metrics.SortinoRatio = CalculateSortinoRatio(trades, 0.0);
|
||||||
|
metrics.MaxDrawdownPercent = CalculateMaxDrawdown(trades);
|
||||||
|
metrics.RecoveryFactor = metrics.MaxDrawdownPercent > 0.0
|
||||||
|
? metrics.NetProfit / metrics.MaxDrawdownPercent
|
||||||
|
: 0.0;
|
||||||
|
|
||||||
|
return metrics;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("Calculate performance metrics failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates win rate.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Win rate in range [0,1].</returns>
|
||||||
|
public double CalculateWinRate(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (trades.Count == 0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
var wins = trades.Count(t => t.RealizedPnL > 0.0);
|
||||||
|
return (double)wins / trades.Count;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateWinRate failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates profit factor.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Profit factor ratio.</returns>
|
||||||
|
public double CalculateProfitFactor(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var grossProfit = trades.Where(t => t.RealizedPnL > 0.0).Sum(t => t.RealizedPnL);
|
||||||
|
var grossLoss = Math.Abs(trades.Where(t => t.RealizedPnL < 0.0).Sum(t => t.RealizedPnL));
|
||||||
|
if (grossLoss <= 0.0)
|
||||||
|
return grossProfit > 0.0 ? double.PositiveInfinity : 0.0;
|
||||||
|
|
||||||
|
return grossProfit / grossLoss;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateProfitFactor failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates expectancy per trade.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Expectancy value.</returns>
|
||||||
|
public double CalculateExpectancy(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (trades.Count == 0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
var wins = trades.Where(t => t.RealizedPnL > 0.0).ToList();
|
||||||
|
var losses = trades.Where(t => t.RealizedPnL < 0.0).ToList();
|
||||||
|
|
||||||
|
var winRate = (double)wins.Count / trades.Count;
|
||||||
|
var lossRate = (double)losses.Count / trades.Count;
|
||||||
|
var avgWin = wins.Count > 0 ? wins.Average(t => t.RealizedPnL) : 0.0;
|
||||||
|
var avgLoss = losses.Count > 0 ? Math.Abs(losses.Average(t => t.RealizedPnL)) : 0.0;
|
||||||
|
|
||||||
|
return (winRate * avgWin) - (lossRate * avgLoss);
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateExpectancy failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates Sharpe ratio.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <param name="riskFreeRate">Risk free return per trade period.</param>
|
||||||
|
/// <returns>Sharpe ratio value.</returns>
|
||||||
|
public double CalculateSharpeRatio(List<TradeRecord> trades, double riskFreeRate)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (trades.Count < 2)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
var returns = trades.Select(t => t.RealizedPnL).ToList();
|
||||||
|
var mean = returns.Average();
|
||||||
|
var variance = returns.Sum(r => (r - mean) * (r - mean)) / (returns.Count - 1);
|
||||||
|
var stdDev = Math.Sqrt(variance);
|
||||||
|
if (stdDev <= 0.0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
return (mean - riskFreeRate) / stdDev;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateSharpeRatio failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates Sortino ratio.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <param name="riskFreeRate">Risk free return per trade period.</param>
|
||||||
|
/// <returns>Sortino ratio value.</returns>
|
||||||
|
public double CalculateSortinoRatio(List<TradeRecord> trades, double riskFreeRate)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (trades.Count < 2)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
var returns = trades.Select(t => t.RealizedPnL).ToList();
|
||||||
|
var mean = returns.Average();
|
||||||
|
var downside = returns.Where(r => r < riskFreeRate).ToList();
|
||||||
|
if (downside.Count == 0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
var downsideVariance = downside.Sum(r => (r - riskFreeRate) * (r - riskFreeRate)) / downside.Count;
|
||||||
|
var downsideDev = Math.Sqrt(downsideVariance);
|
||||||
|
if (downsideDev <= 0.0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
return (mean - riskFreeRate) / downsideDev;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateSortinoRatio failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Calculates maximum drawdown percent from cumulative realized PnL.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Max drawdown in percent points.</returns>
|
||||||
|
public double CalculateMaxDrawdown(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (trades.Count == 0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
var ordered = trades.OrderBy(t => t.ExitTime.HasValue ? t.ExitTime.Value : t.EntryTime).ToList();
|
||||||
|
var equity = 0.0;
|
||||||
|
var peak = 0.0;
|
||||||
|
var maxDrawdown = 0.0;
|
||||||
|
|
||||||
|
foreach (var trade in ordered)
|
||||||
|
{
|
||||||
|
equity += trade.RealizedPnL;
|
||||||
|
if (equity > peak)
|
||||||
|
peak = equity;
|
||||||
|
|
||||||
|
var drawdown = peak - equity;
|
||||||
|
if (drawdown > maxDrawdown)
|
||||||
|
maxDrawdown = drawdown;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (peak <= 0.0)
|
||||||
|
return maxDrawdown;
|
||||||
|
|
||||||
|
return (maxDrawdown / peak) * 100.0;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculateMaxDrawdown failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
199
src/NT8.Core/Analytics/PnLAttributor.cs
Normal file
199
src/NT8.Core/Analytics/PnLAttributor.cs
Normal file
@@ -0,0 +1,199 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Provides PnL attribution analysis across multiple dimensions.
|
||||||
|
/// </summary>
|
||||||
|
public class PnLAttributor
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Initializes a new attributor instance.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="logger">Logger dependency.</param>
|
||||||
|
public PnLAttributor(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Attributes PnL by trade grade.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Attribution report.</returns>
|
||||||
|
public AttributionReport AttributeByGrade(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
return BuildReport(trades, AttributionDimension.Grade, t => t.Grade.ToString());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Attributes PnL by combined volatility and trend regime.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Attribution report.</returns>
|
||||||
|
public AttributionReport AttributeByRegime(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
return BuildReport(
|
||||||
|
trades,
|
||||||
|
AttributionDimension.Regime,
|
||||||
|
t => string.Format("{0}|{1}", t.VolatilityRegime, t.TrendRegime));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Attributes PnL by strategy name.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Attribution report.</returns>
|
||||||
|
public AttributionReport AttributeByStrategy(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
return BuildReport(trades, AttributionDimension.Strategy, t => t.StrategyName ?? string.Empty);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Attributes PnL by time-of-day bucket.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <returns>Attribution report.</returns>
|
||||||
|
public AttributionReport AttributeByTimeOfDay(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
return BuildReport(trades, AttributionDimension.Time, GetTimeBucket);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Attributes PnL by a multi-dimensional combined key.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="trades">Trade records.</param>
|
||||||
|
/// <param name="dimensions">Dimensions to combine.</param>
|
||||||
|
/// <returns>Attribution report.</returns>
|
||||||
|
public AttributionReport AttributeMultiDimensional(List<TradeRecord> trades, List<AttributionDimension> dimensions)
|
||||||
|
{
|
||||||
|
if (dimensions == null)
|
||||||
|
throw new ArgumentNullException("dimensions");
|
||||||
|
if (dimensions.Count == 0)
|
||||||
|
throw new ArgumentException("At least one dimension is required", "dimensions");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
return BuildReport(trades, AttributionDimension.Strategy, delegate(TradeRecord trade)
|
||||||
|
{
|
||||||
|
var parts = new List<string>();
|
||||||
|
foreach (var dimension in dimensions)
|
||||||
|
{
|
||||||
|
parts.Add(GetDimensionValue(trade, dimension));
|
||||||
|
}
|
||||||
|
|
||||||
|
return string.Join("|", parts.ToArray());
|
||||||
|
});
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("AttributeMultiDimensional failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private AttributionReport BuildReport(
|
||||||
|
List<TradeRecord> trades,
|
||||||
|
AttributionDimension dimension,
|
||||||
|
Func<TradeRecord, string> keySelector)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
if (keySelector == null)
|
||||||
|
throw new ArgumentNullException("keySelector");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var report = new AttributionReport();
|
||||||
|
report.Dimension = dimension;
|
||||||
|
report.TotalTrades = trades.Count;
|
||||||
|
report.TotalPnL = trades.Sum(t => t.RealizedPnL);
|
||||||
|
|
||||||
|
var groups = trades.GroupBy(keySelector).ToList();
|
||||||
|
foreach (var group in groups)
|
||||||
|
{
|
||||||
|
var tradeList = group.ToList();
|
||||||
|
var totalPnL = tradeList.Sum(t => t.RealizedPnL);
|
||||||
|
var wins = tradeList.Count(t => t.RealizedPnL > 0.0);
|
||||||
|
var losses = tradeList.Count(t => t.RealizedPnL < 0.0);
|
||||||
|
var grossProfit = tradeList.Where(t => t.RealizedPnL > 0.0).Sum(t => t.RealizedPnL);
|
||||||
|
var grossLoss = Math.Abs(tradeList.Where(t => t.RealizedPnL < 0.0).Sum(t => t.RealizedPnL));
|
||||||
|
|
||||||
|
var slice = new AttributionSlice();
|
||||||
|
slice.DimensionName = dimension.ToString();
|
||||||
|
slice.DimensionValue = group.Key;
|
||||||
|
slice.TotalPnL = totalPnL;
|
||||||
|
slice.TradeCount = tradeList.Count;
|
||||||
|
slice.AvgPnL = tradeList.Count > 0 ? totalPnL / tradeList.Count : 0.0;
|
||||||
|
slice.WinRate = tradeList.Count > 0 ? (double)wins / tradeList.Count : 0.0;
|
||||||
|
slice.ProfitFactor = grossLoss > 0.0
|
||||||
|
? grossProfit / grossLoss
|
||||||
|
: (grossProfit > 0.0 ? double.PositiveInfinity : 0.0);
|
||||||
|
slice.Contribution = report.TotalPnL != 0.0 ? totalPnL / report.TotalPnL : 0.0;
|
||||||
|
|
||||||
|
report.Slices.Add(slice);
|
||||||
|
}
|
||||||
|
|
||||||
|
report.Slices = report.Slices
|
||||||
|
.OrderByDescending(s => s.TotalPnL)
|
||||||
|
.ToList();
|
||||||
|
|
||||||
|
report.Metadata.Add("group_count", report.Slices.Count);
|
||||||
|
report.Metadata.Add("winners", trades.Count(t => t.RealizedPnL > 0.0));
|
||||||
|
report.Metadata.Add("losers", trades.Count(t => t.RealizedPnL < 0.0));
|
||||||
|
|
||||||
|
return report;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("BuildReport failed for dimension {0}: {1}", dimension, ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static string GetTimeBucket(TradeRecord trade)
|
||||||
|
{
|
||||||
|
var local = trade.EntryTime;
|
||||||
|
var time = local.TimeOfDay;
|
||||||
|
|
||||||
|
if (time < new TimeSpan(10, 30, 0))
|
||||||
|
return "FirstHour";
|
||||||
|
if (time < new TimeSpan(14, 0, 0))
|
||||||
|
return "MidDay";
|
||||||
|
if (time < new TimeSpan(16, 0, 0))
|
||||||
|
return "LastHour";
|
||||||
|
|
||||||
|
return "AfterHours";
|
||||||
|
}
|
||||||
|
|
||||||
|
private static string GetDimensionValue(TradeRecord trade, AttributionDimension dimension)
|
||||||
|
{
|
||||||
|
switch (dimension)
|
||||||
|
{
|
||||||
|
case AttributionDimension.Strategy:
|
||||||
|
return trade.StrategyName ?? string.Empty;
|
||||||
|
case AttributionDimension.Grade:
|
||||||
|
return trade.Grade.ToString();
|
||||||
|
case AttributionDimension.Regime:
|
||||||
|
return string.Format("{0}|{1}", trade.VolatilityRegime, trade.TrendRegime);
|
||||||
|
case AttributionDimension.Time:
|
||||||
|
return GetTimeBucket(trade);
|
||||||
|
case AttributionDimension.Symbol:
|
||||||
|
return trade.Symbol ?? string.Empty;
|
||||||
|
case AttributionDimension.RiskMode:
|
||||||
|
return trade.RiskMode.ToString();
|
||||||
|
default:
|
||||||
|
return string.Empty;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
194
src/NT8.Core/Analytics/PortfolioOptimizer.cs
Normal file
194
src/NT8.Core/Analytics/PortfolioOptimizer.cs
Normal file
@@ -0,0 +1,194 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Strategy performance summary for portfolio optimization.
|
||||||
|
/// </summary>
|
||||||
|
public class StrategyPerformance
|
||||||
|
{
|
||||||
|
public string StrategyName { get; set; }
|
||||||
|
public double MeanReturn { get; set; }
|
||||||
|
public double StdDevReturn { get; set; }
|
||||||
|
public double Sharpe { get; set; }
|
||||||
|
public Dictionary<string, double> Correlations { get; set; }
|
||||||
|
|
||||||
|
public StrategyPerformance()
|
||||||
|
{
|
||||||
|
Correlations = new Dictionary<string, double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Portfolio allocation optimization result.
|
||||||
|
/// </summary>
|
||||||
|
public class AllocationResult
|
||||||
|
{
|
||||||
|
public Dictionary<string, double> Allocation { get; set; }
|
||||||
|
public double ExpectedSharpe { get; set; }
|
||||||
|
|
||||||
|
public AllocationResult()
|
||||||
|
{
|
||||||
|
Allocation = new Dictionary<string, double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Optimizes allocations across multiple strategies.
|
||||||
|
/// </summary>
|
||||||
|
public class PortfolioOptimizer
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
|
||||||
|
public PortfolioOptimizer(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Returns a Sharpe-weighted allocation.
|
||||||
|
/// </summary>
|
||||||
|
public AllocationResult OptimizeAllocation(List<StrategyPerformance> strategies)
|
||||||
|
{
|
||||||
|
if (strategies == null)
|
||||||
|
throw new ArgumentNullException("strategies");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var result = new AllocationResult();
|
||||||
|
if (strategies.Count == 0)
|
||||||
|
return result;
|
||||||
|
|
||||||
|
var positive = strategies.Select(s => new
|
||||||
|
{
|
||||||
|
Name = s.StrategyName,
|
||||||
|
Score = Math.Max(0.0001, s.Sharpe)
|
||||||
|
}).ToList();
|
||||||
|
|
||||||
|
var total = positive.Sum(s => s.Score);
|
||||||
|
foreach (var s in positive)
|
||||||
|
{
|
||||||
|
result.Allocation[s.Name] = s.Score / total;
|
||||||
|
}
|
||||||
|
|
||||||
|
result.ExpectedSharpe = CalculatePortfolioSharpe(result.Allocation, strategies);
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("OptimizeAllocation failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Computes approximate portfolio Sharpe.
|
||||||
|
/// </summary>
|
||||||
|
public double CalculatePortfolioSharpe(Dictionary<string, double> allocation, List<StrategyPerformance> strategies)
|
||||||
|
{
|
||||||
|
if (allocation == null)
|
||||||
|
throw new ArgumentNullException("allocation");
|
||||||
|
if (strategies == null)
|
||||||
|
throw new ArgumentNullException("strategies");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
if (allocation.Count == 0 || strategies.Count == 0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
var byName = strategies.ToDictionary(s => s.StrategyName, s => s);
|
||||||
|
|
||||||
|
var mean = 0.0;
|
||||||
|
foreach (var kv in allocation)
|
||||||
|
{
|
||||||
|
if (byName.ContainsKey(kv.Key))
|
||||||
|
mean += kv.Value * byName[kv.Key].MeanReturn;
|
||||||
|
}
|
||||||
|
|
||||||
|
var variance = 0.0;
|
||||||
|
foreach (var i in allocation)
|
||||||
|
{
|
||||||
|
if (!byName.ContainsKey(i.Key))
|
||||||
|
continue;
|
||||||
|
|
||||||
|
var si = byName[i.Key];
|
||||||
|
foreach (var j in allocation)
|
||||||
|
{
|
||||||
|
if (!byName.ContainsKey(j.Key))
|
||||||
|
continue;
|
||||||
|
|
||||||
|
var sj = byName[j.Key];
|
||||||
|
var corr = 0.0;
|
||||||
|
if (i.Key == j.Key)
|
||||||
|
{
|
||||||
|
corr = 1.0;
|
||||||
|
}
|
||||||
|
else if (si.Correlations.ContainsKey(j.Key))
|
||||||
|
{
|
||||||
|
corr = si.Correlations[j.Key];
|
||||||
|
}
|
||||||
|
else if (sj.Correlations.ContainsKey(i.Key))
|
||||||
|
{
|
||||||
|
corr = sj.Correlations[i.Key];
|
||||||
|
}
|
||||||
|
|
||||||
|
variance += i.Value * j.Value * si.StdDevReturn * sj.StdDevReturn * corr;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var std = variance > 0.0 ? Math.Sqrt(variance) : 0.0;
|
||||||
|
if (std <= 0.0)
|
||||||
|
return 0.0;
|
||||||
|
|
||||||
|
return mean / std;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("CalculatePortfolioSharpe failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Computes inverse-volatility risk parity allocation.
|
||||||
|
/// </summary>
|
||||||
|
public Dictionary<string, double> RiskParityAllocation(List<StrategyPerformance> strategies)
|
||||||
|
{
|
||||||
|
if (strategies == null)
|
||||||
|
throw new ArgumentNullException("strategies");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var result = new Dictionary<string, double>();
|
||||||
|
if (strategies.Count == 0)
|
||||||
|
return result;
|
||||||
|
|
||||||
|
var invVol = new Dictionary<string, double>();
|
||||||
|
foreach (var s in strategies)
|
||||||
|
{
|
||||||
|
var vol = s.StdDevReturn > 0.000001 ? s.StdDevReturn : 0.000001;
|
||||||
|
invVol[s.StrategyName] = 1.0 / vol;
|
||||||
|
}
|
||||||
|
|
||||||
|
var total = invVol.Sum(v => v.Value);
|
||||||
|
foreach (var kv in invVol)
|
||||||
|
{
|
||||||
|
result[kv.Key] = kv.Value / total;
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("RiskParityAllocation failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
163
src/NT8.Core/Analytics/RegimePerformanceAnalyzer.cs
Normal file
163
src/NT8.Core/Analytics/RegimePerformanceAnalyzer.cs
Normal file
@@ -0,0 +1,163 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Regime transition impact summary.
|
||||||
|
/// </summary>
|
||||||
|
public class RegimeTransitionImpact
|
||||||
|
{
|
||||||
|
public string FromRegime { get; set; }
|
||||||
|
public string ToRegime { get; set; }
|
||||||
|
public int TradeCount { get; set; }
|
||||||
|
public double TotalPnL { get; set; }
|
||||||
|
public double AvgPnL { get; set; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Regime performance report.
|
||||||
|
/// </summary>
|
||||||
|
public class RegimePerformanceReport
|
||||||
|
{
|
||||||
|
public Dictionary<string, PerformanceMetrics> CombinedMetrics { get; set; }
|
||||||
|
public Dictionary<VolatilityRegime, PerformanceMetrics> VolatilityMetrics { get; set; }
|
||||||
|
public Dictionary<TrendRegime, PerformanceMetrics> TrendMetrics { get; set; }
|
||||||
|
public List<RegimeTransitionImpact> TransitionImpacts { get; set; }
|
||||||
|
|
||||||
|
public RegimePerformanceReport()
|
||||||
|
{
|
||||||
|
CombinedMetrics = new Dictionary<string, PerformanceMetrics>();
|
||||||
|
VolatilityMetrics = new Dictionary<VolatilityRegime, PerformanceMetrics>();
|
||||||
|
TrendMetrics = new Dictionary<TrendRegime, PerformanceMetrics>();
|
||||||
|
TransitionImpacts = new List<RegimeTransitionImpact>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Analyzer for volatility and trend regime trade outcomes.
|
||||||
|
/// </summary>
|
||||||
|
public class RegimePerformanceAnalyzer
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
private readonly PerformanceCalculator _calculator;
|
||||||
|
|
||||||
|
public RegimePerformanceAnalyzer(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
_calculator = new PerformanceCalculator(logger);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Produces report by individual and combined regimes.
|
||||||
|
/// </summary>
|
||||||
|
public RegimePerformanceReport AnalyzeByRegime(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var report = new RegimePerformanceReport();
|
||||||
|
|
||||||
|
foreach (VolatilityRegime vol in Enum.GetValues(typeof(VolatilityRegime)))
|
||||||
|
{
|
||||||
|
var subset = trades.Where(t => t.VolatilityRegime == vol).ToList();
|
||||||
|
report.VolatilityMetrics[vol] = _calculator.Calculate(subset);
|
||||||
|
}
|
||||||
|
|
||||||
|
foreach (TrendRegime trend in Enum.GetValues(typeof(TrendRegime)))
|
||||||
|
{
|
||||||
|
var subset = trades.Where(t => t.TrendRegime == trend).ToList();
|
||||||
|
report.TrendMetrics[trend] = _calculator.Calculate(subset);
|
||||||
|
}
|
||||||
|
|
||||||
|
var combined = trades.GroupBy(t => string.Format("{0}|{1}", t.VolatilityRegime, t.TrendRegime));
|
||||||
|
foreach (var group in combined)
|
||||||
|
{
|
||||||
|
report.CombinedMetrics[group.Key] = _calculator.Calculate(group.ToList());
|
||||||
|
}
|
||||||
|
|
||||||
|
report.TransitionImpacts = AnalyzeTransitions(trades);
|
||||||
|
return report;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("AnalyzeByRegime failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets performance for one specific regime combination.
|
||||||
|
/// </summary>
|
||||||
|
public PerformanceMetrics GetPerformance(VolatilityRegime volRegime, TrendRegime trendRegime, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var subset = trades.Where(t => t.VolatilityRegime == volRegime && t.TrendRegime == trendRegime).ToList();
|
||||||
|
return _calculator.Calculate(subset);
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GetPerformance failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Analyzes regime transitions between consecutive trades.
|
||||||
|
/// </summary>
|
||||||
|
public List<RegimeTransitionImpact> AnalyzeTransitions(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var ordered = trades.OrderBy(t => t.EntryTime).ToList();
|
||||||
|
var transitionPnl = new Dictionary<string, List<double>>();
|
||||||
|
|
||||||
|
for (var i = 1; i < ordered.Count; i++)
|
||||||
|
{
|
||||||
|
var from = string.Format("{0}|{1}", ordered[i - 1].VolatilityRegime, ordered[i - 1].TrendRegime);
|
||||||
|
var to = string.Format("{0}|{1}", ordered[i].VolatilityRegime, ordered[i].TrendRegime);
|
||||||
|
var key = string.Format("{0}->{1}", from, to);
|
||||||
|
|
||||||
|
if (!transitionPnl.ContainsKey(key))
|
||||||
|
transitionPnl.Add(key, new List<double>());
|
||||||
|
transitionPnl[key].Add(ordered[i].RealizedPnL);
|
||||||
|
}
|
||||||
|
|
||||||
|
var result = new List<RegimeTransitionImpact>();
|
||||||
|
foreach (var kvp in transitionPnl)
|
||||||
|
{
|
||||||
|
var parts = kvp.Key.Split(new[] {"->"}, StringSplitOptions.None);
|
||||||
|
var impact = new RegimeTransitionImpact();
|
||||||
|
impact.FromRegime = parts[0];
|
||||||
|
impact.ToRegime = parts.Length > 1 ? parts[1] : string.Empty;
|
||||||
|
impact.TradeCount = kvp.Value.Count;
|
||||||
|
impact.TotalPnL = kvp.Value.Sum();
|
||||||
|
impact.AvgPnL = kvp.Value.Count > 0 ? kvp.Value.Average() : 0.0;
|
||||||
|
result.Add(impact);
|
||||||
|
}
|
||||||
|
|
||||||
|
return result.OrderByDescending(r => r.TotalPnL).ToList();
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("AnalyzeTransitions failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
281
src/NT8.Core/Analytics/ReportGenerator.cs
Normal file
281
src/NT8.Core/Analytics/ReportGenerator.cs
Normal file
@@ -0,0 +1,281 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Globalization;
|
||||||
|
using System.Linq;
|
||||||
|
using System.Text;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Generates performance reports and export formats.
|
||||||
|
/// </summary>
|
||||||
|
public class ReportGenerator
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
private readonly PerformanceCalculator _calculator;
|
||||||
|
|
||||||
|
public ReportGenerator(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
_calculator = new PerformanceCalculator(logger);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Generates daily report.
|
||||||
|
/// </summary>
|
||||||
|
public DailyReport GenerateDailyReport(DateTime date, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var dayStart = date.Date;
|
||||||
|
var dayEnd = dayStart.AddDays(1);
|
||||||
|
var subset = trades.Where(t => t.EntryTime >= dayStart && t.EntryTime < dayEnd).ToList();
|
||||||
|
|
||||||
|
var report = new DailyReport();
|
||||||
|
report.Date = dayStart;
|
||||||
|
report.SummaryMetrics = _calculator.Calculate(subset);
|
||||||
|
|
||||||
|
foreach (var g in subset.GroupBy(t => t.Grade.ToString()))
|
||||||
|
{
|
||||||
|
report.GradePnL[g.Key] = g.Sum(t => t.RealizedPnL);
|
||||||
|
}
|
||||||
|
|
||||||
|
return report;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GenerateDailyReport failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Generates weekly report.
|
||||||
|
/// </summary>
|
||||||
|
public WeeklyReport GenerateWeeklyReport(DateTime weekStart, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var start = weekStart.Date;
|
||||||
|
var end = start.AddDays(7);
|
||||||
|
var subset = trades.Where(t => t.EntryTime >= start && t.EntryTime < end).ToList();
|
||||||
|
|
||||||
|
var report = new WeeklyReport();
|
||||||
|
report.WeekStart = start;
|
||||||
|
report.WeekEnd = end.AddTicks(-1);
|
||||||
|
report.SummaryMetrics = _calculator.Calculate(subset);
|
||||||
|
|
||||||
|
foreach (var g in subset.GroupBy(t => t.StrategyName ?? string.Empty))
|
||||||
|
{
|
||||||
|
report.StrategyPnL[g.Key] = g.Sum(t => t.RealizedPnL);
|
||||||
|
}
|
||||||
|
|
||||||
|
return report;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GenerateWeeklyReport failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Generates monthly report.
|
||||||
|
/// </summary>
|
||||||
|
public MonthlyReport GenerateMonthlyReport(int year, int month, List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var start = new DateTime(year, month, 1);
|
||||||
|
var end = start.AddMonths(1);
|
||||||
|
var subset = trades.Where(t => t.EntryTime >= start && t.EntryTime < end).ToList();
|
||||||
|
|
||||||
|
var report = new MonthlyReport();
|
||||||
|
report.Year = year;
|
||||||
|
report.Month = month;
|
||||||
|
report.SummaryMetrics = _calculator.Calculate(subset);
|
||||||
|
|
||||||
|
foreach (var g in subset.GroupBy(t => t.Symbol ?? string.Empty))
|
||||||
|
{
|
||||||
|
report.SymbolPnL[g.Key] = g.Sum(t => t.RealizedPnL);
|
||||||
|
}
|
||||||
|
|
||||||
|
return report;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GenerateMonthlyReport failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Exports report to text format.
|
||||||
|
/// </summary>
|
||||||
|
public string ExportToText(Report report)
|
||||||
|
{
|
||||||
|
if (report == null)
|
||||||
|
throw new ArgumentNullException("report");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var sb = new StringBuilder();
|
||||||
|
sb.AppendLine(string.Format("=== {0} Report ===", report.ReportName));
|
||||||
|
sb.AppendLine(string.Format("Generated: {0:O}", report.GeneratedAtUtc));
|
||||||
|
sb.AppendLine();
|
||||||
|
sb.AppendLine(string.Format("Total Trades: {0}", report.SummaryMetrics.TotalTrades));
|
||||||
|
sb.AppendLine(string.Format("Win Rate: {0:P2}", report.SummaryMetrics.WinRate));
|
||||||
|
sb.AppendLine(string.Format(CultureInfo.InvariantCulture, "Net Profit: {0:F2}", report.SummaryMetrics.NetProfit));
|
||||||
|
sb.AppendLine(string.Format(CultureInfo.InvariantCulture, "Profit Factor: {0:F2}", report.SummaryMetrics.ProfitFactor));
|
||||||
|
sb.AppendLine(string.Format(CultureInfo.InvariantCulture, "Expectancy: {0:F2}", report.SummaryMetrics.Expectancy));
|
||||||
|
sb.AppendLine(string.Format(CultureInfo.InvariantCulture, "Max Drawdown %: {0:F2}", report.SummaryMetrics.MaxDrawdownPercent));
|
||||||
|
return sb.ToString();
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("ExportToText failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Exports trade records to CSV.
|
||||||
|
/// </summary>
|
||||||
|
public string ExportToCsv(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var sb = new StringBuilder();
|
||||||
|
sb.AppendLine("TradeId,Symbol,Strategy,EntryTime,ExitTime,Side,Qty,Entry,Exit,PnL,RMultiple,Grade,RiskMode");
|
||||||
|
|
||||||
|
foreach (var t in trades.OrderBy(x => x.EntryTime))
|
||||||
|
{
|
||||||
|
sb.AppendFormat(CultureInfo.InvariantCulture,
|
||||||
|
"{0},{1},{2},{3:O},{4},{5},{6},{7:F4},{8},{9:F2},{10:F4},{11},{12}",
|
||||||
|
Escape(t.TradeId),
|
||||||
|
Escape(t.Symbol),
|
||||||
|
Escape(t.StrategyName),
|
||||||
|
t.EntryTime,
|
||||||
|
t.ExitTime.HasValue ? t.ExitTime.Value.ToString("O") : string.Empty,
|
||||||
|
t.Side,
|
||||||
|
t.Quantity,
|
||||||
|
t.EntryPrice,
|
||||||
|
t.ExitPrice.HasValue ? t.ExitPrice.Value.ToString("F4", CultureInfo.InvariantCulture) : string.Empty,
|
||||||
|
t.RealizedPnL,
|
||||||
|
t.RMultiple,
|
||||||
|
t.Grade,
|
||||||
|
t.RiskMode);
|
||||||
|
sb.AppendLine();
|
||||||
|
}
|
||||||
|
|
||||||
|
return sb.ToString();
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("ExportToCsv failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Exports report summary to JSON.
|
||||||
|
/// </summary>
|
||||||
|
public string ExportToJson(Report report)
|
||||||
|
{
|
||||||
|
if (report == null)
|
||||||
|
throw new ArgumentNullException("report");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var json = new StringBuilder();
|
||||||
|
json.Append("{");
|
||||||
|
json.AppendFormat(CultureInfo.InvariantCulture, "\"reportName\":\"{0}\"", EscapeJson(report.ReportName));
|
||||||
|
json.AppendFormat(CultureInfo.InvariantCulture, ",\"generatedAtUtc\":\"{0:O}\"", report.GeneratedAtUtc);
|
||||||
|
json.Append(",\"summary\":{");
|
||||||
|
json.AppendFormat(CultureInfo.InvariantCulture, "\"totalTrades\":{0}", report.SummaryMetrics.TotalTrades);
|
||||||
|
json.AppendFormat(CultureInfo.InvariantCulture, ",\"winRate\":{0}", report.SummaryMetrics.WinRate);
|
||||||
|
json.AppendFormat(CultureInfo.InvariantCulture, ",\"netProfit\":{0}", report.SummaryMetrics.NetProfit);
|
||||||
|
json.AppendFormat(CultureInfo.InvariantCulture, ",\"profitFactor\":{0}", report.SummaryMetrics.ProfitFactor);
|
||||||
|
json.AppendFormat(CultureInfo.InvariantCulture, ",\"expectancy\":{0}", report.SummaryMetrics.Expectancy);
|
||||||
|
json.Append("}");
|
||||||
|
json.Append("}");
|
||||||
|
return json.ToString();
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("ExportToJson failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Builds equity curve points from realized pnl.
|
||||||
|
/// </summary>
|
||||||
|
public EquityCurve BuildEquityCurve(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var curve = new EquityCurve();
|
||||||
|
var equity = 0.0;
|
||||||
|
var peak = 0.0;
|
||||||
|
|
||||||
|
foreach (var trade in trades.OrderBy(t => t.ExitTime.HasValue ? t.ExitTime.Value : t.EntryTime))
|
||||||
|
{
|
||||||
|
equity += trade.RealizedPnL;
|
||||||
|
if (equity > peak)
|
||||||
|
peak = equity;
|
||||||
|
|
||||||
|
var point = new EquityPoint();
|
||||||
|
point.Time = trade.ExitTime.HasValue ? trade.ExitTime.Value : trade.EntryTime;
|
||||||
|
point.Equity = equity;
|
||||||
|
point.Drawdown = peak - equity;
|
||||||
|
curve.Points.Add(point);
|
||||||
|
}
|
||||||
|
|
||||||
|
return curve;
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("BuildEquityCurve failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static string Escape(string value)
|
||||||
|
{
|
||||||
|
if (value == null)
|
||||||
|
return string.Empty;
|
||||||
|
|
||||||
|
if (value.Contains(",") || value.Contains("\"") || value.Contains("\n") || value.Contains("\r"))
|
||||||
|
return string.Format("\"{0}\"", value.Replace("\"", "\"\""));
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static string EscapeJson(string value)
|
||||||
|
{
|
||||||
|
if (value == null)
|
||||||
|
return string.Empty;
|
||||||
|
|
||||||
|
return value.Replace("\\", "\\\\").Replace("\"", "\\\"");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
115
src/NT8.Core/Analytics/ReportModels.cs
Normal file
115
src/NT8.Core/Analytics/ReportModels.cs
Normal file
@@ -0,0 +1,115 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Base report model.
|
||||||
|
/// </summary>
|
||||||
|
public class Report
|
||||||
|
{
|
||||||
|
public string ReportName { get; set; }
|
||||||
|
public DateTime GeneratedAtUtc { get; set; }
|
||||||
|
public PerformanceMetrics SummaryMetrics { get; set; }
|
||||||
|
|
||||||
|
public Report()
|
||||||
|
{
|
||||||
|
GeneratedAtUtc = DateTime.UtcNow;
|
||||||
|
SummaryMetrics = new PerformanceMetrics();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Daily report.
|
||||||
|
/// </summary>
|
||||||
|
public class DailyReport : Report
|
||||||
|
{
|
||||||
|
public DateTime Date { get; set; }
|
||||||
|
public Dictionary<string, double> GradePnL { get; set; }
|
||||||
|
|
||||||
|
public DailyReport()
|
||||||
|
{
|
||||||
|
ReportName = "Daily";
|
||||||
|
GradePnL = new Dictionary<string, double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Weekly report.
|
||||||
|
/// </summary>
|
||||||
|
public class WeeklyReport : Report
|
||||||
|
{
|
||||||
|
public DateTime WeekStart { get; set; }
|
||||||
|
public DateTime WeekEnd { get; set; }
|
||||||
|
public Dictionary<string, double> StrategyPnL { get; set; }
|
||||||
|
|
||||||
|
public WeeklyReport()
|
||||||
|
{
|
||||||
|
ReportName = "Weekly";
|
||||||
|
StrategyPnL = new Dictionary<string, double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Monthly report.
|
||||||
|
/// </summary>
|
||||||
|
public class MonthlyReport : Report
|
||||||
|
{
|
||||||
|
public int Year { get; set; }
|
||||||
|
public int Month { get; set; }
|
||||||
|
public Dictionary<string, double> SymbolPnL { get; set; }
|
||||||
|
|
||||||
|
public MonthlyReport()
|
||||||
|
{
|
||||||
|
ReportName = "Monthly";
|
||||||
|
SymbolPnL = new Dictionary<string, double>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trade blotter representation.
|
||||||
|
/// </summary>
|
||||||
|
public class TradeBlotterReport
|
||||||
|
{
|
||||||
|
public DateTime GeneratedAtUtc { get; set; }
|
||||||
|
public List<TradeRecord> Trades { get; set; }
|
||||||
|
|
||||||
|
public TradeBlotterReport()
|
||||||
|
{
|
||||||
|
GeneratedAtUtc = DateTime.UtcNow;
|
||||||
|
Trades = new List<TradeRecord>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Equity curve point series.
|
||||||
|
/// </summary>
|
||||||
|
public class EquityCurve
|
||||||
|
{
|
||||||
|
public List<EquityPoint> Points { get; set; }
|
||||||
|
|
||||||
|
public EquityCurve()
|
||||||
|
{
|
||||||
|
Points = new List<EquityPoint>();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Equity point model.
|
||||||
|
/// </summary>
|
||||||
|
public class EquityPoint
|
||||||
|
{
|
||||||
|
public DateTime Time { get; set; }
|
||||||
|
public double Equity { get; set; }
|
||||||
|
public double Drawdown { get; set; }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Sort direction.
|
||||||
|
/// </summary>
|
||||||
|
public enum SortDirection
|
||||||
|
{
|
||||||
|
Asc,
|
||||||
|
Desc
|
||||||
|
}
|
||||||
|
}
|
||||||
264
src/NT8.Core/Analytics/TradeBlotter.cs
Normal file
264
src/NT8.Core/Analytics/TradeBlotter.cs
Normal file
@@ -0,0 +1,264 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Linq;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Filterable and sortable trade blotter service.
|
||||||
|
/// </summary>
|
||||||
|
public class TradeBlotter
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
private readonly object _lock;
|
||||||
|
private readonly List<TradeRecord> _trades;
|
||||||
|
|
||||||
|
public TradeBlotter(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
_lock = new object();
|
||||||
|
_trades = new List<TradeRecord>();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Replaces blotter trade set.
|
||||||
|
/// </summary>
|
||||||
|
public void SetTrades(List<TradeRecord> trades)
|
||||||
|
{
|
||||||
|
if (trades == null)
|
||||||
|
throw new ArgumentNullException("trades");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
_trades.Clear();
|
||||||
|
_trades.AddRange(trades.Select(Clone));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("SetTrades failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Appends one trade and supports real-time update flow.
|
||||||
|
/// </summary>
|
||||||
|
public void AddOrUpdateTrade(TradeRecord trade)
|
||||||
|
{
|
||||||
|
if (trade == null)
|
||||||
|
throw new ArgumentNullException("trade");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
var index = _trades.FindIndex(t => t.TradeId == trade.TradeId);
|
||||||
|
if (index >= 0)
|
||||||
|
_trades[index] = Clone(trade);
|
||||||
|
else
|
||||||
|
_trades.Add(Clone(trade));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("AddOrUpdateTrade failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Filters by date range.
|
||||||
|
/// </summary>
|
||||||
|
public List<TradeRecord> FilterByDate(DateTime start, DateTime end)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
return _trades
|
||||||
|
.Where(t => t.EntryTime >= start && t.EntryTime <= end)
|
||||||
|
.OrderBy(t => t.EntryTime)
|
||||||
|
.Select(Clone)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("FilterByDate failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Filters by symbol.
|
||||||
|
/// </summary>
|
||||||
|
public List<TradeRecord> FilterBySymbol(string symbol)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(symbol))
|
||||||
|
throw new ArgumentNullException("symbol");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
return _trades
|
||||||
|
.Where(t => string.Equals(t.Symbol, symbol, StringComparison.OrdinalIgnoreCase))
|
||||||
|
.OrderBy(t => t.EntryTime)
|
||||||
|
.Select(Clone)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("FilterBySymbol failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Filters by grade.
|
||||||
|
/// </summary>
|
||||||
|
public List<TradeRecord> FilterByGrade(TradeGrade grade)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
return _trades
|
||||||
|
.Where(t => t.Grade == grade)
|
||||||
|
.OrderBy(t => t.EntryTime)
|
||||||
|
.Select(Clone)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("FilterByGrade failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Filters by realized pnl range.
|
||||||
|
/// </summary>
|
||||||
|
public List<TradeRecord> FilterByPnL(double minPnL, double maxPnL)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
return _trades
|
||||||
|
.Where(t => t.RealizedPnL >= minPnL && t.RealizedPnL <= maxPnL)
|
||||||
|
.OrderBy(t => t.EntryTime)
|
||||||
|
.Select(Clone)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("FilterByPnL failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Sorts by named column.
|
||||||
|
/// </summary>
|
||||||
|
public List<TradeRecord> SortBy(string column, SortDirection direction)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(column))
|
||||||
|
throw new ArgumentNullException("column");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
IEnumerable<TradeRecord> ordered;
|
||||||
|
var normalized = column.Trim().ToLowerInvariant();
|
||||||
|
|
||||||
|
switch (normalized)
|
||||||
|
{
|
||||||
|
case "time":
|
||||||
|
case "entrytime":
|
||||||
|
ordered = direction == SortDirection.Asc
|
||||||
|
? _trades.OrderBy(t => t.EntryTime)
|
||||||
|
: _trades.OrderByDescending(t => t.EntryTime);
|
||||||
|
break;
|
||||||
|
case "symbol":
|
||||||
|
ordered = direction == SortDirection.Asc
|
||||||
|
? _trades.OrderBy(t => t.Symbol)
|
||||||
|
: _trades.OrderByDescending(t => t.Symbol);
|
||||||
|
break;
|
||||||
|
case "pnl":
|
||||||
|
ordered = direction == SortDirection.Asc
|
||||||
|
? _trades.OrderBy(t => t.RealizedPnL)
|
||||||
|
: _trades.OrderByDescending(t => t.RealizedPnL);
|
||||||
|
break;
|
||||||
|
case "grade":
|
||||||
|
ordered = direction == SortDirection.Asc
|
||||||
|
? _trades.OrderBy(t => t.Grade)
|
||||||
|
: _trades.OrderByDescending(t => t.Grade);
|
||||||
|
break;
|
||||||
|
case "rmultiple":
|
||||||
|
ordered = direction == SortDirection.Asc
|
||||||
|
? _trades.OrderBy(t => t.RMultiple)
|
||||||
|
: _trades.OrderByDescending(t => t.RMultiple);
|
||||||
|
break;
|
||||||
|
case "duration":
|
||||||
|
ordered = direction == SortDirection.Asc
|
||||||
|
? _trades.OrderBy(t => t.Duration)
|
||||||
|
: _trades.OrderByDescending(t => t.Duration);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
ordered = direction == SortDirection.Asc
|
||||||
|
? _trades.OrderBy(t => t.EntryTime)
|
||||||
|
: _trades.OrderByDescending(t => t.EntryTime);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return ordered.Select(Clone).ToList();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("SortBy failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static TradeRecord Clone(TradeRecord input)
|
||||||
|
{
|
||||||
|
var copy = new TradeRecord();
|
||||||
|
copy.TradeId = input.TradeId;
|
||||||
|
copy.Symbol = input.Symbol;
|
||||||
|
copy.StrategyName = input.StrategyName;
|
||||||
|
copy.EntryTime = input.EntryTime;
|
||||||
|
copy.ExitTime = input.ExitTime;
|
||||||
|
copy.Side = input.Side;
|
||||||
|
copy.Quantity = input.Quantity;
|
||||||
|
copy.EntryPrice = input.EntryPrice;
|
||||||
|
copy.ExitPrice = input.ExitPrice;
|
||||||
|
copy.RealizedPnL = input.RealizedPnL;
|
||||||
|
copy.UnrealizedPnL = input.UnrealizedPnL;
|
||||||
|
copy.Grade = input.Grade;
|
||||||
|
copy.ConfluenceScore = input.ConfluenceScore;
|
||||||
|
copy.RiskMode = input.RiskMode;
|
||||||
|
copy.VolatilityRegime = input.VolatilityRegime;
|
||||||
|
copy.TrendRegime = input.TrendRegime;
|
||||||
|
copy.StopTicks = input.StopTicks;
|
||||||
|
copy.TargetTicks = input.TargetTicks;
|
||||||
|
copy.RMultiple = input.RMultiple;
|
||||||
|
copy.Duration = input.Duration;
|
||||||
|
copy.Metadata = new Dictionary<string, object>(input.Metadata);
|
||||||
|
return copy;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
497
src/NT8.Core/Analytics/TradeRecorder.cs
Normal file
497
src/NT8.Core/Analytics/TradeRecorder.cs
Normal file
@@ -0,0 +1,497 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using System.Globalization;
|
||||||
|
using System.Linq;
|
||||||
|
using System.Text;
|
||||||
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Analytics
|
||||||
|
{
|
||||||
|
/// <summary>
|
||||||
|
/// Records and queries complete trade lifecycle information.
|
||||||
|
/// </summary>
|
||||||
|
public class TradeRecorder
|
||||||
|
{
|
||||||
|
private readonly ILogger _logger;
|
||||||
|
private readonly object _lock;
|
||||||
|
private readonly Dictionary<string, TradeRecord> _trades;
|
||||||
|
private readonly Dictionary<string, List<OrderFill>> _fillsByTrade;
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Initializes a new instance of the trade recorder.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="logger">Logger implementation.</param>
|
||||||
|
public TradeRecorder(ILogger logger)
|
||||||
|
{
|
||||||
|
if (logger == null)
|
||||||
|
throw new ArgumentNullException("logger");
|
||||||
|
|
||||||
|
_logger = logger;
|
||||||
|
_lock = new object();
|
||||||
|
_trades = new Dictionary<string, TradeRecord>();
|
||||||
|
_fillsByTrade = new Dictionary<string, List<OrderFill>>();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Records trade entry details.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="tradeId">Trade identifier.</param>
|
||||||
|
/// <param name="intent">Strategy intent used for the trade.</param>
|
||||||
|
/// <param name="fill">Entry fill event.</param>
|
||||||
|
/// <param name="score">Confluence score at entry.</param>
|
||||||
|
/// <param name="mode">Risk mode at entry.</param>
|
||||||
|
public void RecordEntry(string tradeId, StrategyIntent intent, OrderFill fill, ConfluenceScore score, RiskMode mode)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(tradeId))
|
||||||
|
throw new ArgumentNullException("tradeId");
|
||||||
|
if (intent == null)
|
||||||
|
throw new ArgumentNullException("intent");
|
||||||
|
if (fill == null)
|
||||||
|
throw new ArgumentNullException("fill");
|
||||||
|
if (score == null)
|
||||||
|
throw new ArgumentNullException("score");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var record = new TradeRecord();
|
||||||
|
record.TradeId = tradeId;
|
||||||
|
record.Symbol = intent.Symbol;
|
||||||
|
record.StrategyName = ResolveStrategyName(intent);
|
||||||
|
record.EntryTime = fill.FillTime;
|
||||||
|
record.ExitTime = null;
|
||||||
|
record.Side = intent.Side;
|
||||||
|
record.Quantity = fill.Quantity;
|
||||||
|
record.EntryPrice = fill.FillPrice;
|
||||||
|
record.ExitPrice = null;
|
||||||
|
record.RealizedPnL = 0.0;
|
||||||
|
record.UnrealizedPnL = 0.0;
|
||||||
|
record.Grade = score.Grade;
|
||||||
|
record.ConfluenceScore = score.WeightedScore;
|
||||||
|
record.RiskMode = mode;
|
||||||
|
record.VolatilityRegime = ResolveVolatilityRegime(intent, score);
|
||||||
|
record.TrendRegime = ResolveTrendRegime(intent, score);
|
||||||
|
record.StopTicks = intent.StopTicks;
|
||||||
|
record.TargetTicks = intent.TargetTicks.HasValue ? intent.TargetTicks.Value : 0;
|
||||||
|
record.RMultiple = 0.0;
|
||||||
|
record.Duration = TimeSpan.Zero;
|
||||||
|
record.Metadata.Add("entry_fill_id", fill.ExecutionId ?? string.Empty);
|
||||||
|
record.Metadata.Add("entry_commission", fill.Commission);
|
||||||
|
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
_trades[tradeId] = record;
|
||||||
|
if (!_fillsByTrade.ContainsKey(tradeId))
|
||||||
|
_fillsByTrade.Add(tradeId, new List<OrderFill>());
|
||||||
|
_fillsByTrade[tradeId].Add(fill);
|
||||||
|
}
|
||||||
|
|
||||||
|
_logger.LogInformation("Trade entry recorded: {0} {1} {2} @ {3:F2}",
|
||||||
|
tradeId, record.Symbol, record.Quantity, record.EntryPrice);
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("RecordEntry failed for trade {0}: {1}", tradeId, ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Records full trade exit and finalizes metrics.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="tradeId">Trade identifier.</param>
|
||||||
|
/// <param name="fill">Exit fill event.</param>
|
||||||
|
public void RecordExit(string tradeId, OrderFill fill)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(tradeId))
|
||||||
|
throw new ArgumentNullException("tradeId");
|
||||||
|
if (fill == null)
|
||||||
|
throw new ArgumentNullException("fill");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
if (!_trades.ContainsKey(tradeId))
|
||||||
|
throw new ArgumentException("Trade not found", "tradeId");
|
||||||
|
|
||||||
|
var record = _trades[tradeId];
|
||||||
|
record.ExitTime = fill.FillTime;
|
||||||
|
record.ExitPrice = fill.FillPrice;
|
||||||
|
record.Duration = record.ExitTime.Value - record.EntryTime;
|
||||||
|
|
||||||
|
if (!_fillsByTrade.ContainsKey(tradeId))
|
||||||
|
_fillsByTrade.Add(tradeId, new List<OrderFill>());
|
||||||
|
_fillsByTrade[tradeId].Add(fill);
|
||||||
|
|
||||||
|
var totalExitQty = _fillsByTrade[tradeId]
|
||||||
|
.Skip(1)
|
||||||
|
.Sum(f => f.Quantity);
|
||||||
|
if (totalExitQty > 0)
|
||||||
|
{
|
||||||
|
var weightedExitPrice = _fillsByTrade[tradeId]
|
||||||
|
.Skip(1)
|
||||||
|
.Sum(f => f.FillPrice * f.Quantity) / totalExitQty;
|
||||||
|
record.ExitPrice = weightedExitPrice;
|
||||||
|
}
|
||||||
|
|
||||||
|
var signedMove = (record.ExitPrice.HasValue ? record.ExitPrice.Value : record.EntryPrice) - record.EntryPrice;
|
||||||
|
if (record.Side == OrderSide.Sell)
|
||||||
|
signedMove = -signedMove;
|
||||||
|
|
||||||
|
record.RealizedPnL = signedMove * record.Quantity;
|
||||||
|
record.UnrealizedPnL = 0.0;
|
||||||
|
|
||||||
|
var stopRisk = record.StopTicks <= 0 ? 0.0 : record.StopTicks;
|
||||||
|
if (stopRisk > 0.0)
|
||||||
|
record.RMultiple = signedMove / stopRisk;
|
||||||
|
|
||||||
|
record.Metadata["exit_fill_id"] = fill.ExecutionId ?? string.Empty;
|
||||||
|
record.Metadata["exit_commission"] = fill.Commission;
|
||||||
|
}
|
||||||
|
|
||||||
|
_logger.LogInformation("Trade exit recorded: {0}", tradeId);
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("RecordExit failed for trade {0}: {1}", tradeId, ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Records a partial fill event.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="tradeId">Trade identifier.</param>
|
||||||
|
/// <param name="fill">Partial fill event.</param>
|
||||||
|
public void RecordPartialFill(string tradeId, OrderFill fill)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(tradeId))
|
||||||
|
throw new ArgumentNullException("tradeId");
|
||||||
|
if (fill == null)
|
||||||
|
throw new ArgumentNullException("fill");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
if (!_fillsByTrade.ContainsKey(tradeId))
|
||||||
|
_fillsByTrade.Add(tradeId, new List<OrderFill>());
|
||||||
|
_fillsByTrade[tradeId].Add(fill);
|
||||||
|
|
||||||
|
if (_trades.ContainsKey(tradeId))
|
||||||
|
{
|
||||||
|
_trades[tradeId].Metadata["partial_fill_count"] = _fillsByTrade[tradeId].Count;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("RecordPartialFill failed for trade {0}: {1}", tradeId, ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets a single trade by identifier.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="tradeId">Trade identifier.</param>
|
||||||
|
/// <returns>Trade record if found.</returns>
|
||||||
|
public TradeRecord GetTrade(string tradeId)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(tradeId))
|
||||||
|
throw new ArgumentNullException("tradeId");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
TradeRecord record;
|
||||||
|
if (!_trades.TryGetValue(tradeId, out record))
|
||||||
|
return null;
|
||||||
|
return Clone(record);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GetTrade failed for trade {0}: {1}", tradeId, ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets trades in a time range.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="start">Start timestamp inclusive.</param>
|
||||||
|
/// <param name="end">End timestamp inclusive.</param>
|
||||||
|
/// <returns>Trade records in range.</returns>
|
||||||
|
public List<TradeRecord> GetTrades(DateTime start, DateTime end)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
return _trades.Values
|
||||||
|
.Where(t => t.EntryTime >= start && t.EntryTime <= end)
|
||||||
|
.OrderBy(t => t.EntryTime)
|
||||||
|
.Select(Clone)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GetTrades failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets trades by grade.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="grade">Target grade.</param>
|
||||||
|
/// <returns>Trade list.</returns>
|
||||||
|
public List<TradeRecord> GetTradesByGrade(TradeGrade grade)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
return _trades.Values
|
||||||
|
.Where(t => t.Grade == grade)
|
||||||
|
.OrderBy(t => t.EntryTime)
|
||||||
|
.Select(Clone)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GetTradesByGrade failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Gets trades by strategy name.
|
||||||
|
/// </summary>
|
||||||
|
/// <param name="strategyName">Strategy name.</param>
|
||||||
|
/// <returns>Trade list.</returns>
|
||||||
|
public List<TradeRecord> GetTradesByStrategy(string strategyName)
|
||||||
|
{
|
||||||
|
if (string.IsNullOrEmpty(strategyName))
|
||||||
|
throw new ArgumentNullException("strategyName");
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
return _trades.Values
|
||||||
|
.Where(t => string.Equals(t.StrategyName, strategyName, StringComparison.OrdinalIgnoreCase))
|
||||||
|
.OrderBy(t => t.EntryTime)
|
||||||
|
.Select(Clone)
|
||||||
|
.ToList();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("GetTradesByStrategy failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Exports all trades to CSV.
|
||||||
|
/// </summary>
|
||||||
|
/// <returns>CSV text.</returns>
|
||||||
|
public string ExportToCsv()
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
var rows = new StringBuilder();
|
||||||
|
rows.AppendLine("TradeId,Symbol,StrategyName,EntryTime,ExitTime,Side,Quantity,EntryPrice,ExitPrice,RealizedPnL,Grade,RiskMode,VolatilityRegime,TrendRegime,RMultiple");
|
||||||
|
|
||||||
|
List<TradeRecord> trades;
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
trades = _trades.Values.OrderBy(t => t.EntryTime).Select(Clone).ToList();
|
||||||
|
}
|
||||||
|
|
||||||
|
foreach (var trade in trades)
|
||||||
|
{
|
||||||
|
rows.AppendFormat(CultureInfo.InvariantCulture,
|
||||||
|
"{0},{1},{2},{3:O},{4},{5},{6},{7:F4},{8},{9:F2},{10},{11},{12},{13},{14:F4}",
|
||||||
|
EscapeCsv(trade.TradeId),
|
||||||
|
EscapeCsv(trade.Symbol),
|
||||||
|
EscapeCsv(trade.StrategyName),
|
||||||
|
trade.EntryTime,
|
||||||
|
trade.ExitTime.HasValue ? trade.ExitTime.Value.ToString("O") : string.Empty,
|
||||||
|
trade.Side,
|
||||||
|
trade.Quantity,
|
||||||
|
trade.EntryPrice,
|
||||||
|
trade.ExitPrice.HasValue ? trade.ExitPrice.Value.ToString("F4", CultureInfo.InvariantCulture) : string.Empty,
|
||||||
|
trade.RealizedPnL,
|
||||||
|
trade.Grade,
|
||||||
|
trade.RiskMode,
|
||||||
|
trade.VolatilityRegime,
|
||||||
|
trade.TrendRegime,
|
||||||
|
trade.RMultiple);
|
||||||
|
rows.AppendLine();
|
||||||
|
}
|
||||||
|
|
||||||
|
return rows.ToString();
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("ExportToCsv failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Exports all trades to JSON.
|
||||||
|
/// </summary>
|
||||||
|
/// <returns>JSON text.</returns>
|
||||||
|
public string ExportToJson()
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
List<TradeRecord> trades;
|
||||||
|
lock (_lock)
|
||||||
|
{
|
||||||
|
trades = _trades.Values.OrderBy(t => t.EntryTime).Select(Clone).ToList();
|
||||||
|
}
|
||||||
|
|
||||||
|
var builder = new StringBuilder();
|
||||||
|
builder.Append("[");
|
||||||
|
|
||||||
|
for (var i = 0; i < trades.Count; i++)
|
||||||
|
{
|
||||||
|
var trade = trades[i];
|
||||||
|
if (i > 0)
|
||||||
|
builder.Append(",");
|
||||||
|
|
||||||
|
builder.Append("{");
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, "\"tradeId\":\"{0}\"", EscapeJson(trade.TradeId));
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"symbol\":\"{0}\"", EscapeJson(trade.Symbol));
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"strategyName\":\"{0}\"", EscapeJson(trade.StrategyName));
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"entryTime\":\"{0:O}\"", trade.EntryTime);
|
||||||
|
if (trade.ExitTime.HasValue)
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"exitTime\":\"{0:O}\"", trade.ExitTime.Value);
|
||||||
|
else
|
||||||
|
builder.Append(",\"exitTime\":null");
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"side\":\"{0}\"", trade.Side);
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"quantity\":{0}", trade.Quantity);
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"entryPrice\":{0}", trade.EntryPrice);
|
||||||
|
if (trade.ExitPrice.HasValue)
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"exitPrice\":{0}", trade.ExitPrice.Value);
|
||||||
|
else
|
||||||
|
builder.Append(",\"exitPrice\":null");
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"realizedPnL\":{0}", trade.RealizedPnL);
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"grade\":\"{0}\"", trade.Grade);
|
||||||
|
builder.AppendFormat(CultureInfo.InvariantCulture, ",\"riskMode\":\"{0}\"", trade.RiskMode);
|
||||||
|
builder.Append("}");
|
||||||
|
}
|
||||||
|
|
||||||
|
builder.Append("]");
|
||||||
|
return builder.ToString();
|
||||||
|
}
|
||||||
|
catch (Exception ex)
|
||||||
|
{
|
||||||
|
_logger.LogError("ExportToJson failed: {0}", ex.Message);
|
||||||
|
throw;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private static string ResolveStrategyName(StrategyIntent intent)
|
||||||
|
{
|
||||||
|
object name;
|
||||||
|
if (intent.Metadata != null && intent.Metadata.TryGetValue("strategy_name", out name) && name != null)
|
||||||
|
return name.ToString();
|
||||||
|
return "Unknown";
|
||||||
|
}
|
||||||
|
|
||||||
|
private static VolatilityRegime ResolveVolatilityRegime(StrategyIntent intent, ConfluenceScore score)
|
||||||
|
{
|
||||||
|
object value;
|
||||||
|
if (TryGetMetadataValue(intent, score, "volatility_regime", out value))
|
||||||
|
{
|
||||||
|
VolatilityRegime parsed;
|
||||||
|
if (Enum.TryParse(value.ToString(), true, out parsed))
|
||||||
|
return parsed;
|
||||||
|
}
|
||||||
|
return VolatilityRegime.Normal;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static TrendRegime ResolveTrendRegime(StrategyIntent intent, ConfluenceScore score)
|
||||||
|
{
|
||||||
|
object value;
|
||||||
|
if (TryGetMetadataValue(intent, score, "trend_regime", out value))
|
||||||
|
{
|
||||||
|
TrendRegime parsed;
|
||||||
|
if (Enum.TryParse(value.ToString(), true, out parsed))
|
||||||
|
return parsed;
|
||||||
|
}
|
||||||
|
return TrendRegime.Range;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static bool TryGetMetadataValue(StrategyIntent intent, ConfluenceScore score, string key, out object value)
|
||||||
|
{
|
||||||
|
value = null;
|
||||||
|
if (intent.Metadata != null && intent.Metadata.TryGetValue(key, out value))
|
||||||
|
return true;
|
||||||
|
if (score.Metadata != null && score.Metadata.TryGetValue(key, out value))
|
||||||
|
return true;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static TradeRecord Clone(TradeRecord input)
|
||||||
|
{
|
||||||
|
var clone = new TradeRecord();
|
||||||
|
clone.TradeId = input.TradeId;
|
||||||
|
clone.Symbol = input.Symbol;
|
||||||
|
clone.StrategyName = input.StrategyName;
|
||||||
|
clone.EntryTime = input.EntryTime;
|
||||||
|
clone.ExitTime = input.ExitTime;
|
||||||
|
clone.Side = input.Side;
|
||||||
|
clone.Quantity = input.Quantity;
|
||||||
|
clone.EntryPrice = input.EntryPrice;
|
||||||
|
clone.ExitPrice = input.ExitPrice;
|
||||||
|
clone.RealizedPnL = input.RealizedPnL;
|
||||||
|
clone.UnrealizedPnL = input.UnrealizedPnL;
|
||||||
|
clone.Grade = input.Grade;
|
||||||
|
clone.ConfluenceScore = input.ConfluenceScore;
|
||||||
|
clone.RiskMode = input.RiskMode;
|
||||||
|
clone.VolatilityRegime = input.VolatilityRegime;
|
||||||
|
clone.TrendRegime = input.TrendRegime;
|
||||||
|
clone.StopTicks = input.StopTicks;
|
||||||
|
clone.TargetTicks = input.TargetTicks;
|
||||||
|
clone.RMultiple = input.RMultiple;
|
||||||
|
clone.Duration = input.Duration;
|
||||||
|
clone.Metadata = new Dictionary<string, object>(input.Metadata);
|
||||||
|
return clone;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static string EscapeCsv(string value)
|
||||||
|
{
|
||||||
|
if (value == null)
|
||||||
|
return string.Empty;
|
||||||
|
|
||||||
|
if (value.Contains(",") || value.Contains("\"") || value.Contains("\n") || value.Contains("\r"))
|
||||||
|
return string.Format("\"{0}\"", value.Replace("\"", "\"\""));
|
||||||
|
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static string EscapeJson(string value)
|
||||||
|
{
|
||||||
|
if (value == null)
|
||||||
|
return string.Empty;
|
||||||
|
|
||||||
|
return value
|
||||||
|
.Replace("\\", "\\\\")
|
||||||
|
.Replace("\"", "\\\"")
|
||||||
|
.Replace("\r", "\\r")
|
||||||
|
.Replace("\n", "\\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -8,6 +8,8 @@ namespace NT8.Core.Common.Models
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public class RiskConfig
|
public class RiskConfig
|
||||||
{
|
{
|
||||||
|
// Phase 1 - Basic Risk Properties
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Daily loss limit in dollars
|
/// Daily loss limit in dollars
|
||||||
/// </summary>
|
/// </summary>
|
||||||
@@ -28,8 +30,30 @@ namespace NT8.Core.Common.Models
|
|||||||
/// </summary>
|
/// </summary>
|
||||||
public bool EmergencyFlattenEnabled { get; set; }
|
public bool EmergencyFlattenEnabled { get; set; }
|
||||||
|
|
||||||
|
// Phase 2 - Advanced Risk Properties (Optional)
|
||||||
|
|
||||||
/// <summary>
|
/// <summary>
|
||||||
/// Constructor for RiskConfig
|
/// Weekly loss limit in dollars (optional, for advanced risk management)
|
||||||
|
/// </summary>
|
||||||
|
public double? WeeklyLossLimit { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Trailing drawdown limit in dollars (optional, for advanced risk management)
|
||||||
|
/// </summary>
|
||||||
|
public double? TrailingDrawdownLimit { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Maximum cross-strategy exposure in dollars (optional, for advanced risk management)
|
||||||
|
/// </summary>
|
||||||
|
public double? MaxCrossStrategyExposure { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Maximum correlated exposure in dollars (optional, for advanced risk management)
|
||||||
|
/// </summary>
|
||||||
|
public double? MaxCorrelatedExposure { get; set; }
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Constructor for RiskConfig (Phase 1 - backward compatible)
|
||||||
/// </summary>
|
/// </summary>
|
||||||
public RiskConfig(
|
public RiskConfig(
|
||||||
double dailyLossLimit,
|
double dailyLossLimit,
|
||||||
@@ -41,6 +65,35 @@ namespace NT8.Core.Common.Models
|
|||||||
MaxTradeRisk = maxTradeRisk;
|
MaxTradeRisk = maxTradeRisk;
|
||||||
MaxOpenPositions = maxOpenPositions;
|
MaxOpenPositions = maxOpenPositions;
|
||||||
EmergencyFlattenEnabled = emergencyFlattenEnabled;
|
EmergencyFlattenEnabled = emergencyFlattenEnabled;
|
||||||
|
|
||||||
|
// Phase 2 properties default to null (not set)
|
||||||
|
WeeklyLossLimit = null;
|
||||||
|
TrailingDrawdownLimit = null;
|
||||||
|
MaxCrossStrategyExposure = null;
|
||||||
|
MaxCorrelatedExposure = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// <summary>
|
||||||
|
/// Constructor for RiskConfig (Phase 2 - with advanced parameters)
|
||||||
|
/// </summary>
|
||||||
|
public RiskConfig(
|
||||||
|
double dailyLossLimit,
|
||||||
|
double maxTradeRisk,
|
||||||
|
int maxOpenPositions,
|
||||||
|
bool emergencyFlattenEnabled,
|
||||||
|
double? weeklyLossLimit,
|
||||||
|
double? trailingDrawdownLimit,
|
||||||
|
double? maxCrossStrategyExposure,
|
||||||
|
double? maxCorrelatedExposure)
|
||||||
|
{
|
||||||
|
DailyLossLimit = dailyLossLimit;
|
||||||
|
MaxTradeRisk = maxTradeRisk;
|
||||||
|
MaxOpenPositions = maxOpenPositions;
|
||||||
|
EmergencyFlattenEnabled = emergencyFlattenEnabled;
|
||||||
|
WeeklyLossLimit = weeklyLossLimit;
|
||||||
|
TrailingDrawdownLimit = trailingDrawdownLimit;
|
||||||
|
MaxCrossStrategyExposure = maxCrossStrategyExposure;
|
||||||
|
MaxCorrelatedExposure = maxCorrelatedExposure;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,72 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||||
|
using NT8.Core.Analytics;
|
||||||
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Tests.Analytics
|
||||||
|
{
|
||||||
|
[TestClass]
|
||||||
|
public class GradePerformanceAnalyzerTests
|
||||||
|
{
|
||||||
|
private GradePerformanceAnalyzer _target;
|
||||||
|
|
||||||
|
[TestInitialize]
|
||||||
|
public void TestInitialize()
|
||||||
|
{
|
||||||
|
_target = new GradePerformanceAnalyzer(new BasicLogger("GradePerformanceAnalyzerTests"));
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod] public void AnalyzeByGrade_ReturnsReport() { var r = _target.AnalyzeByGrade(Sample()); Assert.IsNotNull(r); }
|
||||||
|
[TestMethod] public void AnalyzeByGrade_HasMetrics() { var r = _target.AnalyzeByGrade(Sample()); Assert.IsTrue(r.MetricsByGrade.Count > 0); }
|
||||||
|
[TestMethod] public void CalculateGradeAccuracy_Bounded() { var a = _target.CalculateGradeAccuracy(TradeGrade.A, Sample()); Assert.IsTrue(a >= 0 && a <= 1); }
|
||||||
|
[TestMethod] public void FindOptimalThreshold_ReturnsEnum() { var t = _target.FindOptimalThreshold(Sample()); Assert.IsTrue(Enum.IsDefined(typeof(TradeGrade), t)); }
|
||||||
|
[TestMethod] public void GetMetricsByGrade_ReturnsAll() { var m = _target.GetMetricsByGrade(Sample()); Assert.IsTrue(m.Count >= 6); }
|
||||||
|
[TestMethod] public void AnalyzeByGrade_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.AnalyzeByGrade(null)); }
|
||||||
|
[TestMethod] public void Accuracy_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.CalculateGradeAccuracy(TradeGrade.B, null)); }
|
||||||
|
[TestMethod] public void Threshold_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.FindOptimalThreshold(null)); }
|
||||||
|
[TestMethod] public void Metrics_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.GetMetricsByGrade(null)); }
|
||||||
|
[TestMethod] public void Accuracy_Empty_IsZero() { Assert.AreEqual(0.0, _target.CalculateGradeAccuracy(TradeGrade.A, new List<TradeRecord>()), 0.0001); }
|
||||||
|
[TestMethod] public void SuggestedThreshold_NotDefaultOnData() { var r = _target.AnalyzeByGrade(Sample()); Assert.IsTrue((int)r.SuggestedThreshold >= 1); }
|
||||||
|
[TestMethod] public void Metrics_ContainsA() { var m = _target.GetMetricsByGrade(Sample()); Assert.IsTrue(m.ContainsKey(TradeGrade.A)); }
|
||||||
|
[TestMethod] public void Metrics_ContainsF() { var m = _target.GetMetricsByGrade(Sample()); Assert.IsTrue(m.ContainsKey(TradeGrade.F)); }
|
||||||
|
[TestMethod] public void Analyze_GradeAccuracyPresent() { var r = _target.AnalyzeByGrade(Sample()); Assert.IsTrue(r.GradeAccuracy.ContainsKey(TradeGrade.B)); }
|
||||||
|
[TestMethod] public void Analyze_ExpectancyComputed() { var r = _target.AnalyzeByGrade(Sample()); Assert.IsTrue(r.MetricsByGrade[TradeGrade.A].Expectancy >= -1000); }
|
||||||
|
|
||||||
|
private static List<TradeRecord> Sample()
|
||||||
|
{
|
||||||
|
return new List<TradeRecord>
|
||||||
|
{
|
||||||
|
Trade(TradeGrade.A, 50), Trade(TradeGrade.A, -10),
|
||||||
|
Trade(TradeGrade.B, 20), Trade(TradeGrade.C, -15),
|
||||||
|
Trade(TradeGrade.D, -5), Trade(TradeGrade.F, -25)
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
private static TradeRecord Trade(TradeGrade grade, double pnl)
|
||||||
|
{
|
||||||
|
var t = new TradeRecord();
|
||||||
|
t.TradeId = Guid.NewGuid().ToString();
|
||||||
|
t.Symbol = "ES";
|
||||||
|
t.StrategyName = "S";
|
||||||
|
t.EntryTime = DateTime.UtcNow;
|
||||||
|
t.ExitTime = DateTime.UtcNow.AddMinutes(1);
|
||||||
|
t.Side = OrderSide.Buy;
|
||||||
|
t.Quantity = 1;
|
||||||
|
t.EntryPrice = 100;
|
||||||
|
t.ExitPrice = 101;
|
||||||
|
t.RealizedPnL = pnl;
|
||||||
|
t.Grade = grade;
|
||||||
|
t.RiskMode = RiskMode.PCP;
|
||||||
|
t.VolatilityRegime = VolatilityRegime.Normal;
|
||||||
|
t.TrendRegime = TrendRegime.Range;
|
||||||
|
t.StopTicks = 8;
|
||||||
|
t.TargetTicks = 16;
|
||||||
|
t.Duration = TimeSpan.FromMinutes(1);
|
||||||
|
return t;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
159
tests/NT8.Core.Tests/Analytics/OptimizationTests.cs
Normal file
159
tests/NT8.Core.Tests/Analytics/OptimizationTests.cs
Normal file
@@ -0,0 +1,159 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||||
|
using NT8.Core.Analytics;
|
||||||
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Tests.Analytics
|
||||||
|
{
|
||||||
|
[TestClass]
|
||||||
|
public class OptimizationTests
|
||||||
|
{
|
||||||
|
[TestMethod]
|
||||||
|
public void ParameterOptimizer_OptimizeParameter_ReturnsResult()
|
||||||
|
{
|
||||||
|
var target = new ParameterOptimizer(new BasicLogger("OptimizationTests"));
|
||||||
|
var result = target.OptimizeParameter("test", new List<double> { 1, 2, 3 }, Trades());
|
||||||
|
Assert.IsNotNull(result);
|
||||||
|
Assert.AreEqual("test", result.ParameterName);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void ParameterOptimizer_GridSearch_ReturnsResult()
|
||||||
|
{
|
||||||
|
var target = new ParameterOptimizer(new BasicLogger("OptimizationTests"));
|
||||||
|
var p = new Dictionary<string, List<double>>();
|
||||||
|
p.Add("a", new List<double> { 1, 2 });
|
||||||
|
p.Add("b", new List<double> { 3, 4 });
|
||||||
|
var result = target.GridSearch(p, Trades());
|
||||||
|
Assert.IsTrue(result.MetricsByCombination.Count > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void ParameterOptimizer_WalkForward_ReturnsResult()
|
||||||
|
{
|
||||||
|
var target = new ParameterOptimizer(new BasicLogger("OptimizationTests"));
|
||||||
|
var cfg = new StrategyConfig("S", "ES", new Dictionary<string, object>(), new RiskConfig(1000, 500, 5, true), new SizingConfig(SizingMethod.FixedContracts, 1, 5, 200, new Dictionary<string, object>()));
|
||||||
|
var bars = Bars();
|
||||||
|
var result = target.WalkForwardTest(cfg, bars);
|
||||||
|
Assert.IsNotNull(result);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void MonteCarlo_Simulate_ReturnsDistribution()
|
||||||
|
{
|
||||||
|
var target = new MonteCarloSimulator(new BasicLogger("OptimizationTests"));
|
||||||
|
var result = target.Simulate(Trades(), 100, 20);
|
||||||
|
Assert.AreEqual(100, result.FinalPnLDistribution.Count);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void MonteCarlo_RiskOfRuin_InRange()
|
||||||
|
{
|
||||||
|
var target = new MonteCarloSimulator(new BasicLogger("OptimizationTests"));
|
||||||
|
var r = target.CalculateRiskOfRuin(Trades(), 50.0);
|
||||||
|
Assert.IsTrue(r >= 0.0 && r <= 1.0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void MonteCarlo_ConfidenceInterval_ReturnsBounds()
|
||||||
|
{
|
||||||
|
var target = new MonteCarloSimulator(new BasicLogger("OptimizationTests"));
|
||||||
|
var result = target.Simulate(Trades(), 100, 20);
|
||||||
|
var ci = target.CalculateConfidenceInterval(result, 0.95);
|
||||||
|
Assert.IsTrue(ci.UpperBound >= ci.LowerBound);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void PortfolioOptimizer_OptimizeAllocation_ReturnsWeights()
|
||||||
|
{
|
||||||
|
var target = new PortfolioOptimizer(new BasicLogger("OptimizationTests"));
|
||||||
|
var result = target.OptimizeAllocation(Strategies());
|
||||||
|
Assert.IsTrue(result.Allocation.Count > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void PortfolioOptimizer_RiskParity_ReturnsWeights()
|
||||||
|
{
|
||||||
|
var target = new PortfolioOptimizer(new BasicLogger("OptimizationTests"));
|
||||||
|
var weights = target.RiskParityAllocation(Strategies());
|
||||||
|
Assert.IsTrue(weights.Count > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void PortfolioOptimizer_Sharpe_Computes()
|
||||||
|
{
|
||||||
|
var target = new PortfolioOptimizer(new BasicLogger("OptimizationTests"));
|
||||||
|
var s = Strategies();
|
||||||
|
var a = new Dictionary<string, double>();
|
||||||
|
a.Add("A", 0.5);
|
||||||
|
a.Add("B", 0.5);
|
||||||
|
var sharpe = target.CalculatePortfolioSharpe(a, s);
|
||||||
|
Assert.IsTrue(sharpe >= 0.0 || sharpe < 0.0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod] public void MonteCarlo_InvalidConfidence_Throws() { var t = new MonteCarloSimulator(new BasicLogger("OptimizationTests")); var r = t.Simulate(Trades(), 20, 10); Assert.ThrowsException<ArgumentException>(() => t.CalculateConfidenceInterval(r, 1.0)); }
|
||||||
|
[TestMethod] public void ParameterOptimizer_NullTrades_Throws() { var t = new ParameterOptimizer(new BasicLogger("OptimizationTests")); Assert.ThrowsException<ArgumentNullException>(() => t.OptimizeParameter("x", new List<double> { 1 }, null)); }
|
||||||
|
[TestMethod] public void PortfolioOptimizer_NullStrategies_Throws() { var t = new PortfolioOptimizer(new BasicLogger("OptimizationTests")); Assert.ThrowsException<ArgumentNullException>(() => t.OptimizeAllocation(null)); }
|
||||||
|
|
||||||
|
private static List<TradeRecord> Trades()
|
||||||
|
{
|
||||||
|
var list = new List<TradeRecord>();
|
||||||
|
for (var i = 0; i < 30; i++)
|
||||||
|
{
|
||||||
|
var t = new TradeRecord();
|
||||||
|
t.TradeId = i.ToString();
|
||||||
|
t.Symbol = "ES";
|
||||||
|
t.StrategyName = i % 2 == 0 ? "A" : "B";
|
||||||
|
t.EntryTime = DateTime.UtcNow.AddMinutes(i);
|
||||||
|
t.ExitTime = DateTime.UtcNow.AddMinutes(i + 1);
|
||||||
|
t.Side = OrderSide.Buy;
|
||||||
|
t.Quantity = 1;
|
||||||
|
t.EntryPrice = 100;
|
||||||
|
t.ExitPrice = 101;
|
||||||
|
t.RealizedPnL = i % 3 == 0 ? -10 : 15;
|
||||||
|
t.Grade = TradeGrade.B;
|
||||||
|
t.RiskMode = RiskMode.PCP;
|
||||||
|
t.VolatilityRegime = VolatilityRegime.Normal;
|
||||||
|
t.TrendRegime = TrendRegime.Range;
|
||||||
|
t.StopTicks = 8;
|
||||||
|
t.TargetTicks = 16;
|
||||||
|
t.Duration = TimeSpan.FromMinutes(1);
|
||||||
|
list.Add(t);
|
||||||
|
}
|
||||||
|
return list;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static List<BarData> Bars()
|
||||||
|
{
|
||||||
|
var list = new List<BarData>();
|
||||||
|
for (var i = 0; i < 20; i++)
|
||||||
|
{
|
||||||
|
list.Add(new BarData("ES", DateTime.UtcNow.AddMinutes(i), 100 + i, 101 + i, 99 + i, 100.5 + i, 1000, TimeSpan.FromMinutes(1)));
|
||||||
|
}
|
||||||
|
return list;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static List<StrategyPerformance> Strategies()
|
||||||
|
{
|
||||||
|
var a = new StrategyPerformance();
|
||||||
|
a.StrategyName = "A";
|
||||||
|
a.MeanReturn = 1.2;
|
||||||
|
a.StdDevReturn = 0.8;
|
||||||
|
a.Sharpe = 1.5;
|
||||||
|
a.Correlations.Add("B", 0.2);
|
||||||
|
|
||||||
|
var b = new StrategyPerformance();
|
||||||
|
b.StrategyName = "B";
|
||||||
|
b.MeanReturn = 0.9;
|
||||||
|
b.StdDevReturn = 0.7;
|
||||||
|
b.Sharpe = 1.28;
|
||||||
|
b.Correlations.Add("A", 0.2);
|
||||||
|
|
||||||
|
return new List<StrategyPerformance> { a, b };
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
78
tests/NT8.Core.Tests/Analytics/PerformanceCalculatorTests.cs
Normal file
78
tests/NT8.Core.Tests/Analytics/PerformanceCalculatorTests.cs
Normal file
@@ -0,0 +1,78 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||||
|
using NT8.Core.Analytics;
|
||||||
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Tests.Analytics
|
||||||
|
{
|
||||||
|
[TestClass]
|
||||||
|
public class PerformanceCalculatorTests
|
||||||
|
{
|
||||||
|
private PerformanceCalculator _target;
|
||||||
|
|
||||||
|
[TestInitialize]
|
||||||
|
public void TestInitialize()
|
||||||
|
{
|
||||||
|
_target = new PerformanceCalculator(new BasicLogger("PerformanceCalculatorTests"));
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod] public void Calculate_Empty_ReturnsZeroTrades() { var m = _target.Calculate(new List<TradeRecord>()); Assert.AreEqual(0, m.TotalTrades); }
|
||||||
|
[TestMethod] public void CalculateWinRate_Basic() { Assert.AreEqual(0.5, _target.CalculateWinRate(Sample()), 0.0001); }
|
||||||
|
[TestMethod] public void CalculateProfitFactor_Basic() { Assert.IsTrue(_target.CalculateProfitFactor(Sample()) > 0.0); }
|
||||||
|
[TestMethod] public void CalculateExpectancy_Basic() { Assert.IsTrue(_target.CalculateExpectancy(Sample()) != 0.0); }
|
||||||
|
[TestMethod] public void CalculateSharpeRatio_Short_ReturnsZero() { Assert.AreEqual(0.0, _target.CalculateSharpeRatio(new List<TradeRecord>(), 0.0), 0.0001); }
|
||||||
|
[TestMethod] public void CalculateMaxDrawdown_Basic() { Assert.IsTrue(_target.CalculateMaxDrawdown(Sample()) >= 0.0); }
|
||||||
|
[TestMethod] public void CalculateSortinoRatio_Basic() { Assert.IsTrue(_target.CalculateSortinoRatio(Sample(), 0.0) >= 0.0 || _target.CalculateSortinoRatio(Sample(), 0.0) < 0.0); }
|
||||||
|
[TestMethod] public void Calculate_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.Calculate(null)); }
|
||||||
|
[TestMethod] public void WinRate_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.CalculateWinRate(null)); }
|
||||||
|
[TestMethod] public void ProfitFactor_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.CalculateProfitFactor(null)); }
|
||||||
|
[TestMethod] public void Expectancy_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.CalculateExpectancy(null)); }
|
||||||
|
[TestMethod] public void Sharpe_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.CalculateSharpeRatio(null, 0)); }
|
||||||
|
[TestMethod] public void Sortino_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.CalculateSortinoRatio(null, 0)); }
|
||||||
|
[TestMethod] public void MaxDrawdown_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.CalculateMaxDrawdown(null)); }
|
||||||
|
[TestMethod] public void Calculate_ReportsWinsAndLosses() { var m = _target.Calculate(Sample()); Assert.AreEqual(2, m.Wins); Assert.AreEqual(2, m.Losses); }
|
||||||
|
[TestMethod] public void Calculate_NetProfitComputed() { var m = _target.Calculate(Sample()); Assert.AreEqual(10.0, m.NetProfit, 0.0001); }
|
||||||
|
[TestMethod] public void Calculate_RecoveryFactorComputed() { var m = _target.Calculate(Sample()); Assert.IsTrue(m.RecoveryFactor >= 0.0); }
|
||||||
|
[TestMethod] public void ProfitFactor_NoLosses_Infinite() { var list = new List<TradeRecord>(); list.Add(Trade(10)); Assert.AreEqual(double.PositiveInfinity, _target.CalculateProfitFactor(list)); }
|
||||||
|
[TestMethod] public void Expectancy_Empty_Zero() { Assert.AreEqual(0.0, _target.CalculateExpectancy(new List<TradeRecord>()), 0.0001); }
|
||||||
|
[TestMethod] public void MaxDrawdown_Empty_Zero() { Assert.AreEqual(0.0, _target.CalculateMaxDrawdown(new List<TradeRecord>()), 0.0001); }
|
||||||
|
|
||||||
|
private static List<TradeRecord> Sample()
|
||||||
|
{
|
||||||
|
return new List<TradeRecord>
|
||||||
|
{
|
||||||
|
Trade(50), Trade(-25), Trade(15), Trade(-30)
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
private static TradeRecord Trade(double pnl)
|
||||||
|
{
|
||||||
|
var t = new TradeRecord();
|
||||||
|
t.TradeId = Guid.NewGuid().ToString();
|
||||||
|
t.Symbol = "ES";
|
||||||
|
t.StrategyName = "S";
|
||||||
|
t.EntryTime = DateTime.UtcNow;
|
||||||
|
t.ExitTime = DateTime.UtcNow.AddMinutes(1);
|
||||||
|
t.Side = OrderSide.Buy;
|
||||||
|
t.Quantity = 1;
|
||||||
|
t.EntryPrice = 100;
|
||||||
|
t.ExitPrice = 101;
|
||||||
|
t.RealizedPnL = pnl;
|
||||||
|
t.UnrealizedPnL = 0;
|
||||||
|
t.Grade = TradeGrade.B;
|
||||||
|
t.ConfluenceScore = 0.7;
|
||||||
|
t.RiskMode = RiskMode.PCP;
|
||||||
|
t.VolatilityRegime = VolatilityRegime.Normal;
|
||||||
|
t.TrendRegime = TrendRegime.Range;
|
||||||
|
t.StopTicks = 8;
|
||||||
|
t.TargetTicks = 16;
|
||||||
|
t.RMultiple = pnl / 8.0;
|
||||||
|
t.Duration = TimeSpan.FromMinutes(1);
|
||||||
|
return t;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
76
tests/NT8.Core.Tests/Analytics/PnLAttributorTests.cs
Normal file
76
tests/NT8.Core.Tests/Analytics/PnLAttributorTests.cs
Normal file
@@ -0,0 +1,76 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||||
|
using NT8.Core.Analytics;
|
||||||
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Tests.Analytics
|
||||||
|
{
|
||||||
|
[TestClass]
|
||||||
|
public class PnLAttributorTests
|
||||||
|
{
|
||||||
|
private PnLAttributor _target;
|
||||||
|
|
||||||
|
[TestInitialize]
|
||||||
|
public void TestInitialize()
|
||||||
|
{
|
||||||
|
_target = new PnLAttributor(new BasicLogger("PnLAttributorTests"));
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod] public void AttributeByGrade_ReturnsSlices() { var r = _target.AttributeByGrade(Sample()); Assert.IsTrue(r.Slices.Count > 0); }
|
||||||
|
[TestMethod] public void AttributeByRegime_ReturnsSlices() { var r = _target.AttributeByRegime(Sample()); Assert.IsTrue(r.Slices.Count > 0); }
|
||||||
|
[TestMethod] public void AttributeByStrategy_ReturnsSlices() { var r = _target.AttributeByStrategy(Sample()); Assert.IsTrue(r.Slices.Count > 0); }
|
||||||
|
[TestMethod] public void AttributeByTimeOfDay_ReturnsSlices() { var r = _target.AttributeByTimeOfDay(Sample()); Assert.IsTrue(r.Slices.Count > 0); }
|
||||||
|
[TestMethod] public void MultiDimensional_ReturnsSlices() { var r = _target.AttributeMultiDimensional(Sample(), new List<AttributionDimension> { AttributionDimension.Grade, AttributionDimension.Strategy }); Assert.IsTrue(r.Slices.Count > 0); }
|
||||||
|
[TestMethod] public void MultiDimensional_EmptyDims_Throws() { Assert.ThrowsException<ArgumentException>(() => _target.AttributeMultiDimensional(Sample(), new List<AttributionDimension>())); }
|
||||||
|
[TestMethod] public void Grade_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.AttributeByGrade(null)); }
|
||||||
|
[TestMethod] public void Regime_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.AttributeByRegime(null)); }
|
||||||
|
[TestMethod] public void Strategy_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.AttributeByStrategy(null)); }
|
||||||
|
[TestMethod] public void Time_Null_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.AttributeByTimeOfDay(null)); }
|
||||||
|
[TestMethod] public void Multi_NullTrades_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.AttributeMultiDimensional(null, new List<AttributionDimension> { AttributionDimension.Strategy })); }
|
||||||
|
[TestMethod] public void Multi_NullDims_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.AttributeMultiDimensional(Sample(), null)); }
|
||||||
|
[TestMethod] public void Contribution_SumsCloseToOneWhenTotalNonZero() { var r = _target.AttributeByStrategy(Sample()); var sum = 0.0; foreach (var s in r.Slices) sum += s.Contribution; Assert.IsTrue(sum > 0.5 && sum < 1.5); }
|
||||||
|
[TestMethod] public void Slice_HasDimensionName() { var r = _target.AttributeByGrade(Sample()); Assert.IsFalse(string.IsNullOrEmpty(r.Slices[0].DimensionName)); }
|
||||||
|
[TestMethod] public void Slice_WinRateInRange() { var r = _target.AttributeByGrade(Sample()); Assert.IsTrue(r.Slices[0].WinRate >= 0 && r.Slices[0].WinRate <= 1); }
|
||||||
|
[TestMethod] public void Report_TotalTradesMatches() { var s = Sample(); var r = _target.AttributeByGrade(s); Assert.AreEqual(s.Count, r.TotalTrades); }
|
||||||
|
[TestMethod] public void Report_TotalPnLMatches() { var s = Sample(); var r = _target.AttributeByGrade(s); double p = 0; foreach (var t in s) p += t.RealizedPnL; Assert.AreEqual(p, r.TotalPnL, 0.0001); }
|
||||||
|
[TestMethod] public void TimeBuckets_Assigned() { var r = _target.AttributeByTimeOfDay(Sample()); Assert.IsTrue(r.Slices.Count > 0); }
|
||||||
|
|
||||||
|
private static List<TradeRecord> Sample()
|
||||||
|
{
|
||||||
|
return new List<TradeRecord>
|
||||||
|
{
|
||||||
|
Trade("S1", TradeGrade.A, 50, VolatilityRegime.Normal, TrendRegime.StrongUp, DateTime.UtcNow.Date.AddHours(9.5)),
|
||||||
|
Trade("S1", TradeGrade.B, -20, VolatilityRegime.Elevated, TrendRegime.Range, DateTime.UtcNow.Date.AddHours(11)),
|
||||||
|
Trade("S2", TradeGrade.C, 30, VolatilityRegime.Low, TrendRegime.WeakUp, DateTime.UtcNow.Date.AddHours(15.5)),
|
||||||
|
Trade("S2", TradeGrade.A, -10, VolatilityRegime.Normal, TrendRegime.WeakDown, DateTime.UtcNow.Date.AddHours(10))
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
private static TradeRecord Trade(string strategy, TradeGrade grade, double pnl, VolatilityRegime vol, TrendRegime trend, DateTime time)
|
||||||
|
{
|
||||||
|
var t = new TradeRecord();
|
||||||
|
t.TradeId = Guid.NewGuid().ToString();
|
||||||
|
t.Symbol = "ES";
|
||||||
|
t.StrategyName = strategy;
|
||||||
|
t.EntryTime = time;
|
||||||
|
t.ExitTime = time.AddMinutes(5);
|
||||||
|
t.Side = OrderSide.Buy;
|
||||||
|
t.Quantity = 1;
|
||||||
|
t.EntryPrice = 100;
|
||||||
|
t.ExitPrice = 101;
|
||||||
|
t.RealizedPnL = pnl;
|
||||||
|
t.Grade = grade;
|
||||||
|
t.RiskMode = RiskMode.PCP;
|
||||||
|
t.VolatilityRegime = vol;
|
||||||
|
t.TrendRegime = trend;
|
||||||
|
t.StopTicks = 8;
|
||||||
|
t.TargetTicks = 16;
|
||||||
|
t.Duration = TimeSpan.FromMinutes(5);
|
||||||
|
return t;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
54
tests/NT8.Core.Tests/Analytics/TradeRecorderTests.cs
Normal file
54
tests/NT8.Core.Tests/Analytics/TradeRecorderTests.cs
Normal file
@@ -0,0 +1,54 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||||
|
using NT8.Core.Analytics;
|
||||||
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Core.Tests.Analytics
|
||||||
|
{
|
||||||
|
[TestClass]
|
||||||
|
public class TradeRecorderTests
|
||||||
|
{
|
||||||
|
private TradeRecorder _target;
|
||||||
|
|
||||||
|
[TestInitialize]
|
||||||
|
public void TestInitialize()
|
||||||
|
{
|
||||||
|
_target = new TradeRecorder(new BasicLogger("TradeRecorderTests"));
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod] public void RecordEntry_StoresTrade() { _target.RecordEntry("T1", Intent(), Fill(1, 100), Score(), RiskMode.PCP); Assert.IsNotNull(_target.GetTrade("T1")); }
|
||||||
|
[TestMethod] public void RecordExit_SetsExitFields() { _target.RecordEntry("T2", Intent(), Fill(1, 100), Score(), RiskMode.PCP); _target.RecordExit("T2", Fill(1, 104)); Assert.IsTrue(_target.GetTrade("T2").ExitPrice.HasValue); }
|
||||||
|
[TestMethod] public void RecordPartialFill_DoesNotThrow() { _target.RecordPartialFill("T3", Fill(1, 100)); Assert.IsTrue(true); }
|
||||||
|
[TestMethod] public void GetTradesByGrade_Filters() { _target.RecordEntry("T4", Intent(), Fill(1, 100), Score(TradeGrade.A), RiskMode.PCP); Assert.AreEqual(1, _target.GetTradesByGrade(TradeGrade.A).Count); }
|
||||||
|
[TestMethod] public void GetTradesByStrategy_Filters() { var i = Intent(); i.Metadata.Add("strategy_name", "S1"); _target.RecordEntry("T5", i, Fill(1, 100), Score(), RiskMode.PCP); Assert.AreEqual(1, _target.GetTradesByStrategy("S1").Count); }
|
||||||
|
[TestMethod] public void GetTrades_ByDateRange_Filters() { _target.RecordEntry("T6", Intent(), Fill(1, 100), Score(), RiskMode.PCP); var list = _target.GetTrades(DateTime.UtcNow.AddMinutes(-1), DateTime.UtcNow.AddMinutes(1)); Assert.IsTrue(list.Count >= 1); }
|
||||||
|
[TestMethod] public void ExportToCsv_HasHeader() { _target.RecordEntry("T7", Intent(), Fill(1, 100), Score(), RiskMode.PCP); var csv = _target.ExportToCsv(); StringAssert.Contains(csv, "TradeId,Symbol"); }
|
||||||
|
[TestMethod] public void ExportToJson_HasArray() { _target.RecordEntry("T8", Intent(), Fill(1, 100), Score(), RiskMode.PCP); var json = _target.ExportToJson(); StringAssert.StartsWith(json, "["); }
|
||||||
|
[TestMethod] public void GetTrade_Unknown_ReturnsNull() { Assert.IsNull(_target.GetTrade("NONE")); }
|
||||||
|
[TestMethod] public void RecordExit_Unknown_Throws() { Assert.ThrowsException<ArgumentException>(() => _target.RecordExit("X", Fill(1, 100))); }
|
||||||
|
[TestMethod] public void RecordEntry_NullIntent_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.RecordEntry("T9", null, Fill(1, 100), Score(), RiskMode.PCP)); }
|
||||||
|
[TestMethod] public void RecordEntry_NullFill_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.RecordEntry("T10", Intent(), null, Score(), RiskMode.PCP)); }
|
||||||
|
[TestMethod] public void RecordEntry_NullScore_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.RecordEntry("T11", Intent(), Fill(1, 100), null, RiskMode.PCP)); }
|
||||||
|
[TestMethod] public void GetTradesByStrategy_Empty_Throws() { Assert.ThrowsException<ArgumentNullException>(() => _target.GetTradesByStrategy("")); }
|
||||||
|
[TestMethod] public void RecordExit_ComputesPnL() { _target.RecordEntry("T12", Intent(), Fill(1, 100), Score(), RiskMode.PCP); _target.RecordExit("T12", Fill(1, 110)); Assert.IsTrue(_target.GetTrade("T12").RealizedPnL > 0); }
|
||||||
|
|
||||||
|
private static StrategyIntent Intent()
|
||||||
|
{
|
||||||
|
return new StrategyIntent("ES", OrderSide.Buy, OrderType.Market, null, 8, 16, 0.8, "test", new Dictionary<string, object>());
|
||||||
|
}
|
||||||
|
|
||||||
|
private static ConfluenceScore Score(TradeGrade grade = TradeGrade.B)
|
||||||
|
{
|
||||||
|
return new ConfluenceScore(0.7, 0.7, grade, new List<ConfluenceFactor>(), DateTime.UtcNow, new Dictionary<string, object>());
|
||||||
|
}
|
||||||
|
|
||||||
|
private static OrderFill Fill(int qty, double price)
|
||||||
|
{
|
||||||
|
return new OrderFill("O1", "ES", qty, price, DateTime.UtcNow, 1.0, Guid.NewGuid().ToString());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
201
tests/NT8.Integration.Tests/Phase5IntegrationTests.cs
Normal file
201
tests/NT8.Integration.Tests/Phase5IntegrationTests.cs
Normal file
@@ -0,0 +1,201 @@
|
|||||||
|
using System;
|
||||||
|
using System.Collections.Generic;
|
||||||
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
||||||
|
using NT8.Core.Analytics;
|
||||||
|
using NT8.Core.Common.Models;
|
||||||
|
using NT8.Core.Intelligence;
|
||||||
|
using NT8.Core.Logging;
|
||||||
|
|
||||||
|
namespace NT8.Integration.Tests
|
||||||
|
{
|
||||||
|
[TestClass]
|
||||||
|
public class Phase5IntegrationTests
|
||||||
|
{
|
||||||
|
private BasicLogger _logger;
|
||||||
|
|
||||||
|
[TestInitialize]
|
||||||
|
public void TestInitialize()
|
||||||
|
{
|
||||||
|
_logger = new BasicLogger("Phase5IntegrationTests");
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_Recorder_ToReportGenerator_Works()
|
||||||
|
{
|
||||||
|
var recorder = new TradeRecorder(_logger);
|
||||||
|
recorder.RecordEntry("T1", Intent(), Fill(1, 100), Score(), RiskMode.PCP);
|
||||||
|
recorder.RecordExit("T1", Fill(1, 105));
|
||||||
|
|
||||||
|
var trades = recorder.GetTrades(DateTime.UtcNow.AddHours(-1), DateTime.UtcNow.AddHours(1));
|
||||||
|
var generator = new ReportGenerator(_logger);
|
||||||
|
var daily = generator.GenerateDailyReport(DateTime.UtcNow, trades);
|
||||||
|
|
||||||
|
Assert.IsNotNull(daily);
|
||||||
|
Assert.IsTrue(daily.SummaryMetrics.TotalTrades >= 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_Attribution_GradeAnalysis_Works()
|
||||||
|
{
|
||||||
|
var trades = Trades();
|
||||||
|
var attributor = new PnLAttributor(_logger);
|
||||||
|
var grade = attributor.AttributeByGrade(trades);
|
||||||
|
|
||||||
|
var gradeAnalyzer = new GradePerformanceAnalyzer(_logger);
|
||||||
|
var report = gradeAnalyzer.AnalyzeByGrade(trades);
|
||||||
|
|
||||||
|
Assert.IsTrue(grade.Slices.Count > 0);
|
||||||
|
Assert.IsTrue(report.MetricsByGrade.Count > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_Regime_Confluence_Works()
|
||||||
|
{
|
||||||
|
var trades = Trades();
|
||||||
|
var regime = new RegimePerformanceAnalyzer(_logger).AnalyzeByRegime(trades);
|
||||||
|
var weights = new ConfluenceValidator(_logger).RecommendWeights(trades);
|
||||||
|
|
||||||
|
Assert.IsTrue(regime.CombinedMetrics.Count > 0);
|
||||||
|
Assert.IsTrue(weights.Count > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_Optimization_MonteCarlo_Portfolio_Works()
|
||||||
|
{
|
||||||
|
var trades = Trades();
|
||||||
|
var opt = new ParameterOptimizer(_logger);
|
||||||
|
var single = opt.OptimizeParameter("x", new List<double> { 1, 2, 3 }, trades);
|
||||||
|
|
||||||
|
var mc = new MonteCarloSimulator(_logger);
|
||||||
|
var sim = mc.Simulate(trades, 50, 20);
|
||||||
|
|
||||||
|
var po = new PortfolioOptimizer(_logger);
|
||||||
|
var alloc = po.OptimizeAllocation(Strategies());
|
||||||
|
|
||||||
|
Assert.IsNotNull(single);
|
||||||
|
Assert.AreEqual(50, sim.FinalPnLDistribution.Count);
|
||||||
|
Assert.IsTrue(alloc.Allocation.Count > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_Blotter_FilterSort_Works()
|
||||||
|
{
|
||||||
|
var blotter = new TradeBlotter(_logger);
|
||||||
|
blotter.SetTrades(Trades());
|
||||||
|
|
||||||
|
var bySymbol = blotter.FilterBySymbol("ES");
|
||||||
|
var sorted = blotter.SortBy("pnl", SortDirection.Desc);
|
||||||
|
|
||||||
|
Assert.IsTrue(bySymbol.Count > 0);
|
||||||
|
Assert.IsTrue(sorted.Count > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_DrawdownAnalysis_Works()
|
||||||
|
{
|
||||||
|
var analyzer = new DrawdownAnalyzer(_logger);
|
||||||
|
var report = analyzer.Analyze(Trades());
|
||||||
|
Assert.IsNotNull(report);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_ReportExports_Works()
|
||||||
|
{
|
||||||
|
var generator = new ReportGenerator(_logger);
|
||||||
|
var daily = generator.GenerateDailyReport(DateTime.UtcNow, Trades());
|
||||||
|
var text = generator.ExportToText(daily);
|
||||||
|
var json = generator.ExportToJson(daily);
|
||||||
|
var csv = generator.ExportToCsv(Trades());
|
||||||
|
|
||||||
|
Assert.IsTrue(text.Length > 0);
|
||||||
|
Assert.IsTrue(json.Length > 0);
|
||||||
|
Assert.IsTrue(csv.Length > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_EquityCurve_Works()
|
||||||
|
{
|
||||||
|
var curve = new ReportGenerator(_logger).BuildEquityCurve(Trades());
|
||||||
|
Assert.IsTrue(curve.Points.Count > 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_RiskOfRuin_Works()
|
||||||
|
{
|
||||||
|
var ror = new MonteCarloSimulator(_logger).CalculateRiskOfRuin(Trades(), 30.0);
|
||||||
|
Assert.IsTrue(ror >= 0.0 && ror <= 1.0);
|
||||||
|
}
|
||||||
|
|
||||||
|
[TestMethod]
|
||||||
|
public void EndToEnd_TransitionAnalysis_Works()
|
||||||
|
{
|
||||||
|
var impacts = new RegimePerformanceAnalyzer(_logger).AnalyzeTransitions(Trades());
|
||||||
|
Assert.IsNotNull(impacts);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static StrategyIntent Intent()
|
||||||
|
{
|
||||||
|
return new StrategyIntent("ES", OrderSide.Buy, OrderType.Market, null, 8, 16, 0.8, "test", new Dictionary<string, object>());
|
||||||
|
}
|
||||||
|
|
||||||
|
private static ConfluenceScore Score()
|
||||||
|
{
|
||||||
|
return new ConfluenceScore(0.7, 0.7, TradeGrade.B, new List<ConfluenceFactor>(), DateTime.UtcNow, new Dictionary<string, object>());
|
||||||
|
}
|
||||||
|
|
||||||
|
private static OrderFill Fill(int qty, double price)
|
||||||
|
{
|
||||||
|
return new OrderFill("O1", "ES", qty, price, DateTime.UtcNow, 1.0, Guid.NewGuid().ToString());
|
||||||
|
}
|
||||||
|
|
||||||
|
private static List<TradeRecord> Trades()
|
||||||
|
{
|
||||||
|
var list = new List<TradeRecord>();
|
||||||
|
for (var i = 0; i < 20; i++)
|
||||||
|
{
|
||||||
|
var t = new TradeRecord();
|
||||||
|
t.TradeId = i.ToString();
|
||||||
|
t.Symbol = "ES";
|
||||||
|
t.StrategyName = i % 2 == 0 ? "S1" : "S2";
|
||||||
|
t.EntryTime = DateTime.UtcNow.Date.AddMinutes(i * 10);
|
||||||
|
t.ExitTime = t.EntryTime.AddMinutes(5);
|
||||||
|
t.Side = OrderSide.Buy;
|
||||||
|
t.Quantity = 1;
|
||||||
|
t.EntryPrice = 100;
|
||||||
|
t.ExitPrice = 101;
|
||||||
|
t.RealizedPnL = i % 3 == 0 ? -10 : 15;
|
||||||
|
t.Grade = i % 2 == 0 ? TradeGrade.A : TradeGrade.B;
|
||||||
|
t.RiskMode = RiskMode.PCP;
|
||||||
|
t.VolatilityRegime = i % 2 == 0 ? VolatilityRegime.Normal : VolatilityRegime.Elevated;
|
||||||
|
t.TrendRegime = i % 2 == 0 ? TrendRegime.StrongUp : TrendRegime.Range;
|
||||||
|
t.StopTicks = 8;
|
||||||
|
t.TargetTicks = 16;
|
||||||
|
t.RMultiple = t.RealizedPnL / 8.0;
|
||||||
|
t.Duration = TimeSpan.FromMinutes(5);
|
||||||
|
list.Add(t);
|
||||||
|
}
|
||||||
|
|
||||||
|
return list;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static List<StrategyPerformance> Strategies()
|
||||||
|
{
|
||||||
|
var a = new StrategyPerformance();
|
||||||
|
a.StrategyName = "S1";
|
||||||
|
a.MeanReturn = 1.2;
|
||||||
|
a.StdDevReturn = 0.9;
|
||||||
|
a.Sharpe = 1.3;
|
||||||
|
a.Correlations.Add("S2", 0.3);
|
||||||
|
|
||||||
|
var b = new StrategyPerformance();
|
||||||
|
b.StrategyName = "S2";
|
||||||
|
b.MeanReturn = 1.0;
|
||||||
|
b.StdDevReturn = 0.8;
|
||||||
|
b.Sharpe = 1.25;
|
||||||
|
b.Correlations.Add("S1", 0.3);
|
||||||
|
|
||||||
|
return new List<StrategyPerformance> { a, b };
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
Reference in New Issue
Block a user