Create app.py

app.py

@@ -0,0 +1,152 @@
+import numpy as np
+import pandas as pd
+import yfinance as yf
+import plotly.graph_objects as go
+import streamlit as st
+
+#st.title('Analyzing Future Stock Price Movements with Monte Carlo Simulations')
+st.set_page_config(page_title = "Analyzing Future Stock Price Movements with Monte Carlo Simulations", layout = "wide")
+
+# Sidebar inputs
+st.sidebar.header('Input Parameters')
+ticker = st.sidebar.text_input('Enter Stock Ticker', 'AFX.DE')
+start_date = st.sidebar.date_input('Start Date', pd.to_datetime('2020-01-01'))
+end_date = st.sidebar.date_input('End Date', pd.to_datetime('2025-12-30'))
+days_to_forecast = st.sidebar.slider('Time Horizon (Days)', min_value=1, max_value=60, value=30)
+num_simulations = st.sidebar.number_input('Number of Simulations', min_value=100, max_value=100000, value=1000, step=100)
+lower_threshold = st.sidebar.number_input('Lower Threshold', min_value=0, max_value=200, value=90)
+upper_threshold = st.sidebar.number_input('Upper Threshold', min_value=0, max_value=200, value=110)
+volatility_bsm = st.sidebar.number_input('BSM Volatility (Annualized)', min_value=0.01, max_value=10.0, value=0.29, step=0.01)
+
+st.write("""
+This analysis estimates potential price movements of a selected stock over a specified time horizon. The estimates are based on historical volatility and the implied volatility derived fromthe Black-Scholes-Merton model. You can adjust the time horizon, number of simulations, and implied volatility measure to explore different scenarios of price dynamics.
+""")
+
+st.markdown("""
+### How to Use This App
+1. **Input Parameters**: Use the sidebar to enter the stock ticker, date range, and other parameters for the analyses.
+2. **Run the Analysis**: Click the "Run" button to perform the analyses and visualize the results.
+Each analysis is accompanied by a detailed explanation and visual representation, providing insights into the stock's price behavior and helping traders make informed decisions regarding potential price movements.
+""")
+
+# Adding LaTeX formatted formulas
+# Display the main formula for Monte Carlo simulations with clear, basic LaTeX
+st.latex(r'''
+P_t = P_0 \times e^{(\mu - \frac{1}{2} \sigma^2) \times t + \sigma \times \sqrt{t} \times Z}
+''')
+
+# Provide detailed explanations using plain text
+st.markdown("""
+**Monte Carlo Simulation Explained:**
+- **(P_t)**: Estimated stock price at time (t).
+- **(P_0)**: Current stock price.
+- **(mu)**: Mean of the log returns.
+- **(sigma)**: Standard deviation of the log returns, representing historical volatility.
+- **(t)**: Time horizon in days.
+- **(Z)**: Random variable from the standard normal distribution.
+This formula models future stock prices using a stochastic process known as the Monte Carlo simulation. It considers both the average return and the variability in returns to project future price movements. The random component (Z) introduces randomness reflecting the unpredictable nature of stock price movements.
+""")
+
+# Note on usage
+st.markdown("""
+Use this tool to simulate different scenarios by varying the number of simulations and observing the distribution of possible future prices. Adjust the time horizon and volatility to see how these factors influence the projected price range. This analysis is crucial for assessing potential investment risks and rewards.
+""")
+
+st.write(f"""
+### Monte Carlo Simulations
+These simulations project multiple potential future price paths for the stock based on the volatility models described. By running {num_simulations} simulations, the tool generates a distribution of possible future prices, allowing us to calculate confidence intervals and probabilities for various price levels.
+""")
+
+if st.sidebar.button('Run'):
+    stock_data = yf.download(ticker, start=start_date, end=end_date)
+    
+    if not stock_data.empty:
+        stock_data['Returns'] = stock_data['Close'].pct_change()
+        log_returns = np.log(stock_data['Close'] / stock_data['Close'].shift(1))
+        current_price = stock_data.iloc[-1]['Close']
+
+        def run_simulation(volatility, dt, annualized=False):
+            simulated_prices = np.zeros((days_to_forecast, num_simulations))
+            simulated_prices[0] = current_price
+
+            if annualized:
+                volatility = volatility / np.sqrt(252)
+
+            for t in range(1, days_to_forecast):
+                random_walk = np.random.normal(loc=log_returns.mean() * dt,
+                                               scale=volatility * np.sqrt(dt),
+                                               size=num_simulations)
+                simulated_prices[t] = simulated_prices[t - 1] * np.exp(random_walk)
+            return simulated_prices
+
+        simulated_prices_historical = run_simulation(log_returns.std(), 1)
+        simulated_prices_bsm = run_simulation(volatility_bsm, 1, annualized=True)
+
+        fig1 = go.Figure()
+        fig2 = go.Figure()
+
+        for simulated_prices, fig, title in zip([simulated_prices_historical, simulated_prices_bsm],
+                                                [fig1, fig2], ['Historical Volatility', 'BSM Volatility']):
+            mean_price_path = np.mean(simulated_prices, axis=1)
+            median_price_path = np.median(simulated_prices, axis=1)
+            lower_bound_68 = np.percentile(simulated_prices, 16, axis=1)
+            upper_bound_68 = np.percentile(simulated_prices, 84, axis=1)
+            lower_bound_95 = np.percentile(simulated_prices, 2.5, axis=1)
+            upper_bound_95 = np.percentile(simulated_prices, 97.5, axis=1)
+
+            for i in range(min(num_simulations, 100)):  # Plot a subset of paths for clarity
+                fig.add_trace(go.Scatter(x=np.arange(days_to_forecast), y=simulated_prices[:, i], mode='lines', line=dict(color='lightgray', width=0.5), opacity=0.3, showlegend=False))
+
+            fig.add_trace(go.Scatter(x=np.arange(days_to_forecast), y=mean_price_path, mode='lines', name='Mean Price Path', line=dict(color='black')))
+            fig.add_trace(go.Scatter(x=np.arange(days_to_forecast), y=median_price_path, mode='lines', name='Median Price Path', line=dict(color='blue')))
+            fig.add_trace(go.Scatter(x=np.arange(days_to_forecast), y=lower_bound_68, mode='lines', name='68% confidence interval (Lower)', line=dict(color='green', dash='dash')))
+            fig.add_trace(go.Scatter(x=np.arange(days_to_forecast), y=upper_bound_68, mode='lines', name='68% confidence interval (Upper)', line=dict(color='green', dash='dash')))
+            fig.add_trace(go.Scatter(x=np.arange(days_to_forecast), y=lower_bound_95, mode='lines', name='95% confidence interval (Lower)', line=dict(color='blue', dash='dash')))
+            fig.add_trace(go.Scatter(x=np.arange(days_to_forecast), y=upper_bound_95, mode='lines', name='95% confidence interval (Upper)', line=dict(color='red', dash='dash')))
+
+            fig.add_trace(go.Scatter(x=np.arange(days_to_forecast), y=[upper_threshold] * days_to_forecast, mode='lines', name='Upper Threshold', line=dict(color='purple')))
+            fig.add_trace(go.Scatter(x=np.arange(days_to_forecast), y=[lower_threshold] * days_to_forecast, mode='lines', name='Lower Threshold', line=dict(color='orange')))
+
+            above_upper_threshold_prob = (simulated_prices[-1] > upper_threshold).sum() / num_simulations
+            below_lower_threshold_prob = (simulated_prices[-1] < lower_threshold).sum() / num_simulations
+            between_thresholds_prob = 1 - above_upper_threshold_prob - below_lower_threshold_prob
+
+            fig.update_layout(
+                title=f'Monte Carlo Confidence Cone for {ticker} using {title}',
+                xaxis_title='Days',
+                yaxis_title='Stock Price',
+                legend_title='Legend'
+            )
+                                          
+                              
+            fig.add_annotation(text=f'P(>{upper_threshold:.2f}): {above_upper_threshold_prob:.2%}<br>'
+                                    f'P(<{lower_threshold:.2f}): {below_lower_threshold_prob:.2%}<br>'
+                                    f'P({lower_threshold:.2f} - {upper_threshold:.2f}): {between_thresholds_prob:.2%}',
+                               xref='paper', yref='paper', x=0.02, y=0.95, showarrow=False, bordercolor="black", borderwidth=1)
+
+            # Add elaboration text below each graph
+            st.plotly_chart(fig)
+            st.markdown(f"""
+            <h4 style='font-size: 16px;'>Interpretation of Results</h4>
+            <ul style='font-size: 14px;'>
+                <li><strong>Mean Price Path:</strong> The average simulated stock price path over the forecast period.</li>
+                <li><strong>Median Price Path:</strong> The median simulated stock price path over the forecast period.</li>
+                <li><strong>68% Confidence Interval:</strong> The range within which 68% of the simulated stock prices fall.</li>
+                <li><strong>95% Confidence Interval:</strong> The range within which 95% of the simulated stock prices fall.</li>
+                <li><strong>Probability of Exceeding Upper Threshold ({upper_threshold}):</strong> {above_upper_threshold_prob:.2%}</li>
+                <li><strong>Probability of Falling Below Lower Threshold ({lower_threshold}):</strong> {below_lower_threshold_prob:.2%}</li>
+                <li><strong>Probability of Staying Between Thresholds ({lower_threshold} - {upper_threshold}):</strong> {between_thresholds_prob:.2%}</li>
+            </ul>
+            """, unsafe_allow_html=True)
+
+    else:
+        st.write("No data found for the given ticker and date range.")
+
+
+hide_streamlit_style = """
+<style>
+#MainMenu {visibility: hidden;}
+footer {visibility: hidden;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)