feat: much more detailed statistics

feat: improved error handling
feat: auto sell on backtrack conclusion

Author: Swofty-Developments

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>net.swofty</groupId>
     <artifactId>stockmarkettester</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>1.1.0</version>
 
     <properties>
         <maven.compiler.source>21</maven.compiler.source>

src/main/java/net/swofty/AlgorithmStatistics.java

@@ -1,16 +1,18 @@
 package net.swofty;
 
-import java.time.LocalDateTime;
+import net.swofty.orders.OrderType;
+
+import java.time.*;
+import java.time.format.DateTimeFormatter;
 import java.time.temporal.ChronoUnit;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.DoubleAdder;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class AlgorithmStatistics {
     private final String algorithmId;
     private final LocalDateTime startTime;
-    private final AtomicInteger totalTrades;
     private final DoubleAdder totalProfit;
     private final DoubleAdder maxDrawdown;
     private final DoubleAdder peakValue;
@@ -19,6 +21,13 @@ public class AlgorithmStatistics {
     private final List<Double> dailyReturns;
     private volatile double initialValue;
 
+    // New fields for enhanced statistics
+    private final Map<String, TickerStatistics> tickerStats;
+    private final Map<LocalDate, WeeklyPerformance> weeklyPerformance = new ConcurrentHashMap<>();
+    private final Map<String, TradeRecord> openTrades = new ConcurrentHashMap<>();
+    private final List<TradeRecord> tradeHistory;
+    private final AtomicInteger totalTrades;
+
     public AlgorithmStatistics(String algorithmId, double initialValue, LocalDateTime startTime) {
         this.algorithmId = algorithmId;
         this.totalTrades = new AtomicInteger(0);
@@ -31,18 +40,51 @@ public AlgorithmStatistics(String algorithmId, double initialValue, LocalDateTim
         this.startTime = startTime;
         this.initialValue = initialValue;
         this.peakValue.add(initialValue);
+
+        // Initialize new tracking structures
+        this.tickerStats = new ConcurrentHashMap<>();
+        this.tradeHistory = Collections.synchronizedList(new ArrayList<>());
+    }
+
+    public void recordTrade(String ticker, OrderType type, int quantity, double price,
+                            double portfolioValueBefore, LocalDateTime timestamp) {
+        TradeRecord trade = new TradeRecord(
+                ticker, type, quantity, price, portfolioValueBefore, timestamp
+        );
+        tradeHistory.add(trade);
+        totalTrades.incrementAndGet();
+
+        // Update ticker-specific statistics
+        tickerStats.computeIfAbsent(ticker, k -> new TickerStatistics())
+                .updateStats(trade);
+
+        // Handle weekly performance tracking
+        switch (type) {
+            case BUY, SHORT -> openTrades.put(ticker, trade);
+            case SELL, COVER -> {
+                TradeRecord openTrade = openTrades.remove(ticker);
+                if (openTrade != null) {
+                    // Get the week of the SELL/COVER trade
+                    LocalDate weekStart = timestamp.toLocalDate().with(DayOfWeek.MONDAY);
+                    weeklyPerformance.computeIfAbsent(weekStart, k -> new WeeklyPerformance())
+                            .recordCompletedTrade(openTrade, trade);
+                }
+            }
+        }
+    }
+
+    public int getTotalTrades() {
+        return totalTrades.get();
     }
 
     public void updateStatistics(double currentValue, double riskFreeRate) {
-        // Update total profit/loss
+        // Existing statistics logic
         totalProfit.reset();
         totalProfit.add(currentValue - initialValue);
 
-        // Update total value
         totalValue.reset();
         totalValue.add(currentValue);
 
-        // Update peak value and calculate drawdown
         if (currentValue > peakValue.sum()) {
             peakValue.reset();
             peakValue.add(currentValue);
@@ -53,13 +95,14 @@ public void updateStatistics(double currentValue, double riskFreeRate) {
             maxDrawdown.add(currentDrawdown);
         }
 
-        // Calculate and store daily return
         double dailyReturn = (currentValue - initialValue) / initialValue;
         dailyReturns.add(dailyReturn);
 
-        // Calculate Sharpe Ratio using proper daily returns
         if (dailyReturns.size() > 1) {
-            double averageReturn = dailyReturns.stream().mapToDouble(Double::doubleValue).average().orElse(0.0);
+            double averageReturn = dailyReturns.stream()
+                    .mapToDouble(Double::doubleValue)
+                    .average()
+                    .orElse(0.0);
             double stdDev = calculateStandardDeviation(dailyReturns, averageReturn);
             double annualizedSharpe = stdDev != 0 ?
                     (Math.sqrt(252) * (averageReturn - riskFreeRate/252) / stdDev) : 0;
@@ -78,33 +121,15 @@ private double calculateStandardDeviation(List<Double> returns, double mean) {
         );
     }
 
-    public void setTrades(int trades) {
-        totalTrades.set(trades);
-    }
-
-    public int getTotalTrades() {
-        return totalTrades.get();
-    }
-
-    public double getTotalProfit() {
-        return totalProfit.sum();
-    }
-
-    public double getMaxDrawdown() {
-        return maxDrawdown.sum();
-    }
-
-    public double getSharpeRatio() {
-        return sharpeRatio.sum();
-    }
-
     @Override
     public String toString() {
+        StringBuilder sb = new StringBuilder();
         long daysRun = ChronoUnit.DAYS.between(startTime, LocalDateTime.now());
         double annualizedReturn = dailyReturns.isEmpty() ? 0 :
                 Math.pow(1 + dailyReturns.get(dailyReturns.size() - 1), 252) - 1;
 
-        return String.format("""
+        // Overall Performance
+        sb.append(String.format("""
             Algorithm Statistics for %s:
             Backtest Period: %d days
             Total Trades: %d
@@ -114,16 +139,157 @@ public String toString() {
             Sharpe Ratio: %.2f
             Average Trades Per Day: %.2f
             Total Value: $%.2f
+            
+            Per-Ticker Performance:
+            =====================
             """,
-                algorithmId,
-                daysRun,
-                totalTrades.get(),
-                totalProfit.sum(),
-                annualizedReturn * 100,
-                maxDrawdown.sum(),
-                sharpeRatio.sum(),
+                algorithmId, daysRun, totalTrades.get(), totalProfit.sum(),
+                annualizedReturn * 100, maxDrawdown.sum(), sharpeRatio.sum(),
                 daysRun > 0 ? (double) totalTrades.get() / daysRun : 0,
                 totalValue.sum()
-        );
+        ));
+
+        // Add per-ticker statistics
+        tickerStats.forEach((ticker, stats) -> {
+            double winRate = stats.totalSells > 0 ?
+                    ((double) stats.profitableSells / stats.totalSells) * 100 : 0.0;
+
+            sb.append(String.format("""
+            %s:
+              Total Sells: %d
+              Profitable Sells: %d (%.1f%%)
+              Total P/L: $%.2f
+              Average P/L per Sale: $%.2f
+              Largest Gain: $%.2f
+              Largest Loss: $%.2f
+              Win Rate: %.1f%%
+              
+            """,
+                    ticker, stats.totalSells, stats.profitableSells,
+                    winRate,
+                    stats.totalPnL,
+                    stats.totalSells > 0 ? stats.totalPnL / stats.totalSells : 0.0,
+                    stats.largestGain,
+                    stats.largestLoss,
+                    winRate
+            ));
+        });
+
+        // Add monthly performance
+        sb.append("\nWeekly Performance:\n===================\n");
+        if (weeklyPerformance.isEmpty()) {
+            sb.append("No completed trades yet\n");
+        } else {
+            DateTimeFormatter weekFormatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+            weeklyPerformance.entrySet().stream()
+                    .sorted(Map.Entry.comparingByKey())
+                    .filter(entry -> entry.getValue().hasActivity())
+                    .forEach(entry -> {
+                        WeeklyPerformance perf = entry.getValue();
+                        LocalDate weekStart = entry.getKey();
+                        LocalDate weekEnd = weekStart.plusDays(6);
+                        String weekRange = String.format("%s - %s",
+                                weekStart.format(weekFormatter),
+                                weekEnd.format(weekFormatter));
+
+                        sb.append(String.format("Week %s:\n", weekRange));
+                        sb.append(String.format("  P/L: $%.2f\n", perf.totalPnL));
+                        sb.append(String.format("  Completed Trades: %d\n", perf.totalSells));
+                        if (perf.totalSells > 0) {
+                            sb.append(String.format("  Average P/L per Share: $%.2f\n", perf.profitPerShare));
+                        }
+                        sb.append("\n");
+                    });
+        }
+
+        return sb.toString();
     }
+
+    private static class TickerStatistics {
+        private int totalSells;  // Changed from totalTrades
+        private int profitableSells;  // Changed from profitableTrades
+        private double totalPnL;
+        private double largestGain;
+        private double largestLoss;
+        private Double lastBuyPrice;
+        private int lastBuyQuantity;
+
+        public synchronized void updateStats(TradeRecord trade) {
+            switch (trade.type()) {
+                case BUY -> {
+                    lastBuyPrice = trade.price();
+                    lastBuyQuantity = trade.quantity();
+                }
+                case SELL -> {
+                    if (lastBuyPrice != null) {
+                        totalSells++; // Only count sells
+                        double profit = (trade.price() - lastBuyPrice) * trade.quantity();
+                        totalPnL += profit;
+
+                        if (profit > 0) {
+                            profitableSells++; // Only increment on profitable sells
+                            largestGain = Math.max(largestGain, profit);
+                        } else {
+                            largestLoss = Math.min(largestLoss, profit);
+                        }
+
+                        lastBuyPrice = null;
+                        lastBuyQuantity = 0;
+                    }
+                }
+                case SHORT -> {
+                    lastBuyPrice = trade.price();
+                    lastBuyQuantity = trade.quantity();
+                }
+                case COVER -> {
+                    if (lastBuyPrice != null) {
+                        totalSells++; // Count covers as sells for shorts
+                        double profit = (lastBuyPrice - trade.price()) * trade.quantity();
+                        totalPnL += profit;
+
+                        if (profit > 0) {
+                            profitableSells++;
+                            largestGain = Math.max(largestGain, profit);
+                        } else {
+                            largestLoss = Math.min(largestLoss, profit);
+                        }
+
+                        lastBuyPrice = null;
+                        lastBuyQuantity = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    private static class WeeklyPerformance {
+        private int totalSells;
+        private double totalPnL;
+        private double profitPerShare;
+
+        public synchronized void recordCompletedTrade(TradeRecord buyTrade, TradeRecord sellTrade) {
+            totalSells++;
+            double profit;
+            if (sellTrade.type() == OrderType.SELL) {
+                profit = (sellTrade.price() - buyTrade.price()) * sellTrade.quantity();
+            } else { // COVER
+                profit = (buyTrade.price() - sellTrade.price()) * sellTrade.quantity();
+            }
+            profitPerShare = profit / sellTrade.quantity();
+            totalPnL += profit;
+        }
+
+        public boolean hasActivity() {
+            return totalSells > 0 || totalPnL != 0.0;
+        }
+    }
+
+    private record TradeRecord(
+            String ticker,
+            OrderType type,
+            int quantity,
+            double price,
+            double portfolioValueBefore,
+            LocalDateTime timestamp
+    ) {}
 }

src/main/java/net/swofty/Portfolio.java

@@ -105,6 +105,14 @@ public synchronized void coverShort(String ticker, int quantity, double price) {
         marginAvailable += quantity * shortPosition.entryPrice() * MARGIN_REQUIREMENT;
     }
 
+    public Map<String, Position> getAllPositions() {
+        return positions;
+    }
+
+    public Map<String, net.swofty.orders.Short> getAllShortPositions() {
+        return shortPositions;
+    }
+
     // Stop order methods
     public void setStopLoss(String ticker, double stopPrice, int quantity) {
         totalPositions++;

src/main/java/net/swofty/builtin/TestAlgorithm.java

@@ -13,8 +13,6 @@
 
 public class TestAlgorithm {
     public static void main(String[] args) {
-        AlphaVantageFetcher.setup("KEY", Path.of("PATH/StockMarketAlgorithmMaker/vantage-cache/"));
-
         // Create market service
         HistoricalMarketService marketService = new HistoricalMarketService(
                 new AlphaVantageProvider("KEY"),
@@ -36,6 +34,7 @@ public static void main(String[] args) {
                             .withInterval(Duration.ofMinutes(1))
                             .withRunOnMarketClosed(true)  // Enable running outside market hours
                             .withProvider(marketService)  // Use the initialized service
+                            .withAutomaticallySellOnFinish(true)
                             .withAlgorithm(new SimpleBuyAndHoldAlgorithm("simple-day-trader", tickers), 1_000_000)
                             .run()
                             .thenAccept(results -> {

src/main/java/net/swofty/data/HistoricalMarketService.java

@@ -108,6 +108,7 @@ public CompletableFuture<Void> initialize(Set<String> tickers, int previousDays,
                         if (cachedData != null) {
                             historicalCache.put(ticker, cachedData);
                             System.out.println("Loaded cached data for " + ticker);
+                            success = true;
                             continue;
                         }
                     }
@@ -120,6 +121,8 @@ public CompletableFuture<Void> initialize(Set<String> tickers, int previousDays,
                                         Set.of(ticker), start, end, marketConfig).get();
                                 historicalCache.put(ticker, data);
 
+                                long cooldown = (60 / provider.getRateLimit()) * 1000;
+
                                 // Save to cache if enabled
                                 if (cacheDirectory.isPresent()) {
                                     saveToCache(ticker, data, start, end);
@@ -129,7 +132,11 @@ public CompletableFuture<Void> initialize(Set<String> tickers, int previousDays,
                                 }
 
                                 success = true;
-                                Thread.sleep((60 / provider.getRateLimit()) * 1000);
+                                int amountOfTickersLeft = tickers.size() - attempts;
+                                if (amountOfTickersLeft > 0) {
+                                    System.out.println("Waiting " + cooldown + "ms due to rate limits");
+                                    Thread.sleep(cooldown);
+                                }
                             } else {
                                 throw new RuntimeException("Provider is not available");
                             }

src/main/java/net/swofty/data/providers/AlphaVantageProvider.java

@@ -116,7 +116,7 @@ private void validateResponse(HttpResponse<String> response) {
                 throw new MarketDataException("API Limit Reached: " + root.get("Note").asText(), null);
             }
         } catch (Exception e) {
-            throw new MarketDataException("Failed to validate response", e);
+            throw new MarketDataException("Failed to validate response, your ticker may be invalid", e);
         }
     }