Update app.py

app.py

@@ -13,10 +13,10 @@ def fetch_stock_data(ticker: str, start_date: str, end_date: str) -> pd.DataFram
     return yf.download(ticker, start=start_date, end=end_date)
 
 # Helper function to plot rolling volatility and volatility of volatility
-def plot_rolling_volatility(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_volatility(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    data['Rolling_Volatility'] = data['Return'].rolling(window=21).std() * np.sqrt(252)
-    data['Vol_of_Vol'] = data['Rolling_Volatility'].rolling(window=21).std()
+    data['Rolling_Volatility'] = data['Return'].rolling(window=window).std() * np.sqrt(252)
+    data['Vol_of_Vol'] = data['Rolling_Volatility'].rolling(window=window).std()
 
     fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Volatility', 'Volatility of Volatility'))
@@ -29,9 +29,9 @@ def plot_rolling_volatility(data: pd.DataFrame) -> go.Figure:
     return fig
 
 # Helper function to plot rolling Sharpe ratio
-def plot_rolling_sharpe(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_sharpe(data: pd.DataFrame, window: int, risk_free_rate: float) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    rolling_sharpe = np.sqrt(252) * data['Return'].rolling(252).mean() / data['Return'].rolling(252).std()
+    rolling_sharpe = np.sqrt(252) * (data['Return'].rolling(window).mean() - risk_free_rate) / data['Return'].rolling(window).std()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Sharpe Ratio'))
@@ -40,23 +40,21 @@ def plot_rolling_sharpe(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=data.index, y=rolling_sharpe, mode='lines', name='Rolling Sharpe Ratio', line=dict(color='green')), row=2, col=1)
     fig.add_hline(y=1, line=dict(color='red', dash='dash'), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Sharpe Ratio with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Sharpe Ratio with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling Treynor ratio
-# Helper function to calculate and plot rolling Treynor Ratio
-def plot_rolling_treynor(data: pd.DataFrame, market_data: pd.DataFrame, window_size: int = 252) -> go.Figure:
+def plot_rolling_treynor(data: pd.DataFrame, market_data: pd.DataFrame, window: int, risk_free_rate: float) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
     market_data['Return'] = market_data['Close'].pct_change()
 
     # Align indices
     market_data = market_data.reindex(data.index, method='ffill')
 
-    covariance = data['Return'].rolling(window=window_size).cov(market_data['Return'])
-    variance = market_data['Return'].rolling(window=window_size).var()
+    covariance = data['Return'].rolling(window=window).cov(market_data['Return'])
+    variance = market_data['Return'].rolling(window=window).var()
     rolling_beta = covariance / variance
-    avg_rolling_returns = data['Return'].rolling(window=window_size).mean()
-    risk_free_rate = 0
+    avg_rolling_returns = data['Return'].rolling(window=window).mean()
     data['Rolling_Treynor_Ratio'] = (avg_rolling_returns - risk_free_rate) / rolling_beta
 
     fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.1,
@@ -66,11 +64,11 @@ def plot_rolling_treynor(data: pd.DataFrame, market_data: pd.DataFrame, window_s
     fig.add_trace(go.Scatter(x=market_data.index, y=market_data['Close'], mode='lines', name='Benchmark Price', line=dict(color='blue')), row=2, col=1)
     fig.add_trace(go.Scatter(x=data.index, y=data['Rolling_Treynor_Ratio'], mode='lines', name='Rolling Treynor Ratio', line=dict(color='red')), row=3, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Treynor Ratio with Stock Price and Benchmark', xaxis_title='Date')
+    fig.update_layout(title='Rolling Treynor Ratio with Stock Price and Benchmark', xaxis_title='Date')
     return fig
-    
+
 # Helper function to calculate and plot rolling beta
-def plot_rolling_beta(data: pd.DataFrame, market_data: pd.DataFrame, window: int = 60) -> go.Figure:
+def plot_rolling_beta(data: pd.DataFrame, market_data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change().dropna()
     market_data['Market_Return'] = market_data['Close'].pct_change().dropna()
     
@@ -106,26 +104,25 @@ def plot_rolling_beta(data: pd.DataFrame, market_data: pd.DataFrame, window: int
     fig.add_trace(go.Scatter(x=rolling_beta_ransac.index, y=rolling_beta_ransac, mode='lines', name='Rolling Beta (RANSAC)', line=dict(color='red')), row=3, col=1)
     fig.add_trace(go.Scatter(x=rolling_beta_ols.index, y=rolling_beta_ols, mode='lines', name='Rolling Beta (OLS)', line=dict(color='green')), row=3, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Beta with Stock Price and Benchmark', xaxis_title='Date')
+    fig.update_layout(title='Rolling Beta with Stock Price and Benchmark', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling Jensen's alpha
-def plot_rolling_alpha(data: pd.DataFrame, market_data: pd.DataFrame) -> go.Figure:
+def plot_rolling_alpha(data: pd.DataFrame, market_data: pd.DataFrame, window: int, risk_free_rate: float) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
     market_data['Return'] = market_data['Close'].pct_change()
 
-    window_size = 252
     rolling_alpha = []
 
-    for i in range(len(data) - window_size):
-        window = data['Return'].iloc[i:i + window_size]
-        market_window = market_data['Return'].iloc[i:i + window_size]
-        beta = window.cov(market_window) / market_window.var()
-        expected_return = beta * market_window.mean()
-        alpha = window.mean() - expected_return
+    for i in range(len(data) - window):
+        window_stock = data['Return'].iloc[i:i + window]
+        window_market = market_data['Return'].iloc[i:i + window]
+        beta = window_stock.cov(window_market) / window_market.var()
+        expected_return = risk_free_rate + beta * (window_market.mean() - risk_free_rate)
+        alpha = window_stock.mean() - expected_return
         rolling_alpha.append(alpha)
 
-    rolling_alpha = pd.Series(rolling_alpha, index=data.index[window_size:])
+    rolling_alpha = pd.Series(rolling_alpha, index=data.index[window:])
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Jensen\'s Alpha'))
@@ -133,15 +130,15 @@ def plot_rolling_alpha(data: pd.DataFrame, market_data: pd.DataFrame) -> go.Figu
     fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
     fig.add_trace(go.Scatter(x=rolling_alpha.index, y=rolling_alpha, mode='lines', name='Rolling Jensen\'s Alpha', line=dict(color='green')), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Jensen\'s Alpha with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Jensen\'s Alpha with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling Value at Risk (VaR)
-def plot_rolling_var(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_var(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    rolling_var_90 = data['Return'].rolling(252).quantile(0.10).dropna()
-    rolling_var_95 = data['Return'].rolling(252).quantile(0.05).dropna()
-    rolling_var_97 = data['Return'].rolling(252).quantile(0.03).dropna()
+    rolling_var_90 = data['Return'].rolling(window).quantile(0.10).dropna()
+    rolling_var_95 = data['Return'].rolling(window).quantile(0.05).dropna()
+    rolling_var_97 = data['Return'].rolling(window).quantile(0.03).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling VaR'))
@@ -151,20 +148,20 @@ def plot_rolling_var(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=rolling_var_95.index, y=rolling_var_95, mode='lines', name='Rolling VaR 95%', line=dict(color='blue')), row=2, col=1)
     fig.add_trace(go.Scatter(x=rolling_var_97.index, y=rolling_var_97, mode='lines', name='Rolling VaR 97%', line=dict(color='purple')), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year VaR with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling VaR with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling Conditional VaR (CVaR)
-def plot_rolling_cvar(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_cvar(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
 
     def conditional_var(x, alpha=0.05):
         var = np.percentile(x, alpha * 100)
         return np.mean(x[x < var])
 
-    rolling_cvar_95 = data['Return'].rolling(252).apply(conditional_var, raw=True).dropna()
-    rolling_cvar_90 = data['Return'].rolling(252).apply(lambda x: conditional_var(x, alpha=0.1), raw=True).dropna()
-    rolling_cvar_97 = data['Return'].rolling(252).apply(lambda x: conditional_var(x, alpha=0.03), raw=True).dropna()
+    rolling_cvar_95 = data['Return'].rolling(window).apply(conditional_var, raw=True).dropna()
+    rolling_cvar_90 = data['Return'].rolling(window).apply(lambda x: conditional_var(x, alpha=0.1), raw=True).dropna()
+    rolling_cvar_97 = data['Return'].rolling(window).apply(lambda x: conditional_var(x, alpha=0.03), raw=True).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling CVaR'))
@@ -174,13 +171,13 @@ def plot_rolling_cvar(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=rolling_cvar_90.index, y=rolling_cvar_90, mode='lines', name='Rolling CVaR 90%', line=dict(color='green')), row=2, col=1)
     fig.add_trace(go.Scatter(x=rolling_cvar_97.index, y=rolling_cvar_97, mode='lines', name='Rolling CVaR 97%', line=dict(color='orange')), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year CVaR with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling CVaR with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling Tail Ratio
-def plot_rolling_tail_ratio(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_tail_ratio(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    tail_ratio = data['Return'].rolling(252).apply(lambda x: np.abs(np.percentile(x, 95)) / np.abs(np.percentile(x, 5))).dropna()
+    tail_ratio = data['Return'].rolling(window).apply(lambda x: np.abs(np.percentile(x, 95)) / np.abs(np.percentile(x, 5))).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Tail Ratio'))
@@ -189,14 +186,14 @@ def plot_rolling_tail_ratio(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=tail_ratio.index, y=tail_ratio, mode='lines', name='Tail Ratio', line=dict(color='purple')), row=2, col=1)
     fig.add_hline(y=1, line=dict(color='red', dash='dash'), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Tail Ratio with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Tail Ratio with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling Omega Ratio
-def plot_rolling_omega(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_omega(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
     MAR = 0  # Minimum Acceptable Return
-    omega_ratio = data['Return'].rolling(252).apply(lambda x: np.sum(x[x > MAR] - MAR) / np.sum(MAR - x[x < MAR])).dropna()
+    omega_ratio = data['Return'].rolling(window).apply(lambda x: np.sum(x[x > MAR] - MAR) / np.sum(MAR - x[x < MAR])).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Omega Ratio'))
@@ -205,14 +202,13 @@ def plot_rolling_omega(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=omega_ratio.index, y=omega_ratio, mode='lines', name='Omega Ratio', line=dict(color='green')), row=2, col=1)
     fig.add_hline(y=1, line=dict(color='red', dash='dash'), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Omega Ratio with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Omega Ratio with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling Sortino Ratio
-def plot_rolling_sortino(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_sortino(data: pd.DataFrame, window: int, MAR: float) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    MAR = 0  # Minimum Acceptable Return
-    sortino_ratio = data['Return'].rolling(252).apply(lambda x: np.mean(x - MAR) / np.sqrt(np.mean(np.minimum(0, x - MAR) ** 2))).dropna()
+    sortino_ratio = data['Return'].rolling(window).apply(lambda x: np.mean(x - MAR) / np.sqrt(np.mean(np.minimum(0, x - MAR) ** 2))).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Sortino Ratio'))
@@ -220,13 +216,13 @@ def plot_rolling_sortino(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
     fig.add_trace(go.Scatter(x=sortino_ratio.index, y=sortino_ratio, mode='lines', name='Sortino Ratio', line=dict(color='green')), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Sortino Ratio with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Sortino Ratio with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling Calmar Ratio
-def plot_rolling_calmar(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_calmar(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    calmar_ratio = data['Return'].rolling(252).apply(lambda x: (1 + x).cumprod()[-1] ** (252.0 / len(x)) / np.abs(np.min((1 + x).cumprod() / (1 + x).cumprod().cummax()) - 1)).dropna()
+    calmar_ratio = data['Return'].rolling(window).apply(lambda x: (1 + x).cumprod()[-1] ** (252.0 / len(x)) / np.abs(np.min((1 + x).cumprod() / (1 + x).cumprod().cummax()) - 1)).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Calmar Ratio'))
@@ -234,13 +230,13 @@ def plot_rolling_calmar(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
     fig.add_trace(go.Scatter(x=calmar_ratio.index, y=calmar_ratio, mode='lines', name='Calmar Ratio', line=dict(color='green')), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Calmar Ratio with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Calmar Ratio with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling stability
-def plot_rolling_stability(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_stability(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    stability = data['Return'].rolling(252).apply(lambda x: np.std(np.log1p(x).cumsum() - linregress(np.arange(len(x)), np.log1p(x).cumsum()).intercept - linregress(np.arange(len(x)), np.log1p(x).cumsum()).slope * np.arange(len(x)))).dropna()
+    stability = data['Return'].rolling(window).apply(lambda x: np.std(np.log1p(x).cumsum() - linregress(np.arange(len(x)), np.log1p(x).cumsum()).intercept - linregress(np.arange(len(x)), np.log1p(x).cumsum()).slope * np.arange(len(x)))).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Stability'))
@@ -248,14 +244,14 @@ def plot_rolling_stability(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
     fig.add_trace(go.Scatter(x=stability.index, y=stability, mode='lines', name='Stability', line=dict(color='purple')), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Stability of Returns with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Stability of Returns with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to plot rolling maximum drawdown
-def plot_rolling_drawdown(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_drawdown(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
     rolling_cumulative = (1 + data['Return']).cumprod()
-    rolling_max = rolling_cumulative.rolling(252, min_periods=1).max()
+    rolling_max = rolling_cumulative.rolling(window, min_periods=1).max()
     rolling_drawdown = (rolling_cumulative - rolling_max) / rolling_max
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
@@ -264,11 +260,11 @@ def plot_rolling_drawdown(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
     fig.add_trace(go.Scatter(x=rolling_drawdown.index, y=rolling_drawdown, mode='lines', name='Maximum Drawdown', line=dict(color='red')), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Maximum Drawdown with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Maximum Drawdown with Stock Price', xaxis_title='Date')
     return fig
 
 # Helper function to calculate and plot rolling capture ratios
-def plot_rolling_capture(data: pd.DataFrame, market_data: pd.DataFrame, window_size: int = 252) -> go.Figure:
+def plot_rolling_capture(data: pd.DataFrame, market_data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
     market_data['Return'] = market_data['Close'].pct_change()
 
@@ -310,7 +306,7 @@ def plot_rolling_capture(data: pd.DataFrame, market_data: pd.DataFrame, window_s
         return upside_captures, downside_captures
 
     data['rolling_upside_capture'], data['rolling_downside_capture'] = compute_rolling_captures(
-        data['Return'], market_data['Return'], window_size
+        data['Return'], market_data['Return'], window
     )
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
@@ -320,17 +316,16 @@ def plot_rolling_capture(data: pd.DataFrame, market_data: pd.DataFrame, window_s
     fig.add_trace(go.Scatter(x=data.index, y=data['rolling_upside_capture'], mode='lines', name='Rolling Upside Capture', line=dict(color='green')), row=2, col=1)
     fig.add_trace(go.Scatter(x=data.index, y=data['rolling_downside_capture'], mode='lines', name='Rolling Downside Capture', line=dict(color='red')), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Capture Ratios with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Capture Ratios with Stock Price', xaxis_title='Date')
     return fig
 
-
 # Helper function to plot rolling Pain Index
-def plot_rolling_pain_index(data: pd.DataFrame) -> go.Figure:
+def plot_rolling_pain_index(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
     cumulative_return = (1 + data['Return']).cumprod()
     running_max = cumulative_return.cummax()
     drawdown = (cumulative_return - running_max) / running_max
-    pain_index = drawdown.rolling(252).apply(lambda x: np.mean(x[x < 0])).dropna()
+    pain_index = drawdown.rolling(window).apply(lambda x: np.mean(x[x < 0])).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Pain Index'))
@@ -338,7 +333,7 @@ def plot_rolling_pain_index(data: pd.DataFrame) -> go.Figure:
     fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
     fig.add_trace(go.Scatter(x=pain_index.index, y=pain_index, mode='lines', name='Pain Index', line=dict(color='red')), row=2, col=1)
 
-    fig.update_layout(title='Rolling 1-Year Pain Index with Stock Price', xaxis_title='Date')
+    fig.update_layout(title='Rolling Pain Index with Stock Price', xaxis_title='Date')
     return fig
 
 # Streamlit app
@@ -356,6 +351,7 @@ st.sidebar.header("Input Parameters")
 ticker = st.sidebar.text_input('Enter Stock Ticker', 'VOW.DE')
 start_date = st.sidebar.date_input('Start Date', pd.to_datetime('2010-01-01'))
 end_date = st.sidebar.date_input('End Date', pd.to_datetime('2024-12-31'))
+window_size = st.sidebar.number_input('Rolling Window Size (Days)', min_value=1, value=252)
 
 # Fetch data
 if 'data' not in st.session_state or st.sidebar.button('Fetch Data'):
@@ -363,14 +359,19 @@ if 'data' not in st.session_state or st.sidebar.button('Fetch Data'):
 
 data = st.session_state.data
 
-# Additional input for Rolling Treynor Ratio, Rolling Beta, Rolling Jensen's Alpha, Rolling Capture Ratios
+# Additional input for methods requiring benchmark or risk-free rate
 if selected in ["Rolling Treynor Ratio", "Rolling Beta", "Rolling Jensen's Alpha", "Rolling Capture Ratios"]:
     benchmark_ticker = st.sidebar.text_input('Enter Benchmark Ticker', '^GSPC')
     if 'market_data' not in st.session_state or st.sidebar.button('Fetch Market Data'):
         st.session_state.market_data = fetch_stock_data(benchmark_ticker, start_date, end_date)
-
     market_data = st.session_state.market_data
 
+if selected in ["Rolling Sharpe Ratio", "Rolling Treynor Ratio", "Rolling Jensen's Alpha", "Rolling Sortino Ratio"]:
+    risk_free_rate = st.sidebar.number_input('Risk-Free Rate (as a decimal)', min_value=0.0, value=0.0)
+
+if selected == "Rolling Sortino Ratio":
+    MAR = st.sidebar.number_input('Minimum Acceptable Return (MAR, as a decimal)', min_value=0.0, value=0.0)
+
 # Display results based on the selected method
 if selected == "Rolling Volatility":
     st.markdown("""
@@ -390,16 +391,16 @@ if selected == "Rolling Volatility":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Rolling Volatility:**
-       - Compute the rolling standard deviation of the returns over a specified window (e.g., 21 days) and annualize it:
+       - Compute the rolling standard deviation of the returns over a specified window and annualize it:
     """)
     st.latex(r'''
     \text{Rolling Volatility}_t = \sqrt{252} \times \text{std}(\text{Return}_{t-n:t})
     ''')
     st.markdown("""
-       where \( n \) is the window size (e.g., 21 days).
+       where \( n \) is the window size.
 
     3. **Calculate Volatility of Volatility:**
-       - Compute the rolling standard deviation of the rolling volatility over a specified window (e.g., 21 days):
+       - Compute the rolling standard deviation of the rolling volatility over the specified window:
     """)
     st.latex(r'''
     \text{Volatility of Volatility}_t = \text{std}(\text{Rolling Volatility}_{t-n:t})
@@ -408,18 +409,19 @@ if selected == "Rolling Volatility":
     st.markdown("""
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling volatility and the volatility of volatility.
+    2. Enter the rolling window size.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling volatility and the volatility of volatility.
     """)
 
-    fig = plot_rolling_volatility(data)
+    fig = plot_rolling_volatility(data, window_size)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Sharpe Ratio":
     st.markdown("""
     ### Rolling Sharpe Ratio
 
-    This method calculates the rolling 1-year Sharpe Ratio.
+    This method calculates the rolling Sharpe Ratio.
 
     **Methodology:**
 
@@ -433,44 +435,44 @@ elif selected == "Rolling Sharpe Ratio":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Rolling Average Return:**
-       - Compute the rolling mean of the returns over a 1-year period (252 trading days):
+       - Compute the rolling mean of the returns over the specified window:
     """)
     st.latex(r'''
-    \text{Rolling Average Return}_t = \text{mean}(\text{Return}_{t-252:t})
+    \text{Rolling Average Return}_t = \text{mean}(\text{Return}_{t-n:t})
     ''')
     st.markdown("""
        
     3. **Calculate Rolling Standard Deviation:**
-       - Compute the rolling standard deviation of the returns over a 1-year period:
+       - Compute the rolling standard deviation of the returns over the specified window:
     """)
     st.latex(r'''
-    \text{Rolling Std Dev}_t = \text{std}(\text{Return}_{t-252:t})
+    \text{Rolling Std Dev}_t = \text{std}(\text{Return}_{t-n:t})
     ''')
     st.markdown("""
        
     4. **Calculate Rolling Sharpe Ratio:**
-       - Annualize the Sharpe Ratio by multiplying by the square root of 252:
+       - Annualize the Sharpe Ratio:
     """)
     st.latex(r'''
-    \text{Rolling Sharpe Ratio}_t = \frac{\text{Rolling Average Return}_t}{\text{Rolling Std Dev}_t} \times \sqrt{252}
+    \text{Rolling Sharpe Ratio}_t = \frac{\text{Rolling Average Return}_t - R_f}{\text{Rolling Std Dev}_t} \times \sqrt{252}
     ''')
     st.markdown("""
        
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling Sharpe Ratio.
+    2. Enter the rolling window size and risk-free rate.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling Sharpe Ratio.
     """)
 
-    fig = plot_rolling_sharpe(data)
+    fig = plot_rolling_sharpe(data, window_size, risk_free_rate)
     st.plotly_chart(fig)
 
-
 elif selected == "Rolling Treynor Ratio":
     st.markdown("""
     ### Rolling Treynor Ratio
 
-    This method calculates the rolling 1-year Treynor Ratio.
+    This method calculates the rolling Treynor Ratio.
 
     **Methodology:**
 
@@ -490,7 +492,7 @@ elif selected == "Rolling Treynor Ratio":
     \beta_t = \frac{\text{Cov}(\text{Return}_{\text{stock}, t}, \text{Return}_{\text{benchmark}, t})}{\text{Var}(\text{Return}_{\text{benchmark}, t})}
     ''')
     st.markdown("""
-       where the rolling window size is typically 252 days for 1-year calculations.
+       where the rolling window size is specified.
 
     3. **Calculate Average Rolling Returns:**
        - Compute the rolling mean of the stock returns over the same window:
@@ -499,10 +501,10 @@ elif selected == "Rolling Treynor Ratio":
     \text{Average Rolling Return}_t = \frac{1}{n} \sum_{i=t-n+1}^{t} \text{Return}_{\text{stock}, i}
     ''')
     st.markdown("""
-       where \( n \) is the window size (e.g., 252 days).
+       where \( n \) is the window size.
 
     4. **Calculate Treynor Ratio:**
-       - Compute the Treynor Ratio using the risk-free rate \( R_f \) (assumed to be 0 here for simplicity):
+       - Compute the Treynor Ratio using the risk-free rate \( R_f \):
     """)
     st.latex(r'''
     \text{Treynor Ratio}_t = \frac{\text{Average Rolling Return}_t - R_f}{\beta_t}
@@ -512,12 +514,12 @@ elif selected == "Rolling Treynor Ratio":
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Enter the benchmark ticker.
+    2. Enter the benchmark ticker, rolling window size, and risk-free rate.
     3. Click 'Fetch Data' to load the stock and benchmark data.
     4. The chart will display the rolling Treynor Ratio.
     """)
 
-    fig = plot_rolling_treynor(data, market_data)
+    fig = plot_rolling_treynor(data, market_data, window_size, risk_free_rate)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Beta":
@@ -538,13 +540,13 @@ elif selected == "Rolling Beta":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Rolling Beta using OLS:**
-       - Perform a linear regression of the stock returns against the benchmark returns over a specified window (e.g., 60 days):
+       - Perform a linear regression of the stock returns against the benchmark returns over a specified window:
     """)
     st.latex(r'''
     \beta_{OLS} = \frac{\text{Cov}(\text{Return}_{\text{stock}}, \text{Return}_{\text{benchmark}})}{\text{Var}(\text{Return}_{\text{benchmark}})}
     ''')
     st.markdown("""
-       where the rolling window size is typically 60 days.
+       where the rolling window size is specified.
 
     3. **Calculate Rolling Beta using RANSAC:**
        - Use the RANSAC algorithm to robustly estimate the beta, reducing the influence of outliers:
@@ -557,19 +559,19 @@ elif selected == "Rolling Beta":
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Enter the benchmark ticker.
+    2. Enter the benchmark ticker and rolling window size.
     3. Click 'Fetch Data' to load the stock and benchmark data.
     4. The chart will display the rolling beta calculated using both OLS and RANSAC methods.
     """)
 
-    fig = plot_rolling_beta(data, market_data)
+    fig = plot_rolling_beta(data, market_data, window_size)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Jensen's Alpha":
     st.markdown("""
     ### Rolling Jensen's Alpha
 
-    This method calculates the rolling 1-year Jensen's Alpha.
+    This method calculates the rolling Jensen's Alpha.
 
     **Methodology:**
 
@@ -583,13 +585,13 @@ elif selected == "Rolling Jensen's Alpha":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Beta:**
-       - Compute the rolling beta of the stock returns against the benchmark returns over a specified window (e.g., 252 days):
+       - Compute the rolling beta of the stock returns against the benchmark returns over a specified window:
     """)
     st.latex(r'''
     \beta_t = \frac{\text{Cov}(\text{Return}_{\text{stock}, t}, \text{Return}_{\text{benchmark}, t})}{\text{Var}(\text{Return}_{\text{benchmark}, t})}
     ''')
     st.markdown("""
-       where the rolling window size is typically 252 days for 1-year calculations.
+       where the rolling window size is specified.
 
     3. **Calculate Expected Return:**
        - Compute the expected return of the stock based on the CAPM model:
@@ -598,7 +600,7 @@ elif selected == "Rolling Jensen's Alpha":
     \text{Expected Return}_t = R_f + \beta_t (\text{Return}_{\text{benchmark}} - R_f)
     ''')
     st.markdown("""
-       where \( R_f \) is the risk-free rate (assumed to be 0 here for simplicity).
+       where \( R_f \) is the risk-free rate.
 
     4. **Calculate Jensen's Alpha:**
        - Compute the Jensen's Alpha as the difference between the actual return and the expected return:
@@ -611,19 +613,19 @@ elif selected == "Rolling Jensen's Alpha":
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Enter the benchmark ticker.
+    2. Enter the benchmark ticker, rolling window size, and risk-free rate.
     3. Click 'Fetch Data' to load the stock and benchmark data.
     4. The chart will display the rolling Jensen's Alpha.
     """)
 
-    fig = plot_rolling_alpha(data, market_data)
+    fig = plot_rolling_alpha(data, market_data, window_size, risk_free_rate)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Value at Risk":
     st.markdown("""
     ### Rolling Value at Risk (VaR)
 
-    This method calculates the rolling 1-year Value at Risk (VaR) at different confidence levels.
+    This method calculates the rolling Value at Risk (VaR) at different confidence levels.
 
     **Methodology:**
 
@@ -637,31 +639,32 @@ elif selected == "Rolling Value at Risk":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Rolling VaR:**
-       - Compute the rolling quantile of the returns over a specified window (e.g., 252 days) for different confidence levels:
+       - Compute the rolling quantile of the returns over a specified window for different confidence levels:
     """)
     st.latex(r'''
     \text{VaR}_{\alpha, t} = \text{Quantile}_{\alpha}(\text{Return}_{t-n:t})
     ''')
     st.markdown("""
-       where \( \alpha \) is the confidence level (e.g., 0.05 for 95% VaR) and \( n \) is the window size (e.g., 252 days).
+       where \( \alpha \) is the confidence level and \( n \) is the window size.
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling VaR at different confidence levels (e.g., 90%, 95%, 97%).
+    2. Enter the rolling window size.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling VaR at different confidence levels.
 
     **Results:**
     The chart shows the close prices along with the rolling VaR at different confidence levels over time.
     """)
 
-    fig = plot_rolling_var(data)
+    fig = plot_rolling_var(data, window_size)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Conditional VaR":
     st.markdown("""
     ### Rolling Conditional Value at Risk (CVaR)
 
-    This method calculates the rolling 1-year Conditional Value at Risk (CVaR) at different confidence levels.
+    This method calculates the rolling Conditional Value at Risk (CVaR) at different confidence levels.
 
     **Methodology:**
 
@@ -674,41 +677,33 @@ elif selected == "Rolling Conditional VaR":
     st.markdown("""
        where \( P_t \) is the closing price at time \( t \).
 
-    2. **Calculate Rolling VaR:**
-       - Compute the rolling quantile of the returns over a specified window (e.g., 252 days) for different confidence levels:
-    """)
-    st.latex(r'''
-    \text{VaR}_{\alpha, t} = \text{Quantile}_{\alpha}(\text{Return}_{t-n:t})
-    ''')
-    st.markdown("""
-       where \( \alpha \) is the confidence level (e.g., 0.05 for 95% VaR) and \( n \) is the window size (e.g., 252 days).
-
-    3. **Calculate Rolling CVaR:**
-       - Compute the average of the returns that are below the VaR threshold:
+    2. **Calculate Rolling CVaR:**
+       - Compute the average of the returns that are below the VaR threshold over a specified window:
     """)
     st.latex(r'''
     \text{CVaR}_{\alpha, t} = \frac{1}{n} \sum_{i=1}^{n} \text{Return}_{i} \text{ where } \text{Return}_{i} < \text{VaR}_{\alpha, t}
     ''')
     st.markdown("""
-       where \( n \) is the number of returns below the VaR threshold.
+       where \( n \) is the number of returns below the VaR threshold and \( \alpha \) is the confidence level.
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling CVaR at different confidence levels (e.g., 90%, 95%, 97%).
+    2. Enter the rolling window size.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling CVaR at different confidence levels.
 
     **Results:**
     The chart shows the close prices along with the rolling CVaR at different confidence levels over time.
     """)
 
-    fig = plot_rolling_cvar(data)
+    fig = plot_rolling_cvar(data, window_size)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Tail Ratio":
     st.markdown("""
     ### Rolling Tail Ratio
 
-    This method calculates the rolling 1-year Tail Ratio.
+    This method calculates the rolling Tail Ratio.
 
     **Methodology:**
 
@@ -722,31 +717,32 @@ elif selected == "Rolling Tail Ratio":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Tail Ratio:**
-       - Compute the rolling Tail Ratio over a specified window (e.g., 252 days):
+       - Compute the rolling Tail Ratio over a specified window:
     """)
     st.latex(r'''
     \text{Tail Ratio}_t = \frac{|\text{Quantile}_{95}(\text{Return}_{t-n:t})|}{|\text{Quantile}_{5}(\text{Return}_{t-n:t})|}
     ''')
     st.markdown("""
-       where \( n \) is the window size (e.g., 252 days).
+       where \( n \) is the window size.
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling Tail Ratio.
+    2. Enter the rolling window size.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling Tail Ratio.
 
     **Results:**
     The chart shows the close prices along with the rolling Tail Ratio over time, indicating the balance between extreme positive and negative returns.
     """)
 
-    fig = plot_rolling_tail_ratio(data)
+    fig = plot_rolling_tail_ratio(data, window_size)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Omega Ratio":
     st.markdown("""
     ### Rolling Omega Ratio
 
-    This method calculates the rolling 1-year Omega Ratio.
+    This method calculates the rolling Omega Ratio.
 
     **Methodology:**
 
@@ -760,31 +756,32 @@ elif selected == "Rolling Omega Ratio":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Omega Ratio:**
-       - Compute the rolling Omega Ratio over a specified window (e.g., 252 days):
+       - Compute the rolling Omega Ratio over a specified window:
     """)
     st.latex(r'''
     \text{Omega Ratio}_t = \frac{\sum (\text{Return}_{i} > MAR) (\text{Return}_{i} - MAR)}{\sum (\text{Return}_{i} < MAR) (MAR - \text{Return}_{i})}
     ''')
     st.markdown("""
-       where \( MAR \) is the Minimum Acceptable Return (assumed to be 0 here for simplicity) and \( n \) is the window size (e.g., 252 days).
+       where \( MAR \) is the Minimum Acceptable Return and \( n \) is the window size.
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling Omega Ratio.
+    2. Enter the rolling window size and minimum acceptable return.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling Omega Ratio.
 
     **Results:**
     The chart shows the close prices along with the rolling Omega Ratio over time, indicating the risk-return trade-off.
     """)
 
-    fig = plot_rolling_omega(data)
+    fig = plot_rolling_omega(data, window_size)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Sortino Ratio":
     st.markdown("""
     ### Rolling Sortino Ratio
 
-    This method calculates the rolling 1-year Sortino Ratio.
+    This method calculates the rolling Sortino Ratio.
 
     **Methodology:**
 
@@ -798,31 +795,32 @@ elif selected == "Rolling Sortino Ratio":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Rolling Sortino Ratio:**
-       - Compute the rolling Sortino Ratio over a specified window (e.g., 252 days):
+       - Compute the rolling Sortino Ratio over a specified window:
     """)
     st.latex(r'''
     \text{Sortino Ratio}_t = \frac{\sqrt{252} \cdot \text{Mean}(\text{Return}_{t-n:t} - MAR)}{\sqrt{\text{Mean}(\min(0, \text{Return}_{t-n:t} - MAR)^2)}}
     ''')
     st.markdown("""
-       where \( MAR \) is the Minimum Acceptable Return (assumed to be 0 here for simplicity) and \( n \) is the window size (e.g., 252 days).
+       where \( MAR \) is the Minimum Acceptable Return and \( n \) is the window size.
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling Sortino Ratio.
+    2. Enter the rolling window size and minimum acceptable return.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling Sortino Ratio.
 
     **Results:**
     The chart shows the close prices along with the rolling Sortino Ratio over time, indicating the risk-adjusted return considering downside risk.
     """)
 
-    fig = plot_rolling_sortino(data)
+    fig = plot_rolling_sortino(data, window_size, MAR)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Calmar Ratio":
     st.markdown("""
     ### Rolling Calmar Ratio
 
-    This method calculates the rolling 1-year Calmar Ratio.
+    This method calculates the rolling Calmar Ratio.
 
     **Methodology:**
 
@@ -836,32 +834,32 @@ elif selected == "Rolling Calmar Ratio":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Rolling Calmar Ratio:**
-       - Compute the rolling Calmar Ratio over a specified window (e.g., 252 days):
+       - Compute the rolling Calmar Ratio over a specified window:
     """)
     st.latex(r'''
     \text{Calmar Ratio}_t = \frac{\text{CAGR}_{t-n:t}}{\text{Max Drawdown}_{t-n:t}}
     ''')
     st.markdown("""
-       where \( \text{CAGR} \) is the Compound Annual Growth Rate and \( \text{Max Drawdown} \) is the maximum drawdown over the window \( n \) (e.g., 252 days).
+       where \( \text{CAGR} \) is the Compound Annual Growth Rate and \( \text{Max Drawdown} \) is the maximum drawdown over the window \( n \).
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling Calmar Ratio.
+    2. Enter the rolling window size.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling Calmar Ratio.
 
     **Results:**
     The chart shows the close prices along with the rolling Calmar Ratio over time, indicating the performance of the stock relative to its maximum drawdown.
     """)
 
-    fig = plot_rolling_calmar(data)
+    fig = plot_rolling_calmar(data, window_size)
     st.plotly_chart(fig)
 
-
 elif selected == "Rolling Stability":
     st.markdown("""
     ### Rolling Stability
 
-    This method calculates the rolling 1-year stability of returns.
+    This method calculates the rolling stability of returns.
 
     **Methodology:**
 
@@ -875,31 +873,32 @@ elif selected == "Rolling Stability":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Rolling Stability:**
-       - Compute the rolling stability over a specified window (e.g., 252 days):
+       - Compute the rolling stability over a specified window:
     """)
     st.latex(r'''
     \text{Stability}_t = \sqrt{\frac{1}{n-1} \sum_{i=1}^{n} (\log(1 + \text{Return}_{t-i}) - \overline{\log(1 + \text{Return})})^2}
     ''')
     st.markdown("""
-       where \( n \) is the window size (e.g., 252 days) and \( \overline{\log(1 + \text{Return})} \) is the mean of the log returns over the window.
+       where \( n \) is the window size and \( \overline{\log(1 + \text{Return})} \) is the mean of the log returns over the window.
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling stability.
+    2. Enter the rolling window size.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling stability.
 
     **Results:**
     The chart shows the close prices along with the rolling stability over time, indicating the consistency of returns.
     """)
 
-    fig = plot_rolling_stability(data)
+    fig = plot_rolling_stability(data, window_size)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Maximum Drawdown":
     st.markdown("""
     ### Rolling Maximum Drawdown
 
-    This method calculates the rolling 1-year maximum drawdown.
+    This method calculates the rolling maximum drawdown.
 
     **Methodology:**
 
@@ -913,7 +912,7 @@ elif selected == "Rolling Maximum Drawdown":
        where \( P_t \) is the closing price at time \( t \).
 
     2. **Calculate Rolling Maximum Drawdown:**
-       - Compute the cumulative returns and the maximum drawdown over a specified window (e.g., 252 days):
+       - Compute the cumulative returns and the maximum drawdown over a specified window:
     """)
     st.latex(r'''
     \text{Cumulative Return}_t = \prod_{i=1}^{t} (1 + \text{Return}_i)
@@ -926,21 +925,22 @@ elif selected == "Rolling Maximum Drawdown":
 
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling maximum drawdown.
+    2. Enter the rolling window size.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling maximum drawdown.
 
     **Results:**
     The chart shows the close prices along with the rolling maximum drawdown over time, indicating the peak-to-trough decline during a specified period.
     """)
 
-    fig = plot_rolling_drawdown(data)
+    fig = plot_rolling_drawdown(data, window_size)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Capture Ratios":
     st.markdown("""
     ### Rolling Capture Ratios
 
-    This method calculates the rolling 1-year upside and downside capture ratios.
+    This method calculates the rolling upside and downside capture ratios.
 
     **Methodology:**
 
@@ -969,7 +969,7 @@ elif selected == "Rolling Capture Ratios":
     st.markdown("""
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Enter the benchmark ticker.
+    2. Enter the benchmark ticker and rolling window size.
     3. Click 'Fetch Data' to load the stock and benchmark data.
     4. The chart will display the rolling capture ratios.
 
@@ -977,14 +977,14 @@ elif selected == "Rolling Capture Ratios":
     The chart shows the close prices along with the rolling upside and downside capture ratios over time, indicating the stock's performance relative to the benchmark during up and down market conditions.
     """)
 
-    fig = plot_rolling_capture(data, market_data)
+    fig = plot_rolling_capture(data, market_data, window_size)
     st.plotly_chart(fig)
 
 elif selected == "Rolling Pain Index":
     st.markdown("""
     ### Rolling Pain Index
 
-    This method calculates the rolling 1-year pain index.
+    This method calculates the rolling pain index.
 
     **Methodology:**
 
@@ -1012,7 +1012,7 @@ elif selected == "Rolling Pain Index":
     ''')
     st.markdown("""
     4. **Calculate Rolling Pain Index:**
-       - Compute the average drawdown over a specified window (e.g., 252 days) where the drawdown is negative:
+       - Compute the average drawdown over a specified window where the drawdown is negative:
     """)
     st.latex(r'''
     \text{Pain Index} = \frac{1}{n} \sum_{i=1}^{n} \text{Drawdown}_i \quad \text{for } \text{Drawdown}_i < 0
@@ -1020,14 +1020,15 @@ elif selected == "Rolling Pain Index":
     st.markdown("""
     **How to use:**
     1. Enter the stock ticker, start date, and end date.
-    2. Click 'Fetch Data' to load the stock data.
-    3. The chart will display the rolling pain index.
+    2. Enter the rolling window size.
+    3. Click 'Fetch Data' to load the stock data.
+    4. The chart will display the rolling pain index.
 
     **Results:**
     The chart shows the close prices along with the rolling pain index over time, indicating the average drawdown experienced over a specified period.
     """)
 
-    fig = plot_rolling_pain_index(data)
+    fig = plot_rolling_pain_index(data, window_size)
     st.plotly_chart(fig)
 
 hide_streamlit_style = """