Update app.py

app.py

@@ -1,16 +1,20 @@
 import yfinance as yf
 import numpy as np
 import pandas as pd
-import matplotlib.pyplot as plt
 import streamlit as st
 from sklearn.linear_model import RANSACRegressor, LinearRegression
 from scipy.stats import linregress
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
+import datetime
 
 # Helper function to fetch stock data
 def fetch_stock_data(ticker: str, start_date: str, end_date: str) -> pd.DataFrame:
-    return yf.download(ticker, start=start_date, end=end_date)
+    """Fetch stock data from Yahoo Finance."""
+    data = yf.download(ticker, start=start_date, end=end_date, auto_adjust=False)
+    if isinstance(data.columns, pd.MultiIndex):
+        data.columns = data.columns.get_level_values(0)
+    return data
 
 # Helper function to plot rolling volatility and volatility of volatility
 def plot_rolling_volatility(data: pd.DataFrame, window: int) -> go.Figure:
@@ -50,11 +54,12 @@ def plot_rolling_treynor(data: pd.DataFrame, market_data: pd.DataFrame, window:
 
     # Align indices
     market_data = market_data.reindex(data.index, method='ffill')
+    aligned_data = pd.concat([data['Return'], market_data['Return']], axis=1).dropna()
 
-    covariance = data['Return'].rolling(window=window).cov(market_data['Return'])
-    variance = market_data['Return'].rolling(window=window).var()
+    covariance = aligned_data['Return'].rolling(window=window).cov(aligned_data['Return'].rename('Market_Return'))
+    variance = aligned_data['Return'].rolling(window=window).var()
     rolling_beta = covariance / variance
-    avg_rolling_returns = data['Return'].rolling(window=window).mean()
+    avg_rolling_returns = aligned_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,
@@ -69,8 +74,8 @@ def plot_rolling_treynor(data: pd.DataFrame, market_data: pd.DataFrame, window:
 
 # Helper function to calculate and plot rolling beta
 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()
+    data['Return'] = data['Close'].pct_change()
+    market_data['Market_Return'] = market_data['Close'].pct_change()
     
     # Align dates and remove rows with missing data
     aligned_data = pd.concat([data['Return'], market_data['Market_Return']], axis=1).dropna()
@@ -80,7 +85,7 @@ def plot_rolling_beta(data: pd.DataFrame, market_data: pd.DataFrame, window: int
     rolling_beta_ransac = []
     rolling_beta_ols = []
 
-    for i in range(len(aligned_data) - window):
+    for i in range(len(aligned_data) - window + 1):
         X = aligned_data['Market_Return'].iloc[i:i+window].values.reshape(-1, 1)
         y = aligned_data['Return'].iloc[i:i+window].values
 
@@ -93,8 +98,8 @@ def plot_rolling_beta(data: pd.DataFrame, market_data: pd.DataFrame, window: int
         rolling_beta_ols.append(beta_ols)
 
     # Convert lists to series with appropriate index
-    rolling_beta_ransac = pd.Series(rolling_beta_ransac, index=aligned_data.index[window:])
-    rolling_beta_ols = pd.Series(rolling_beta_ols, index=aligned_data.index[window:])
+    rolling_beta_ransac = pd.Series(rolling_beta_ransac, index=aligned_data.index[window-1:])
+    rolling_beta_ols = pd.Series(rolling_beta_ols, index=aligned_data.index[window-1:])
 
     fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Benchmark Price', 'Rolling Beta (RANSAC & OLS)'))
@@ -112,17 +117,20 @@ def plot_rolling_alpha(data: pd.DataFrame, market_data: pd.DataFrame, window: in
     data['Return'] = data['Close'].pct_change()
     market_data['Return'] = market_data['Close'].pct_change()
 
-    rolling_alpha = []
+    # Align indices
+    market_data = market_data.reindex(data.index, method='ffill')
+    aligned_data = pd.concat([data['Return'], market_data['Return']], axis=1).dropna()
 
-    for i in range(len(data) - window):
-        window_stock = data['Return'].iloc[i:i + window]
-        window_market = market_data['Return'].iloc[i:i + window]
+    rolling_alpha = []
+    for i in range(len(aligned_data) - window + 1):
+        window_stock = aligned_data['Return'].iloc[i:i + window]
+        window_market = aligned_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:])
+    rolling_alpha = pd.Series(rolling_alpha, index=aligned_data.index[window-1:])
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Jensen\'s Alpha'))
@@ -156,8 +164,8 @@ 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])
+        var = np.percentile(x.dropna(), alpha * 100)
+        return np.mean(x[x < var]) if len(x[x < var]) > 0 else np.nan
 
     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()
@@ -177,7 +185,7 @@ def plot_rolling_cvar(data: pd.DataFrame, window: int) -> go.Figure:
 # Helper function to plot rolling Tail Ratio
 def plot_rolling_tail_ratio(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    tail_ratio = data['Return'].rolling(window).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.dropna(), 95)) / np.abs(np.percentile(x.dropna(), 5)) if len(x.dropna()) > 0 else np.nan).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Tail Ratio'))
@@ -193,7 +201,7 @@ def plot_rolling_tail_ratio(data: pd.DataFrame, window: int) -> 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(window).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]) if np.sum(x[x < MAR]) != 0 else np.inf).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Omega Ratio'))
@@ -208,7 +216,7 @@ def plot_rolling_omega(data: pd.DataFrame, window: int) -> go.Figure:
 # Helper function to plot rolling Sortino Ratio
 def plot_rolling_sortino(data: pd.DataFrame, window: int, MAR: float) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    sortino_ratio = data['Return'].rolling(window).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.sqrt(252) * np.mean(x - MAR) / np.sqrt(np.mean(np.minimum(0, x - MAR) ** 2)) if np.mean(np.minimum(0, x - MAR) ** 2) > 0 else np.inf).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Sortino Ratio'))
@@ -222,7 +230,7 @@ def plot_rolling_sortino(data: pd.DataFrame, window: int, MAR: float) -> go.Figu
 # Helper function to plot rolling Calmar Ratio
 def plot_rolling_calmar(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    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()
+    calmar_ratio = data['Return'].rolling(window).apply(lambda x: (1 + x).prod() ** (252.0 / len(x)) / np.abs(np.min((1 + x).cumprod() / (1 + x).cumprod().cummax()) - 1) if np.min((1 + x).cumprod() / (1 + x).cumprod().cummax()) < 1 else np.inf).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Calmar Ratio'))
@@ -236,7 +244,7 @@ def plot_rolling_calmar(data: pd.DataFrame, window: int) -> go.Figure:
 # Helper function to plot rolling stability
 def plot_rolling_stability(data: pd.DataFrame, window: int) -> go.Figure:
     data['Return'] = data['Close'].pct_change()
-    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()
+    stability = data['Return'].rolling(window).apply(lambda x: np.std(np.log1p(x.dropna()).cumsum() - linregress(np.arange(len(x.dropna())), np.log1p(x.dropna()).cumsum()).intercept - linregress(np.arange(len(x.dropna())), np.log1p(x.dropna()).cumsum()).slope * np.arange(len(x.dropna()))) if len(x.dropna()) > 1 else np.nan).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Stability'))
@@ -270,6 +278,7 @@ def plot_rolling_capture(data: pd.DataFrame, market_data: pd.DataFrame, window:
 
     # Align indices
     market_data = market_data.reindex(data.index, method='ffill')
+    aligned_data = pd.concat([data['Return'], market_data['Return']], axis=1).dropna()
 
     def calculate_capture(stock_returns, market_returns, is_upside=True):
         if is_upside:
@@ -278,7 +287,7 @@ def plot_rolling_capture(data: pd.DataFrame, market_data: pd.DataFrame, window:
         else:
             relevant_returns = stock_returns[market_returns < 0]
             relevant_market_returns = market_returns[market_returns < 0]
-        return relevant_returns.sum() / relevant_market_returns.sum()
+        return relevant_returns.sum() / relevant_market_returns.sum() if len(relevant_market_returns) > 0 else np.nan
 
     def compute_rolling_captures(stock_returns, market_returns, window):
         upside_captures = []
@@ -298,15 +307,15 @@ def plot_rolling_capture(data: pd.DataFrame, market_data: pd.DataFrame, window:
             upside_captures.append(upside)
             downside_captures.append(downside)
 
-        # Padding the initial values with NaNs to make the length equal to original data
+        # Padding the initial values with NaNs to match index length
         nan_padding = [np.nan] * (window - 1)
-        upside_captures = nan_padding + upside_captures
-        downside_captures = nan_padding + downside_captures
+        upside_captures = pd.Series(nan_padding + upside_captures, index=stock_returns.index)
+        downside_captures = pd.Series(nan_padding + downside_captures, index=stock_returns.index)
 
         return upside_captures, downside_captures
 
     data['rolling_upside_capture'], data['rolling_downside_capture'] = compute_rolling_captures(
-        data['Return'], market_data['Return'], window
+        aligned_data['Return'], aligned_data['Return'].rename('Market_Return'), window
     )
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
@@ -325,7 +334,7 @@ def plot_rolling_pain_index(data: pd.DataFrame, window: int) -> go.Figure:
     cumulative_return = (1 + data['Return']).cumprod()
     running_max = cumulative_return.cummax()
     drawdown = (cumulative_return - running_max) / running_max
-    pain_index = drawdown.rolling(window).apply(lambda x: np.mean(x[x < 0])).dropna()
+    pain_index = drawdown.rolling(window).apply(lambda x: np.mean(x[x < 0]) if len(x[x < 0]) > 0 else 0).dropna()
 
     fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
                         subplot_titles=('Close Price', 'Rolling Pain Index'))
@@ -342,9 +351,6 @@ st.title('Dynamic Risk Management Indicators')
 
 st.sidebar.title("Input Parameters")
 
-# Sidebar for method selection
-import datetime
-
 # Setting today's date plus one day
 today_plus_one = pd.to_datetime(datetime.datetime.now().date() + pd.Timedelta(days=1))
 
@@ -367,588 +373,470 @@ with st.sidebar.expander("Select Method", expanded=True):
 window_size = st.sidebar.number_input('Rolling Window Size (Days)', min_value=1, value=252, 
                                       help="Enter the number of days to use for the rolling window in the selected risk indicator calculation.")
 
-
 # Fetch data
 if 'data' not in st.session_state or st.sidebar.button('Fetch Data'):
-    st.session_state.data = fetch_stock_data(ticker, start_date, end_date)
-
-data = st.session_state.data
-
-# 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', 
-                                             help="Enter the ticker symbol for the benchmark index (e.g., ^GSPC for S&P 500).")
-    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, 
-                                             help="Enter the risk-free rate as a decimal (e.g., 0.01 for 1%).")
-
-if selected == "Rolling Sortino Ratio":
-    MAR = st.sidebar.number_input('Minimum Acceptable Return (MAR, as a decimal)', min_value=0.0, value=0.0, 
-                                  help="Enter the Minimum Acceptable Return (MAR) as a decimal (e.g., 0.02 for 2%).")
-
-# Display results based on the selected method
-if selected == "Rolling Volatility":
-    st.markdown("""
-    ### Rolling Volatility
-
-    This method calculates the rolling volatility and the volatility of volatility.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           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 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.
-
-        3. **Calculate Volatility of Volatility:**
-           - 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})
-        ''')
-
-
-    fig = plot_rolling_volatility(data, window_size)
-    st.plotly_chart(fig)
-
-# Display results based on the selected method
-if selected == "Rolling Sharpe Ratio":
-    st.markdown("""
-    ### Rolling Sharpe Ratio
-
-    This method calculates the rolling Sharpe Ratio.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           where `(P_t)` is the closing price at time `(t)`.
-
-        2. **Calculate Rolling Average Return:**
-           - Compute the rolling mean of the returns over the specified window:
-        """)
-        st.latex(r'''
-        \text{Rolling Average Return}_t = \text{mean}(\text{Return}_{t-n:t})
-        ''')
-        st.markdown("""
-           where `(n)` is the window size.
-
-        3. **Calculate Rolling Standard Deviation:**
-           - 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-n:t})
-        ''')
-        st.markdown("""
-        where `(n)` is the window size.
-
-        4. **Calculate Rolling Sharpe Ratio:**
-           - Annualize the Sharpe Ratio:
-        """)
-        st.latex(r'''
-        \text{Rolling Sharpe Ratio}_t = \frac{\text{Rolling Average Return}_t - R_f}{\text{Rolling Std Dev}_t} \times \sqrt{252}
-        ''')
-        st.markdown("""
-           where `(R_f)` is the risk-free rate.
-        """)
-
-    fig = plot_rolling_sharpe(data, window_size, risk_free_rate)
-    st.plotly_chart(fig)
-
-# Display results based on the selected method
-if selected == "Rolling Treynor Ratio":
-    st.markdown("""
-    ### Rolling Treynor Ratio
-
-    This method calculates the rolling Treynor Ratio.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock and the benchmark:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-        where `(P_t)` is the closing price at time `(t)`.
-
-        2. **Calculate Beta:**
-           - Compute the rolling covariance between the stock and benchmark returns, and divide by the rolling variance of the benchmark returns to get the rolling beta:
-        """)
-        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 `(n)` is the window size.
-
-        3. **Calculate Average Rolling Returns:**
-           - Compute the rolling mean of the stock returns over the same window:
-        """)
-        st.latex(r'''
-        \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.
-
-        4. **Calculate Treynor Ratio:**
-           - 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}
-        ''')
-        st.markdown("""
-        where `(R_f)` is the risk-free rate.
-        """)
-
-    fig = plot_rolling_treynor(data, market_data, window_size, risk_free_rate)
-    st.plotly_chart(fig)
-
-# Display results based on the selected method
-if selected == "Rolling Beta":
-    st.markdown("""
-    ### Rolling Beta
-
-    This method calculates the rolling beta of a stock's returns against a benchmark using RANSAC and OLS methods.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock and the benchmark:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-        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:
-        """)
-        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 `(n)` is the window size.
-
-        3. **Calculate Rolling Beta using RANSAC:**
-           - Use the RANSAC algorithm to robustly estimate the beta, reducing the influence of outliers:
-        """)
-        st.latex(r'''
-        \beta_{RANSAC} = \text{RANSAC}(\text{Return}_{\text{benchmark}}, \text{Return}_{\text{stock}})
-        ''')
-        st.markdown("""
-        RANSAC algorithm iteratively fits the model and removes outliers.
-        """)
-
-    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 Jensen's Alpha.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock and the benchmark:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           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:
-        """)
-        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 `(n)` is the window size.
-
-        3. **Calculate Expected Return:**
-           - Compute the expected return of the stock based on the CAPM model:
-        """)
-        st.latex(r'''
-        \text{Expected Return}_t = R_f + \beta_t (\text{Return}_{\text{benchmark}} - R_f)
-        ''')
-        st.markdown("""
-           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:
-        """)
-        st.latex(r'''
-        \alpha_t = \text{Return}_{\text{stock}, t} - \text{Expected Return}_t
-        ''')
-        st.markdown("""
-           where `(α_t)` is Jensen's Alpha at time `(t)`.
-        """)
-
-    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 Value at Risk (VaR) at different confidence levels.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        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 for different confidence levels:
-        """)
-        st.latex(r'''
-        \text{VaR}_{\alpha, t} = \text{Quantile}_{\alpha}(\text{Return}_{t-n:t})
-        ''')
-        st.markdown("""
-           where `(α)` is the confidence level and `(n)` is the window size.
-        """)
-
-    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 Conditional Value at Risk (CVaR) at different confidence levels.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           where `(P_t)` is the closing price at time `(t)`.
-
-        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 and `(α)` is the confidence level.
-        """)
-
-    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 Tail Ratio.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           where `(P_t)` is the closing price at time `(t)`.
-
-        2. **Calculate Tail Ratio:**
-           - 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.
-        """)
-
-    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 Omega Ratio.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           where `(P_t)` is the closing price at time `(t)`.
-
-        2. **Calculate Omega Ratio:**
-           - 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 and `(n)` is the window size.
-        """)
-
-    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 Sortino Ratio.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           where `(P_t)` is the closing price at time `(t)`.
-
-        2. **Calculate Rolling Sortino Ratio:**
-           - 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 and `(n)` is the window size.
-        """)
-
-    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 Calmar Ratio.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           where `(P_t)` is the closing price at time `(t)`.
-
-        2. **Calculate Rolling Calmar Ratio:**
-           - 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 `CAGR` is the Compound Annual Growth Rate and `Max Drawdown` is the maximum drawdown over the window `(n)`.
-        """)
-
-    fig = plot_rolling_calmar(data, window_size)
-    st.plotly_chart(fig)
-
-elif selected == "Rolling Stability":
-    st.markdown("""
-    ### Rolling Stability
-
-    This method calculates the rolling stability of returns.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           where `(P_t)` is the closing price at time `(t)`.
-
-        2. **Calculate Rolling Stability:**
-           - 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 and `\overline{\log(1 + \text{Return})}` is the mean of the log returns over the window.
-        """)
-
-    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 maximum drawdown.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           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:
-        """)
-        st.latex(r'''
-        \text{Cumulative Return}_t = \prod_{i=1}^{t} (1 + \text{Return}_i)
-        ''')
-        st.latex(r'''
-        \text{Max Drawdown}_t = \frac{\text{Cumulative Return}_t - \text{Rolling Max Cumulative Return}_t}{\text{Rolling Max Cumulative Return}_t}
-        ''')
-        st.markdown("""
-           where the Rolling Max Cumulative Return is the maximum cumulative return over the window.
-        """)
-
-    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 upside and downside capture ratios.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock and the benchmark:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           where `(P_t)` is the closing price at time `(t)`.
-
-        2. **Calculate Upside Capture Ratio:**
-           - Compute the ratio of the sum of the stock's returns to the sum of the benchmark's returns during periods when the benchmark's returns are positive:
-        """)
-        st.latex(r'''
-        \text{Upside Capture Ratio}_t = \frac{\sum_{i=1}^{t} \text{Return}_{\text{stock}, i}}{\sum_{i=1}^{t} \text{Return}_{\text{benchmark}, i}}, \quad \text{if } \text{Return}_{\text{benchmark}, i} > 0
-        ''')
-        st.markdown("""
-        
-        3. **Calculate Downside Capture Ratio:**
-           - Compute the ratio of the sum of the stock's returns to the sum of the benchmark's returns during periods when the benchmark's returns are negative:
-        """)
-        st.latex(r'''
-        \text{Downside Capture Ratio}_t = \frac{\sum_{i=1}^{t} \text{Return}_{\text{stock}, i}}{\sum_{i=1}^{t} \text{Return}_{\text{benchmark}, i}}, \quad \text{if } \text{Return}_{\text{benchmark}, i} < 0
-        ''')
-
-    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 pain index.
-    """)
-
-    with st.expander("Methodology", expanded=False):
-        st.markdown("""
-        1. **Calculate Returns:**
-           - Compute the daily returns of the stock:
-        """)
-        st.latex(r'''
-        \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
-        ''')
-        st.markdown("""
-           where `(P_t)` is the closing price at time `(t)`.
-
-        2. **Calculate Cumulative Returns:**
-           - Compute the cumulative returns over time:
-        """)
-        st.latex(r'''
-        \text{Cumulative Return}_t = \prod_{i=1}^{t} (1 + \text{Return}_i)
-        ''')
-        st.markdown("""
-        
-        3. **Calculate Drawdowns:**
-           - Determine the drawdowns by comparing the cumulative returns to their running maximum:
-        """)
-        st.latex(r'''
-        \text{Drawdown}_t = \frac{\text{Cumulative Return}_t - \text{Running Max Cumulative Return}_t}{\text{Running Max Cumulative Return}_t}
-        ''')
-        st.markdown("""
-        
-        4. **Calculate Rolling Pain Index:**
-           - 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
-        ''')
-
-    fig = plot_rolling_pain_index(data, window_size)
-    st.plotly_chart(fig)
+    data = fetch_stock_data(ticker, start_date, end_date)
+    if data.empty:
+        st.error(f"No data returned for {ticker} from {start_date} to {end_date}")
+    else:
+        st.session_state.data = data
+
+if 'data' in st.session_state and not st.session_state.data.empty:
+    data = st.session_state.data
+
+    # 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', 
+                                                help="Enter the ticker symbol for the benchmark index (e.g., ^GSPC for S&P 500).")
+        if 'market_data' not in st.session_state or st.sidebar.button('Fetch Market Data'):
+            market_data = fetch_stock_data(benchmark_ticker, start_date, end_date)
+            if market_data.empty:
+                st.error(f"No data returned for {benchmark_ticker} from {start_date} to {end_date}")
+            else:
+                st.session_state.market_data = market_data
+        if 'market_data' in st.session_state and not st.session_state.market_data.empty:
+            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, 
+                                                help="Enter the risk-free rate as a decimal (e.g., 0.01 for 1%).")
+
+    if selected == "Rolling Sortino Ratio":
+        MAR = st.sidebar.number_input('Minimum Acceptable Return (MAR, as a decimal)', min_value=0.0, value=0.0, 
+                                    help="Enter the Minimum Acceptable Return (MAR) as a decimal (e.g., 0.02 for 2%).")
+
+    # Display results based on the selected method
+    if selected == "Rolling Volatility":
+        st.markdown("""
+        ### Rolling Volatility
+        This method calculates the rolling volatility and the volatility of volatility.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+               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 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.
+            3. **Calculate Volatility of Volatility:**
+               - 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})
+            ''')
+        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 Sharpe Ratio.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+               where `(P_t)` is the closing price at time `(t)`.
+            2. **Calculate Rolling Average Return:**
+               - Compute the rolling mean of the returns over the specified window:
+            """)
+            st.latex(r'''
+            \text{Rolling Average Return}_t = \text{mean}(\text{Return}_{t-n:t})
+            ''')
+            st.markdown("""
+               where `(n)` is the window size.
+            3. **Calculate Rolling Standard Deviation:**
+               - 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-n:t})
+            ''')
+            st.markdown("""
+            4. **Calculate Rolling Sharpe Ratio:**
+               - Annualize the Sharpe Ratio:
+            """)
+            st.latex(r'''
+            \text{Rolling Sharpe Ratio}_t = \frac{\text{Rolling Average Return}_t - R_f}{\text{Rolling Std Dev}_t} \times \sqrt{252}
+            ''')
+            st.markdown("""
+               where `(R_f)` is the risk-free rate.
+            """)
+        fig = plot_rolling_sharpe(data, window_size, risk_free_rate)
+        st.plotly_chart(fig)
+
+    elif selected == "Rolling Treynor Ratio" and 'market_data' in st.session_state:
+        st.markdown("""
+        ### Rolling Treynor Ratio
+        This method calculates the rolling Treynor Ratio.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock and the benchmark:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Beta:**
+               - Compute the rolling covariance between the stock and benchmark returns, and divide by the rolling variance of the benchmark returns to get the rolling beta:
+            """)
+            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("""
+            3. **Calculate Average Rolling Returns:**
+               - Compute the rolling mean of the stock returns over the same window:
+            """)
+            st.latex(r'''
+            \text{Average Rolling Return}_t = \frac{1}{n} \sum_{i=t-n+1}^{t} \text{Return}_{\text{stock}, i}
+            ''')
+            st.markdown("""
+            4. **Calculate Treynor Ratio:**
+               - 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}
+            ''')
+        fig = plot_rolling_treynor(data, market_data, window_size, risk_free_rate)
+        st.plotly_chart(fig)
+
+    elif selected == "Rolling Beta" and 'market_data' in st.session_state:
+        st.markdown("""
+        ### Rolling Beta
+        This method calculates the rolling beta of a stock's returns against a benchmark using RANSAC and OLS methods.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock and the benchmark:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Rolling Beta using OLS:**
+               - 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("""
+            3. **Calculate Rolling Beta using RANSAC:**
+               - Use the RANSAC algorithm to robustly estimate the beta, reducing the influence of outliers:
+            """)
+            st.latex(r'''
+            \beta_{RANSAC} = \text{RANSAC}(\text{Return}_{\text{benchmark}}, \text{Return}_{\text{stock}})
+            ''')
+        fig = plot_rolling_beta(data, market_data, window_size)
+        st.plotly_chart(fig)
+
+    elif selected == "Rolling Jensen's Alpha" and 'market_data' in st.session_state:
+        st.markdown("""
+        ### Rolling Jensen's Alpha
+        This method calculates the rolling Jensen's Alpha.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock and the benchmark:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Beta:**
+               - 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("""
+            3. **Calculate Expected Return:**
+               - Compute the expected return of the stock based on the CAPM model:
+            """)
+            st.latex(r'''
+            \text{Expected Return}_t = R_f + \beta_t (\text{Return}_{\text{benchmark}} - R_f)
+            ''')
+            st.markdown("""
+            4. **Calculate Jensen's Alpha:**
+               - Compute the Jensen's Alpha as the difference between the actual return and the expected return:
+            """)
+            st.latex(r'''
+            \alpha_t = \text{Return}_{\text{stock}, t} - \text{Expected Return}_t
+            ''')
+        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 Value at Risk (VaR) at different confidence levels.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Rolling VaR:**
+               - 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})
+            ''')
+        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 Conditional Value at Risk (CVaR) at different confidence levels.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            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}
+            ''')
+        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 Tail Ratio.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Tail Ratio:**
+               - 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})|}
+            ''')
+        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 Omega Ratio.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Omega Ratio:**
+               - 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})}
+            ''')
+        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 Sortino Ratio.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Rolling Sortino Ratio:**
+               - 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)}}
+            ''')
+        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 Calmar Ratio.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Rolling Calmar Ratio:**
+               - 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}}
+            ''')
+        fig = plot_rolling_calmar(data, window_size)
+        st.plotly_chart(fig)
+
+    elif selected == "Rolling Stability":
+        st.markdown("""
+        ### Rolling Stability
+        This method calculates the rolling stability of returns.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Rolling Stability:**
+               - 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}
+            ''')
+        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 maximum drawdown.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Rolling Maximum Drawdown:**
+               - 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)
+            ''')
+            st.latex(r'''
+            \text{Max Drawdown}_t = \frac{\text{Cumulative Return}_t - \text{Rolling Max Cumulative Return}_t}{\text{Rolling Max Cumulative Return}_t}
+            ''')
+        fig = plot_rolling_drawdown(data, window_size)
+        st.plotly_chart(fig)
+
+    elif selected == "Rolling Capture Ratios" and 'market_data' in st.session_state:
+        st.markdown("""
+        ### Rolling Capture Ratios
+        This method calculates the rolling upside and downside capture ratios.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock and the benchmark:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Upside Capture Ratio:**
+               - Compute the ratio of the sum of the stock's returns to the sum of the benchmark's returns during periods when the benchmark's returns are positive:
+            """)
+            st.latex(r'''
+            \text{Upside Capture Ratio}_t = \frac{\sum_{i=1}^{t} \text{Return}_{\text{stock}, i}}{\sum_{i=1}^{t} \text{Return}_{\text{benchmark}, i}}, \quad \text{if } \text{Return}_{\text{benchmark}, i} > 0
+            ''')
+            st.markdown("""
+            3. **Calculate Downside Capture Ratio:**
+               - Compute the ratio of the sum of the stock's returns to the sum of the benchmark's returns during periods when the benchmark's returns are negative:
+            """)
+            st.latex(r'''
+            \text{Downside Capture Ratio}_t = \frac{\sum_{i=1}^{t} \text{Return}_{\text{stock}, i}}{\sum_{i=1}^{t} \text{Return}_{\text{benchmark}, i}}, \quad \text{if } \text{Return}_{\text{benchmark}, i} < 0
+            ''')
+        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 pain index.
+        """)
+        with st.expander("Methodology", expanded=False):
+            st.markdown("""
+            1. **Calculate Returns:**
+               - Compute the daily returns of the stock:
+            """)
+            st.latex(r'''
+            \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+            ''')
+            st.markdown("""
+            2. **Calculate Cumulative Returns:**
+               - Compute the cumulative returns over time:
+            """)
+            st.latex(r'''
+            \text{Cumulative Return}_t = \prod_{i=1}^{t} (1 + \text{Return}_i)
+            ''')
+            st.markdown("""
+            3. **Calculate Drawdowns:**
+               - Determine the drawdowns by comparing the cumulative returns to their running maximum:
+            """)
+            st.latex(r'''
+            \text{Drawdown}_t = \frac{\text{Cumulative Return}_t - \text{Running Max Cumulative Return}_t}{\text{Running Max Cumulative Return}_t}
+            ''')
+            st.markdown("""
+            4. **Calculate Rolling Pain Index:**
+               - 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
+            ''')
+        fig = plot_rolling_pain_index(data, window_size)
+        st.plotly_chart(fig)
 
 hide_streamlit_style = """
 <style>
@@ -956,4 +844,4 @@ hide_streamlit_style = """
 footer {visibility: hidden;}
 </style>
 """
-st.markdown(hide_streamlit_style, unsafe_allow_html=True) 
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)