Enhance Technical Indicators and Portfolio Optimization

- Implemented Nested Clustered Optimization (NCO)
- Greatly enhanced existing technical indicators (KAMA, ADX, Supertrend, etc.)
- Integrated TA-Lib support for improved performance and accuracy
- Added new indicators: HMA, ALMA, Coppock Curve, Vortex, Mass Index, etc.
- Standardized indicators with Wilder's smoothing where appropriate
- Unified and improved the core API for technical analysis

Author: MeridianAlgo-Developer

meridianalgo/__init__.py

@@ -1,5 +1,5 @@
 """
-MeridianAlgo v6.2.1 - The Complete Quantitative Finance Platform
+MeridianAlgo v6.2.2 - The Complete Quantitative Finance Platform
 
 A comprehensive, institutional-grade Python library for quantitative finance
 covering everything from trading research to portfolio analytics to derivatives.

meridianalgo/analytics/tear_sheets.py

@@ -462,6 +462,132 @@ def plot_yearly_returns(self, ax: Optional[Any] = None) -> Any:
 
         return ax
 
+    def plot_position_exposure(self, ax: Optional[Any] = None) -> Any:
+        """Plot gross and net exposure over time."""
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib required for plotting")
+
+        if self.positions is None:
+            return None
+
+        if ax is None:
+            fig, ax = plt.subplots(figsize=(12, 4))
+
+        # Calculate exposures if not provided
+        if self.gross_lev is None:
+            long_exposure = self.positions[self.positions > 0].sum(axis=1)
+            short_exposure = self.positions[self.positions < 0].sum(axis=1)
+            gross_exposure = long_exposure + short_exposure.abs()
+            net_exposure = long_exposure + short_exposure
+        else:
+            gross_exposure = self.gross_lev
+            # Estimate net from positions if available, else assume 0
+            net_exposure = self.positions.sum(axis=1) if not self.positions.empty else pd.Series(0, index=self.returns.index)
+
+        ax.plot(gross_exposure.index, gross_exposure.values, label="Gross Exposure", color="black", linewidth=1)
+        ax.plot(net_exposure.index, net_exposure.values, label="Net Exposure", color=self.COLORS["strategy"], linewidth=1, linestyle="--")
+        
+        ax.fill_between(net_exposure.index, net_exposure.values, 0, alpha=0.1, color=self.COLORS["strategy"])
+
+        ax.set_xlabel("Date")
+        ax.set_ylabel("Exposure")
+        ax.set_title("Portfolio Exposure")
+        ax.legend(loc="upper left")
+        
+        return ax
+
+    def plot_top_positions(self, top_n: int = 10, ax: Optional[Any] = None) -> Any:
+        """Plot top positions by allocation."""
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib required for plotting")
+
+        if self.positions is None or self.positions.empty:
+            return None
+
+        if ax is None:
+            fig, ax = plt.subplots(figsize=(10, 6))
+
+        # Calculate average absolute allocation
+        avg_allocation = self.positions.abs().mean().sort_values(ascending=False).head(top_n)
+        
+        sns.barplot(x=avg_allocation.values, y=avg_allocation.index, ax=ax, palette="viridis", orient="h")
+        
+        ax.set_xlabel("Average Absolute Allocation")
+        ax.set_title(f"Top {top_n} Positions by Allocation")
+        
+        return ax
+
+    def plot_trade_pnl_distribution(self, ax: Optional[Any] = None) -> Any:
+        """Plot distribution of trade P&L."""
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib required for plotting")
+            
+        if self.transactions is None or "pnl" not in self.transactions.columns:
+            return None
+            
+        if ax is None:
+            fig, ax = plt.subplots(figsize=(10, 6))
+            
+        pnls = self.transactions["pnl"].dropna()
+        if pnls.empty:
+            return None
+            
+        sns.histplot(pnls, kde=True, ax=ax, color=self.COLORS["strategy"])
+        ax.axvline(0, color="black", linestyle="--", linewidth=1)
+        
+        ax.set_xlabel("Trade P&L")
+        ax.set_title("Trade P&L Distribution")
+        
+        # Add stats
+        win_rate = (pnls > 0).mean()
+        avg_win = pnls[pnls > 0].mean() if not pnls[pnls > 0].empty else 0
+        avg_loss = pnls[pnls < 0].mean() if not pnls[pnls < 0].empty else 0
+        profit_factor = abs(pnls[pnls > 0].sum() / pnls[pnls < 0].sum()) if pnls[pnls < 0].sum() != 0 else float('inf')
+        
+        text = f"Win Rate: {win_rate:.1%}\nAvg Win: ${avg_win:.2f}\nAvg Loss: ${avg_loss:.2f}\nProfit Factor: {profit_factor:.2f}"
+        self._create_text_box(ax, text, (0.05, 0.95))
+        
+        return ax
+
+    def plot_bayesian_cone(self, ax: Optional[Any] = None, n_samples: int = 1000) -> Any:
+        """Plot Bayesian cone for Sharpe ratio uncertainty."""
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib required for plotting")
+            
+            
+        if ax is None:
+            fig, ax = plt.subplots(figsize=(12, 6))
+            
+        # Bootstrap resampling for Sharpe ratio distribution
+        sharpe_dist = []
+        returns_array = self.returns.values
+        
+        for _ in range(n_samples):
+            # Simple bootstrap
+            sample = np.random.choice(returns_array, size=len(returns_array), replace=True)
+            if np.std(sample) > 0:
+                sharpe = np.mean(sample) / np.std(sample) * np.sqrt(self.periods_per_year)
+                sharpe_dist.append(sharpe)
+                
+        sharpe_dist = np.array(sharpe_dist)
+        mean_sharpe = np.mean(sharpe_dist)
+        
+        # Plot cone
+        # We project the uncertainty into the future
+        # This is a simplified visualization - typically cones are for cumulative returns
+        # Here we plot the distribution of likely Sharpe ratios
+        
+        sns.histplot(sharpe_dist, kde=True, ax=ax, color=self.COLORS["strategy"])
+        ax.axvline(mean_sharpe, color="red", linestyle="--", label=f"Mean: {mean_sharpe:.2f}")
+        ax.axvline(np.percentile(sharpe_dist, 5), color="orange", linestyle=":", label="95% CI")
+        ax.axvline(np.percentile(sharpe_dist, 95), color="orange", linestyle=":")
+        
+        ax.set_title(f"Bootstrap Sharpe Ratio Distribution (N={n_samples})")
+        ax.set_xlabel("Sharpe Ratio")
+        ax.legend()
+        
+        return ax
+
     # =========================================================================
     # FULL TEAR SHEETS
     # =========================================================================
@@ -581,6 +707,98 @@ def create_full_tear_sheet(
             plt.show()
 
         return fig
+        
+    def create_position_tear_sheet(self, filename: Optional[str] = None, show: bool = True) -> Optional[Any]:
+        """Create position analysis tear sheet."""
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib required for tear sheets")
+
+        self._setup_plot_style()
+        
+        fig = plt.figure(figsize=(14, 12))
+        gs = gridspec.GridSpec(3, 1, figure=fig, hspace=0.4)
+        
+        # Exposure
+        ax1 = fig.add_subplot(gs[0, :])
+        self.plot_position_exposure(ax1)
+        
+        # Top Positions
+        ax2 = fig.add_subplot(gs[1, :])
+        self.plot_top_positions(ax=ax2)
+        
+        # Returns (for context)
+        ax3 = fig.add_subplot(gs[2, :])
+        self.plot_cumulative_returns(ax3)
+        
+        plt.suptitle("Position Analysis Tear Sheet", fontsize=14, fontweight="bold", y=1.01)
+        
+        if filename:
+            fig.savefig(filename, dpi=150, bbox_inches="tight")
+            
+        if show:
+            plt.show()
+            
+        return fig
+
+    def create_round_trip_tear_sheet(self, filename: Optional[str] = None, show: bool = True) -> Optional[Any]:
+        """Create trade analysis tear sheet."""
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib required for tear sheets")
+
+        self._setup_plot_style()
+        
+        fig = plt.figure(figsize=(14, 12))
+        gs = gridspec.GridSpec(2, 2, figure=fig, hspace=0.4, wspace=0.3)
+        
+        # Trade P&L Distribution
+        ax1 = fig.add_subplot(gs[0, 0])
+        self.plot_trade_pnl_distribution(ax1)
+        
+        # Cumulative Returns (for context)
+        ax2 = fig.add_subplot(gs[0, 1])
+        self.plot_cumulative_returns(ax2)
+        
+        # Rolling Sharpe
+        ax3 = fig.add_subplot(gs[1, :])
+        self.plot_rolling_sharpe(ax=ax3)
+        
+        plt.suptitle("Trade Analysis Tear Sheet", fontsize=14, fontweight="bold", y=1.01)
+        
+        if filename:
+            fig.savefig(filename, dpi=150, bbox_inches="tight")
+            
+        if show:
+            plt.show()
+            
+        return fig
+        
+    def create_bayesian_tear_sheet(self, filename: Optional[str] = None, show: bool = True) -> Optional[Any]:
+        """Create Bayesian analysis tear sheet."""
+        if not HAS_MATPLOTLIB:
+            raise ImportError("matplotlib required for tear sheets")
+
+        self._setup_plot_style()
+        
+        fig = plt.figure(figsize=(14, 10))
+        gs = gridspec.GridSpec(2, 1, figure=fig, hspace=0.4)
+        
+        # Bayesian Cone / Sharpe Distribution
+        ax1 = fig.add_subplot(gs[0, :])
+        self.plot_bayesian_cone(ax1)
+        
+        # Returns Distribution (for context)
+        ax2 = fig.add_subplot(gs[1, :])
+        self.plot_returns_distribution(ax2)
+        
+        plt.suptitle("Bayesian Analysis Tear Sheet", fontsize=14, fontweight="bold", y=1.01)
+        
+        if filename:
+            fig.savefig(filename, dpi=150, bbox_inches="tight")
+            
+        if show:
+            plt.show()
+            
+        return fig
 
     def get_metrics_summary(self) -> pd.DataFrame:
         """Get summary metrics as DataFrame."""
@@ -697,9 +915,7 @@ def create_position_tear_sheet(
         matplotlib figure
     """
     ts = TearSheet(returns, positions=positions, **kwargs)
-    # For now, just use full tear sheet
-    # TODO: Add position-specific plots
-    return ts.create_full_tear_sheet()
+    return ts.create_position_tear_sheet()
 
 
 def create_round_trip_tear_sheet(
@@ -717,8 +933,7 @@ def create_round_trip_tear_sheet(
         matplotlib figure
     """
     ts = TearSheet(returns, transactions=transactions, **kwargs)
-    # TODO: Add round-trip specific analysis
-    return ts.create_full_tear_sheet()
+    return ts.create_round_trip_tear_sheet()
 
 
 def create_bayesian_tear_sheet(
@@ -739,6 +954,8 @@ def create_bayesian_tear_sheet(
     Returns:
         matplotlib figure
     """
-    # TODO: Implement Bayesian analysis
     ts = TearSheet(returns, benchmark=benchmark, **kwargs)
-    return ts.create_full_tear_sheet()
+    # Pass n_samples logic if method supported it, but plot_bayesian_cone does.
+    # Note: create_bayesian_tear_sheet in class doesn't accept n_samples, so we rely on default or modify
+    # Let's modify the class method call if possible, or just accept the default.
+    return ts.create_bayesian_tear_sheet()

meridianalgo/backtesting/backtester.py

@@ -126,10 +126,15 @@ def get_position(self, symbol: str) -> Position:
             self.positions[symbol] = Position(symbol)
         return self.positions[symbol]
 
-    def process_fill(self, fill_event: FillEvent) -> None:
-        """Process a fill event and update portfolio."""
+    def process_fill(self, fill_event: FillEvent) -> float:
+        """
+        Process a fill event and update portfolio.
+        
+        Returns:
+            Realized P&L from the fill
+        """
         if fill_event.fill_status == FillStatus.REJECTED:
-            return
+            return 0.0
 
         position = self.get_position(fill_event.symbol)
 
@@ -146,6 +151,8 @@ def process_fill(self, fill_event: FillEvent) -> None:
         realized_pnl = position.add_fill(fill_event)
         self.total_realized_pnl += realized_pnl
         self.total_commission += fill_event.commission
+        
+        return realized_pnl
 
     def update_market_values(self, market_prices: Dict[str, float]) -> None:
         """Update market values for all positions."""
@@ -382,6 +389,7 @@ def __init__(
 
         # Tracking
         self.portfolio_history: List[Dict[str, Any]] = []
+        self.position_history_list: List[Dict[str, Any]] = []
         self.trade_history: List[Dict[str, Any]] = []
         self.current_date: Optional[datetime] = None
 
@@ -473,22 +481,28 @@ def _handle_order_event(self, event: OrderEvent) -> None:
 
     def _handle_fill_event(self, event: FillEvent) -> None:
         """Handle fill event by updating portfolio."""
-        self.portfolio.process_fill(event)
+        realized_pnl = self.portfolio.process_fill(event)
 
         # Notify strategy
         if self.strategy:
             self.strategy.on_fill_event(event)
 
         # Record trade
-        self._record_trade(event)
+        self._record_trade(event, realized_pnl)
 
     def _record_portfolio_state(self) -> None:
         """Record current portfolio state."""
         summary = self.portfolio.get_portfolio_summary()
         summary["timestamp"] = self.current_date
         self.portfolio_history.append(summary)
-
-    def _record_trade(self, fill_event: FillEvent) -> None:
+        
+        # Record positions
+        positions_snapshot = {"timestamp": self.current_date}
+        for symbol, pos in self.portfolio.positions.items():
+            positions_snapshot[symbol] = pos.quantity
+        self.position_history_list.append(positions_snapshot)
+
+    def _record_trade(self, fill_event: FillEvent, realized_pnl: float = 0.0) -> None:
         """Record trade details."""
         if fill_event.fill_status != FillStatus.REJECTED:
             trade = {
@@ -499,6 +513,7 @@ def _record_trade(self, fill_event: FillEvent) -> None:
                 "price": fill_event.fill_price,
                 "commission": fill_event.commission,
                 "order_id": fill_event.order_id,
+                "pnl": realized_pnl,
             }
             self.trade_history.append(trade)
 
@@ -540,6 +555,11 @@ def _calculate_results(
         portfolio_df = pd.DataFrame(self.portfolio_history)
         if len(portfolio_df) > 0:
             portfolio_df.set_index("timestamp", inplace=True)
+            
+        position_history = pd.DataFrame(self.position_history_list)
+        if len(position_history) > 0:
+            position_history.set_index("timestamp", inplace=True)
+            position_history = position_history.fillna(0)
 
         trade_df = pd.DataFrame(self.trade_history)
 
@@ -590,13 +610,13 @@ def _calculate_results(
 
         # Trade statistics
         total_trades = len(trade_df)
-        if total_trades > 0:
-            # Calculate P&L per trade (simplified)
-            winning_trades = 0  # Would need more complex calculation
-            losing_trades = 0
-        else:
-            winning_trades = 0
-            losing_trades = 0
+        winning_trades = 0
+        losing_trades = 0
+        
+        if total_trades > 0 and "pnl" in trade_df.columns:
+            # We count transactions with realized P&L as "trades" for win/loss stats
+            winning_trades = len(trade_df[trade_df["pnl"] > 0])
+            losing_trades = len(trade_df[trade_df["pnl"] < 0])
 
         execution_time = datetime.now() - start_time
 
@@ -617,7 +637,7 @@ def _calculate_results(
             calmar_ratio=calmar_ratio,
             portfolio_history=portfolio_df,
             trade_history=trade_df,
-            position_history=pd.DataFrame(),  # Would be implemented
+            position_history=position_history,
             daily_returns=daily_returns,
             cumulative_returns=cumulative_returns,
             drawdowns=drawdown,