Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import subprocess | |
| import os | |
| import json | |
| import numpy as np | |
| import plotly.graph_objects as go | |
| from PIL import Image | |
| import time | |
| import io | |
| import sys | |
| # Set page config with wider layout | |
| st.set_page_config( | |
| page_title="Matrix Analysis Dashboard", | |
| page_icon="📊", | |
| layout="wide", | |
| initial_sidebar_state="expanded" | |
| ) | |
| # Apply custom CSS for a dashboard-like appearance | |
| st.markdown(""" | |
| <style> | |
| .main-header { | |
| font-size: 2.5rem; | |
| color: #1E88E5; | |
| text-align: center; | |
| margin-bottom: 1rem; | |
| padding-bottom: 1rem; | |
| border-bottom: 2px solid #f0f0f0; | |
| } | |
| .dashboard-container { | |
| background-color: #f9f9f9; | |
| padding: 1.5rem; | |
| border-radius: 10px; | |
| box-shadow: 0 2px 5px rgba(0,0,0,0.1); | |
| margin-bottom: 1.5rem; | |
| } | |
| .panel-header { | |
| font-size: 1.3rem; | |
| font-weight: bold; | |
| margin-bottom: 1rem; | |
| color: #424242; | |
| border-left: 4px solid #1E88E5; | |
| padding-left: 10px; | |
| } | |
| .stTabs [data-baseweb="tab-list"] { | |
| gap: 12px; | |
| } | |
| .stTabs [data-baseweb="tab"] { | |
| height: 50px; | |
| white-space: pre-wrap; | |
| background-color: #f0f0f0; | |
| border-radius: 6px 6px 0 0; | |
| gap: 1; | |
| padding-top: 10px; | |
| padding-bottom: 10px; | |
| } | |
| .stTabs [aria-selected="true"] { | |
| background-color: #1E88E5 !important; | |
| color: white !important; | |
| } | |
| .math-box { | |
| background-color: #f8f9fa; | |
| border-left: 3px solid #1E88E5; | |
| padding: 10px; | |
| margin: 10px 0; | |
| } | |
| </style> | |
| """, unsafe_allow_html=True) | |
| # Dashboard Header | |
| st.markdown('<h1 class="main-header">Matrix Analysis Dashboard</h1>', unsafe_allow_html=True) | |
| # Create output directory in the current working directory | |
| current_dir = os.getcwd() | |
| output_dir = os.path.join(current_dir, "output") | |
| os.makedirs(output_dir, exist_ok=True) | |
| # Compile the C++ code at runtime | |
| cpp_file = os.path.join(current_dir, "app.cpp") | |
| executable = os.path.join(current_dir, "eigen_analysis") | |
| # Check if cpp file exists and compile if necessary | |
| if not os.path.exists(cpp_file): | |
| st.error(f"C++ source file not found at: {cpp_file}") | |
| st.stop() | |
| # Compile the C++ code with the right OpenCV libraries | |
| if not os.path.exists(executable) or st.sidebar.button("Recompile C++ Code"): | |
| with st.sidebar: | |
| with st.spinner("Compiling C++ code..."): | |
| compile_commands = [ | |
| f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv4` -std=c++11", | |
| f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv` -std=c++11", | |
| f"g++ -o {executable} {cpp_file} -I/usr/include/opencv4 -lopencv_core -lopencv_imgproc -std=c++11" | |
| ] | |
| compiled = False | |
| for cmd in compile_commands: | |
| compile_result = subprocess.run( | |
| cmd, | |
| shell=True, | |
| capture_output=True, | |
| text=True | |
| ) | |
| if compile_result.returncode == 0: | |
| compiled = True | |
| break | |
| if not compiled: | |
| st.error("All compilation attempts failed. Please check the system requirements.") | |
| st.stop() | |
| # Make sure the executable is executable | |
| os.chmod(executable, 0o755) | |
| st.success("C++ code compiled successfully") | |
| # Helper function for running commands with better debugging | |
| def run_command(cmd, show_output=True): | |
| cmd_str = " ".join(cmd) | |
| if show_output: | |
| st.code(f"Running command: {cmd_str}", language="bash") | |
| process = subprocess.Popen( | |
| cmd, | |
| stdout=subprocess.PIPE, | |
| stderr=subprocess.PIPE, | |
| text=True | |
| ) | |
| stdout, stderr = process.communicate() | |
| if process.returncode != 0: | |
| if show_output: | |
| st.error(f"Command failed with return code {process.returncode}") | |
| st.error(f"Command: {cmd_str}") | |
| st.error(f"Error output: {stderr}") | |
| return False, stdout, stderr | |
| return True, stdout, stderr | |
| # Create tabs for different analyses | |
| tab1, tab2 = st.tabs(["Eigenvalue Analysis", "Im(s) vs z Analysis"]) | |
| # Tab 1: Eigenvalue Analysis | |
| with tab1: | |
| # Two-column layout for the dashboard | |
| left_column, right_column = st.columns([1, 3]) | |
| with left_column: | |
| st.markdown('<div class="dashboard-container">', unsafe_allow_html=True) | |
| st.markdown('<div class="panel-header">Eigenvalue Analysis Controls</div>', unsafe_allow_html=True) | |
| # Parameter inputs with defaults and validation | |
| st.markdown("### Matrix Parameters") | |
| n = st.number_input("Sample size (n)", min_value=5, max_value=1000, value=100, step=5, | |
| help="Number of samples", key="eig_n") | |
| p = st.number_input("Dimension (p)", min_value=5, max_value=1000, value=50, step=5, | |
| help="Dimensionality", key="eig_p") | |
| a = st.number_input("Value for a", min_value=1.1, max_value=10.0, value=2.0, step=0.1, | |
| help="Parameter a > 1", key="eig_a") | |
| # Automatically calculate y = p/n (as requested) | |
| y = p/n | |
| st.info(f"Value for y = p/n: {y:.4f}") | |
| st.markdown("### Calculation Controls") | |
| fineness = st.slider( | |
| "Beta points", | |
| min_value=20, | |
| max_value=500, | |
| value=100, | |
| step=10, | |
| help="Number of points to calculate along the β axis (0 to 1)", | |
| key="eig_fineness" | |
| ) | |
| with st.expander("Advanced Settings"): | |
| # Add controls for theoretical calculation precision | |
| theory_grid_points = st.slider( | |
| "Theoretical grid points", | |
| min_value=100, | |
| max_value=1000, | |
| value=200, | |
| step=50, | |
| help="Number of points in initial grid search for theoretical calculations", | |
| key="eig_grid_points" | |
| ) | |
| theory_tolerance = st.number_input( | |
| "Theoretical tolerance", | |
| min_value=1e-12, | |
| max_value=1e-6, | |
| value=1e-10, | |
| format="%.1e", | |
| help="Convergence tolerance for golden section search", | |
| key="eig_tolerance" | |
| ) | |
| # Debug mode | |
| debug_mode = st.checkbox("Debug Mode", value=False, key="eig_debug") | |
| # Generate button | |
| eig_generate_button = st.button("Generate Eigenvalue Analysis", | |
| type="primary", | |
| use_container_width=True, | |
| key="eig_generate") | |
| st.markdown('</div>', unsafe_allow_html=True) | |
| with right_column: | |
| # Main visualization area | |
| st.markdown('<div class="dashboard-container">', unsafe_allow_html=True) | |
| st.markdown('<div class="panel-header">Eigenvalue Analysis Results</div>', unsafe_allow_html=True) | |
| # Container for the analysis results | |
| eig_results_container = st.container() | |
| # Process when generate button is clicked | |
| if eig_generate_button: | |
| with eig_results_container: | |
| # Show progress | |
| progress_container = st.container() | |
| with progress_container: | |
| progress_bar = st.progress(0) | |
| status_text = st.empty() | |
| try: | |
| # Create data file path | |
| data_file = os.path.join(output_dir, "eigenvalue_data.json") | |
| # Delete previous output if exists | |
| if os.path.exists(data_file): | |
| os.remove(data_file) | |
| # Build command for eigenvalue analysis | |
| cmd = [ | |
| executable, | |
| "eigenvalues", | |
| str(n), | |
| str(p), | |
| str(a), | |
| str(y), | |
| str(fineness), | |
| str(theory_grid_points), | |
| str(theory_tolerance), | |
| data_file | |
| ] | |
| # Run the command with our helper function | |
| status_text.text("Running eigenvalue analysis...") | |
| success, stdout, stderr = run_command(cmd, debug_mode) | |
| if not success: | |
| st.error("Eigenvalue analysis failed. Please check the debug output.") | |
| if debug_mode: | |
| st.text("Command output:") | |
| st.code(stdout) | |
| st.text("Error output:") | |
| st.code(stderr) | |
| else: | |
| progress_bar.progress(1.0) | |
| status_text.text("Analysis complete! Generating visualization...") | |
| # Check if the output file was created | |
| if not os.path.exists(data_file): | |
| st.error(f"Output file not created: {data_file}") | |
| if debug_mode: | |
| st.text("Command output:") | |
| st.code(stdout) | |
| st.stop() | |
| # Load the results from the JSON file | |
| with open(data_file, 'r') as f: | |
| data = json.load(f) | |
| # Extract data | |
| beta_values = np.array(data['beta_values']) | |
| max_eigenvalues = np.array(data['max_eigenvalues']) | |
| min_eigenvalues = np.array(data['min_eigenvalues']) | |
| theoretical_max = np.array(data['theoretical_max']) | |
| theoretical_min = np.array(data['theoretical_min']) | |
| # Create an interactive plot using Plotly | |
| fig = go.Figure() | |
| # Add traces for each line | |
| fig.add_trace(go.Scatter( | |
| x=beta_values, | |
| y=max_eigenvalues, | |
| mode='lines+markers', | |
| name='Empirical Max Eigenvalue', | |
| line=dict(color='rgb(220, 60, 60)', width=3), | |
| marker=dict( | |
| symbol='circle', | |
| size=8, | |
| color='rgb(220, 60, 60)', | |
| line=dict(color='white', width=1) | |
| ), | |
| hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Empirical Max</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=beta_values, | |
| y=min_eigenvalues, | |
| mode='lines+markers', | |
| name='Empirical Min Eigenvalue', | |
| line=dict(color='rgb(60, 60, 220)', width=3), | |
| marker=dict( | |
| symbol='circle', | |
| size=8, | |
| color='rgb(60, 60, 220)', | |
| line=dict(color='white', width=1) | |
| ), | |
| hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Empirical Min</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=beta_values, | |
| y=theoretical_max, | |
| mode='lines+markers', | |
| name='Theoretical Max Function', | |
| line=dict(color='rgb(30, 180, 30)', width=3), | |
| marker=dict( | |
| symbol='diamond', | |
| size=8, | |
| color='rgb(30, 180, 30)', | |
| line=dict(color='white', width=1) | |
| ), | |
| hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Theoretical Max</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=beta_values, | |
| y=theoretical_min, | |
| mode='lines+markers', | |
| name='Theoretical Min Function', | |
| line=dict(color='rgb(180, 30, 180)', width=3), | |
| marker=dict( | |
| symbol='diamond', | |
| size=8, | |
| color='rgb(180, 30, 180)', | |
| line=dict(color='white', width=1) | |
| ), | |
| hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Theoretical Min</extra>' | |
| )) | |
| # Configure layout for better appearance | |
| fig.update_layout( | |
| title={ | |
| 'text': f'Eigenvalue Analysis: n={n}, p={p}, a={a}, y={y:.4f}', | |
| 'font': {'size': 24, 'color': '#1E88E5'}, | |
| 'y': 0.95, | |
| 'x': 0.5, | |
| 'xanchor': 'center', | |
| 'yanchor': 'top' | |
| }, | |
| xaxis={ | |
| 'title': 'β Parameter', | |
| 'titlefont': {'size': 18, 'color': '#424242'}, | |
| 'tickfont': {'size': 14}, | |
| 'gridcolor': 'rgba(220, 220, 220, 0.5)', | |
| 'showgrid': True | |
| }, | |
| yaxis={ | |
| 'title': 'Eigenvalues', | |
| 'titlefont': {'size': 18, 'color': '#424242'}, | |
| 'tickfont': {'size': 14}, | |
| 'gridcolor': 'rgba(220, 220, 220, 0.5)', | |
| 'showgrid': True | |
| }, | |
| plot_bgcolor='rgba(240, 240, 240, 0.8)', | |
| paper_bgcolor='rgba(249, 249, 249, 0.8)', | |
| hovermode='closest', | |
| legend={ | |
| 'font': {'size': 14}, | |
| 'bgcolor': 'rgba(255, 255, 255, 0.9)', | |
| 'bordercolor': 'rgba(200, 200, 200, 0.5)', | |
| 'borderwidth': 1 | |
| }, | |
| margin={'l': 60, 'r': 30, 't': 100, 'b': 60}, | |
| height=600, | |
| annotations=[ | |
| { | |
| 'text': f"Max Function: max{{k ∈ (0,∞)}} [yβ(a-1)k + (ak+1)((y-1)k-1)]/[(ak+1)(k²+k)]", | |
| 'xref': 'paper', 'yref': 'paper', | |
| 'x': 0.02, 'y': 0.02, | |
| 'showarrow': False, | |
| 'font': {'size': 12, 'color': 'rgb(30, 180, 30)'}, | |
| 'bgcolor': 'rgba(255, 255, 255, 0.9)', | |
| 'bordercolor': 'rgb(30, 180, 30)', | |
| 'borderwidth': 1, | |
| 'borderpad': 4 | |
| }, | |
| { | |
| 'text': f"Min Function: min{{t ∈ (-1/a,0)}} [yβ(a-1)t + (at+1)((y-1)t-1)]/[(at+1)(t²+t)]", | |
| 'xref': 'paper', 'yref': 'paper', | |
| 'x': 0.55, 'y': 0.02, | |
| 'showarrow': False, | |
| 'font': {'size': 12, 'color': 'rgb(180, 30, 180)'}, | |
| 'bgcolor': 'rgba(255, 255, 255, 0.9)', | |
| 'bordercolor': 'rgb(180, 30, 180)', | |
| 'borderwidth': 1, | |
| 'borderpad': 4 | |
| } | |
| ] | |
| ) | |
| # Add custom modebar buttons | |
| fig.update_layout( | |
| modebar_add=[ | |
| 'drawline', 'drawopenpath', 'drawclosedpath', | |
| 'drawcircle', 'drawrect', 'eraseshape' | |
| ], | |
| modebar_remove=['lasso2d', 'select2d'], | |
| dragmode='zoom' | |
| ) | |
| # Clear progress container | |
| progress_container.empty() | |
| # Display the interactive plot in Streamlit | |
| st.plotly_chart(fig, use_container_width=True) | |
| except Exception as e: | |
| st.error(f"An error occurred: {str(e)}") | |
| if debug_mode: | |
| st.exception(e) | |
| else: | |
| # Try to load existing data if available | |
| data_file = os.path.join(output_dir, "eigenvalue_data.json") | |
| if os.path.exists(data_file): | |
| try: | |
| with open(data_file, 'r') as f: | |
| data = json.load(f) | |
| # Extract data | |
| beta_values = np.array(data['beta_values']) | |
| max_eigenvalues = np.array(data['max_eigenvalues']) | |
| min_eigenvalues = np.array(data['min_eigenvalues']) | |
| theoretical_max = np.array(data['theoretical_max']) | |
| theoretical_min = np.array(data['theoretical_min']) | |
| # Create an interactive plot using Plotly | |
| fig = go.Figure() | |
| # Add traces for each line | |
| fig.add_trace(go.Scatter( | |
| x=beta_values, | |
| y=max_eigenvalues, | |
| mode='lines+markers', | |
| name='Empirical Max Eigenvalue', | |
| line=dict(color='rgb(220, 60, 60)', width=3), | |
| marker=dict( | |
| symbol='circle', | |
| size=8, | |
| color='rgb(220, 60, 60)', | |
| line=dict(color='white', width=1) | |
| ), | |
| hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Empirical Max</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=beta_values, | |
| y=min_eigenvalues, | |
| mode='lines+markers', | |
| name='Empirical Min Eigenvalue', | |
| line=dict(color='rgb(60, 60, 220)', width=3), | |
| marker=dict( | |
| symbol='circle', | |
| size=8, | |
| color='rgb(60, 60, 220)', | |
| line=dict(color='white', width=1) | |
| ), | |
| hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Empirical Min</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=beta_values, | |
| y=theoretical_max, | |
| mode='lines+markers', | |
| name='Theoretical Max Function', | |
| line=dict(color='rgb(30, 180, 30)', width=3), | |
| marker=dict( | |
| symbol='diamond', | |
| size=8, | |
| color='rgb(30, 180, 30)', | |
| line=dict(color='white', width=1) | |
| ), | |
| hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Theoretical Max</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=beta_values, | |
| y=theoretical_min, | |
| mode='lines+markers', | |
| name='Theoretical Min Function', | |
| line=dict(color='rgb(180, 30, 180)', width=3), | |
| marker=dict( | |
| symbol='diamond', | |
| size=8, | |
| color='rgb(180, 30, 180)', | |
| line=dict(color='white', width=1) | |
| ), | |
| hovertemplate='β: %{x:.3f}<br>Value: %{y:.6f}<extra>Theoretical Min</extra>' | |
| )) | |
| # Configure layout for better appearance | |
| fig.update_layout( | |
| title={ | |
| 'text': f'Eigenvalue Analysis (Previous Result)', | |
| 'font': {'size': 24, 'color': '#1E88E5'}, | |
| 'y': 0.95, | |
| 'x': 0.5, | |
| 'xanchor': 'center', | |
| 'yanchor': 'top' | |
| }, | |
| xaxis={ | |
| 'title': 'β Parameter', | |
| 'titlefont': {'size': 18, 'color': '#424242'}, | |
| 'tickfont': {'size': 14}, | |
| 'gridcolor': 'rgba(220, 220, 220, 0.5)', | |
| 'showgrid': True | |
| }, | |
| yaxis={ | |
| 'title': 'Eigenvalues', | |
| 'titlefont': {'size': 18, 'color': '#424242'}, | |
| 'tickfont': {'size': 14}, | |
| 'gridcolor': 'rgba(220, 220, 220, 0.5)', | |
| 'showgrid': True | |
| }, | |
| plot_bgcolor='rgba(240, 240, 240, 0.8)', | |
| paper_bgcolor='rgba(249, 249, 249, 0.8)', | |
| hovermode='closest', | |
| legend={ | |
| 'font': {'size': 14}, | |
| 'bgcolor': 'rgba(255, 255, 255, 0.9)', | |
| 'bordercolor': 'rgba(200, 200, 200, 0.5)', | |
| 'borderwidth': 1 | |
| }, | |
| margin={'l': 60, 'r': 30, 't': 100, 'b': 60}, | |
| height=600 | |
| ) | |
| # Display the interactive plot in Streamlit | |
| st.plotly_chart(fig, use_container_width=True) | |
| st.info("This is the previous analysis result. Adjust parameters and click 'Generate Analysis' to create a new visualization.") | |
| except Exception as e: | |
| st.info("👈 Set parameters and click 'Generate Eigenvalue Analysis' to create a visualization.") | |
| else: | |
| # Show placeholder | |
| st.info("👈 Set parameters and click 'Generate Eigenvalue Analysis' to create a visualization.") | |
| st.markdown('</div>', unsafe_allow_html=True) | |
| # Tab 2: Im(s) vs z Analysis | |
| with tab2: | |
| # Two-column layout for the dashboard | |
| left_column, right_column = st.columns([1, 3]) | |
| with left_column: | |
| st.markdown('<div class="dashboard-container">', unsafe_allow_html=True) | |
| st.markdown('<div class="panel-header">Im(s) vs z Analysis Controls</div>', unsafe_allow_html=True) | |
| # Parameter inputs with defaults and validation | |
| st.markdown("### Cubic Equation Parameters") | |
| cubic_a = st.number_input("Value for a", min_value=1.1, max_value=10.0, value=2.0, step=0.1, | |
| help="Parameter a > 1", key="cubic_a") | |
| cubic_y = st.number_input("Value for y", min_value=0.1, max_value=10.0, value=1.0, step=0.1, | |
| help="Parameter y > 0", key="cubic_y") | |
| cubic_beta = st.number_input("Value for β", min_value=0.0, max_value=1.0, value=0.5, step=0.05, | |
| help="Value between 0 and 1", key="cubic_beta") | |
| st.markdown("### Calculation Controls") | |
| cubic_points = st.slider( | |
| "Number of z points", | |
| min_value=50, | |
| max_value=1000, | |
| value=300, | |
| step=50, | |
| help="Number of points to calculate along the z axis", | |
| key="cubic_points" | |
| ) | |
| # Debug mode | |
| cubic_debug_mode = st.checkbox("Debug Mode", value=False, key="cubic_debug") | |
| # Show cubic equation | |
| st.markdown('<div class="math-box">', unsafe_allow_html=True) | |
| st.markdown("### Cubic Equation") | |
| st.latex(r"zas^3 + [z(a+1)+a(1-y)]\,s^2 + [z+(a+1)-y-y\beta (a-1)]\,s + 1 = 0") | |
| st.markdown('</div>', unsafe_allow_html=True) | |
| # Generate button | |
| cubic_generate_button = st.button("Generate Im(s) vs z Analysis", | |
| type="primary", | |
| use_container_width=True, | |
| key="cubic_generate") | |
| st.markdown('</div>', unsafe_allow_html=True) | |
| with right_column: | |
| # Main visualization area | |
| st.markdown('<div class="dashboard-container">', unsafe_allow_html=True) | |
| st.markdown('<div class="panel-header">Im(s) vs z Analysis Results</div>', unsafe_allow_html=True) | |
| # Container for the analysis results | |
| cubic_results_container = st.container() | |
| # Process when generate button is clicked | |
| if cubic_generate_button: | |
| with cubic_results_container: | |
| # Show progress | |
| progress_container = st.container() | |
| with progress_container: | |
| status_text = st.empty() | |
| status_text.text("Starting cubic equation calculations...") | |
| try: | |
| # Run the C++ executable with the parameters in JSON output mode | |
| data_file = os.path.join(output_dir, "cubic_data.json") | |
| # Delete previous output if exists | |
| if os.path.exists(data_file): | |
| os.remove(data_file) | |
| # Build command for cubic equation analysis | |
| cmd = [ | |
| executable, | |
| "cubic", | |
| str(cubic_a), | |
| str(cubic_y), | |
| str(cubic_beta), | |
| str(cubic_points), | |
| data_file | |
| ] | |
| # Run the command with our helper function | |
| status_text.text("Calculating Im(s) vs z values...") | |
| success, stdout, stderr = run_command(cmd, cubic_debug_mode) | |
| if not success: | |
| st.error("Cubic equation analysis failed. Please check the debug output.") | |
| if cubic_debug_mode: | |
| st.text("Command output:") | |
| st.code(stdout) | |
| st.text("Error output:") | |
| st.code(stderr) | |
| else: | |
| status_text.text("Calculations complete! Generating visualization...") | |
| # Check if the output file was created | |
| if not os.path.exists(data_file): | |
| st.error(f"Output file not created: {data_file}") | |
| if cubic_debug_mode: | |
| st.text("Command output:") | |
| st.code(stdout) | |
| st.stop() | |
| # Load the results from the JSON file | |
| with open(data_file, 'r') as f: | |
| data = json.load(f) | |
| # Extract data | |
| z_values = np.array(data['z_values']) | |
| ims_values1 = np.array(data['ims_values1']) | |
| ims_values2 = np.array(data['ims_values2']) | |
| ims_values3 = np.array(data['ims_values3']) | |
| # Create an interactive plot using Plotly | |
| fig = go.Figure() | |
| # Add traces for each root's imaginary part | |
| fig.add_trace(go.Scatter( | |
| x=z_values, | |
| y=ims_values1, | |
| mode='lines', | |
| name='Im(s₁)', | |
| line=dict(color='rgb(220, 60, 60)', width=3), | |
| hovertemplate='z: %{x:.3f}<br>Im(s₁): %{y:.6f}<extra>Root 1</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=z_values, | |
| y=ims_values2, | |
| mode='lines', | |
| name='Im(s₂)', | |
| line=dict(color='rgb(60, 60, 220)', width=3), | |
| hovertemplate='z: %{x:.3f}<br>Im(s₂): %{y:.6f}<extra>Root 2</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=z_values, | |
| y=ims_values3, | |
| mode='lines', | |
| name='Im(s₃)', | |
| line=dict(color='rgb(30, 180, 30)', width=3), | |
| hovertemplate='z: %{x:.3f}<br>Im(s₃): %{y:.6f}<extra>Root 3</extra>' | |
| )) | |
| # Configure layout for better appearance | |
| fig.update_layout( | |
| title={ | |
| 'text': f'Im(s) vs z Analysis: a={cubic_a}, y={cubic_y}, β={cubic_beta}', | |
| 'font': {'size': 24, 'color': '#1E88E5'}, | |
| 'y': 0.95, | |
| 'x': 0.5, | |
| 'xanchor': 'center', | |
| 'yanchor': 'top' | |
| }, | |
| xaxis={ | |
| 'title': 'z (logarithmic scale)', | |
| 'titlefont': {'size': 18, 'color': '#424242'}, | |
| 'tickfont': {'size': 14}, | |
| 'gridcolor': 'rgba(220, 220, 220, 0.5)', | |
| 'showgrid': True, | |
| 'type': 'log' # Use logarithmic scale for better visualization | |
| }, | |
| yaxis={ | |
| 'title': 'Im(s)', | |
| 'titlefont': {'size': 18, 'color': '#424242'}, | |
| 'tickfont': {'size': 14}, | |
| 'gridcolor': 'rgba(220, 220, 220, 0.5)', | |
| 'showgrid': True | |
| }, | |
| plot_bgcolor='rgba(240, 240, 240, 0.8)', | |
| paper_bgcolor='rgba(249, 249, 249, 0.8)', | |
| hovermode='closest', | |
| legend={ | |
| 'font': {'size': 14}, | |
| 'bgcolor': 'rgba(255, 255, 255, 0.9)', | |
| 'bordercolor': 'rgba(200, 200, 200, 0.5)', | |
| 'borderwidth': 1 | |
| }, | |
| margin={'l': 60, 'r': 30, 't': 100, 'b': 60}, | |
| height=600, | |
| annotations=[ | |
| { | |
| 'text': f"Cubic Equation: {cubic_a}zs³ + [{cubic_a+1}z+{cubic_a}(1-{cubic_y})]s² + [z+{cubic_a+1}-{cubic_y}-{cubic_y*cubic_beta}({cubic_a-1})]s + 1 = 0", | |
| 'xref': 'paper', 'yref': 'paper', | |
| 'x': 0.5, 'y': 0.02, | |
| 'showarrow': False, | |
| 'font': {'size': 12, 'color': 'black'}, | |
| 'bgcolor': 'rgba(255, 255, 255, 0.9)', | |
| 'bordercolor': 'rgba(0, 0, 0, 0.5)', | |
| 'borderwidth': 1, | |
| 'borderpad': 4, | |
| 'align': 'center' | |
| } | |
| ] | |
| ) | |
| # Add custom modebar buttons | |
| fig.update_layout( | |
| modebar_add=[ | |
| 'drawline', 'drawopenpath', 'drawclosedpath', | |
| 'drawcircle', 'drawrect', 'eraseshape' | |
| ], | |
| modebar_remove=['lasso2d', 'select2d'], | |
| dragmode='zoom' | |
| ) | |
| # Clear progress container | |
| progress_container.empty() | |
| # Display the interactive plot in Streamlit | |
| st.plotly_chart(fig, use_container_width=True) | |
| # Add explanation text | |
| st.markdown(""" | |
| ### Explanation of the Analysis | |
| This plot shows the imaginary parts of the three roots (s₁, s₂, s₃) of the cubic equation as a function of z. | |
| The cubic equation being solved is: | |
| ``` | |
| zas³ + [z(a+1)+a(1-y)]s² + [z+(a+1)-y-yβ(a-1)]s + 1 = 0 | |
| ``` | |
| Where a, y, and β are parameters you can adjust in the control panel. The imaginary parts of the roots represent | |
| oscillatory behavior in the system. | |
| - When Im(s) = 0, the root is purely real | |
| - When Im(s) ≠ 0, the root has an oscillatory component | |
| """) | |
| except Exception as e: | |
| st.error(f"An error occurred: {str(e)}") | |
| if cubic_debug_mode: | |
| st.exception(e) | |
| else: | |
| # Try to load existing data if available | |
| data_file = os.path.join(output_dir, "cubic_data.json") | |
| if os.path.exists(data_file): | |
| try: | |
| with open(data_file, 'r') as f: | |
| data = json.load(f) | |
| # Extract data | |
| z_values = np.array(data['z_values']) | |
| ims_values1 = np.array(data['ims_values1']) | |
| ims_values2 = np.array(data['ims_values2']) | |
| ims_values3 = np.array(data['ims_values3']) | |
| # Create an interactive plot using Plotly | |
| fig = go.Figure() | |
| # Add traces for each root's imaginary part | |
| fig.add_trace(go.Scatter( | |
| x=z_values, | |
| y=ims_values1, | |
| mode='lines', | |
| name='Im(s₁)', | |
| line=dict(color='rgb(220, 60, 60)', width=3), | |
| hovertemplate='z: %{x:.3f}<br>Im(s₁): %{y:.6f}<extra>Root 1</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=z_values, | |
| y=ims_values2, | |
| mode='lines', | |
| name='Im(s₂)', | |
| line=dict(color='rgb(60, 60, 220)', width=3), | |
| hovertemplate='z: %{x:.3f}<br>Im(s₂): %{y:.6f}<extra>Root 2</extra>' | |
| )) | |
| fig.add_trace(go.Scatter( | |
| x=z_values, | |
| y=ims_values3, | |
| mode='lines', | |
| name='Im(s₃)', | |
| line=dict(color='rgb(30, 180, 30)', width=3), | |
| hovertemplate='z: %{x:.3f}<br>Im(s₃): %{y:.6f}<extra>Root 3</extra>' | |
| )) | |
| # Configure layout for better appearance | |
| fig.update_layout( | |
| title={ | |
| 'text': f'Im(s) vs z Analysis (Previous Result)', | |
| 'font': {'size': 24, 'color': '#1E88E5'}, | |
| 'y': 0.95, | |
| 'x': 0.5, | |
| 'xanchor': 'center', | |
| 'yanchor': 'top' | |
| }, | |
| xaxis={ | |
| 'title': 'z (logarithmic scale)', | |
| 'titlefont': {'size': 18, 'color': '#424242'}, | |
| 'tickfont': {'size': 14}, | |
| 'gridcolor': 'rgba(220, 220, 220, 0.5)', | |
| 'showgrid': True, | |
| 'type': 'log' # Use logarithmic scale for better visualization | |
| }, | |
| yaxis={ | |
| 'title': 'Im(s)', | |
| 'titlefont': {'size': 18, 'color': '#424242'}, | |
| 'tickfont': {'size': 14}, | |
| 'gridcolor': 'rgba(220, 220, 220, 0.5)', | |
| 'showgrid': True | |
| }, | |
| plot_bgcolor='rgba(240, 240, 240, 0.8)', | |
| paper_bgcolor='rgba(249, 249, 249, 0.8)', | |
| hovermode='closest', | |
| legend={ | |
| 'font': {'size': 14}, | |
| 'bgcolor': 'rgba(255, 255, 255, 0.9)', | |
| 'bordercolor': 'rgba(200, 200, 200, 0.5)', | |
| 'borderwidth': 1 | |
| }, | |
| margin={'l': 60, 'r': 30, 't': 100, 'b': 60}, | |
| height=600 | |
| ) | |
| # Display the interactive plot in Streamlit | |
| st.plotly_chart(fig, use_container_width=True) | |
| st.info("This is the previous analysis result. Adjust parameters and click 'Generate Analysis' to create a new visualization.") | |
| except Exception as e: | |
| st.info("👈 Set parameters and click 'Generate Im(s) vs z Analysis' to create a visualization.") | |
| else: | |
| # Show placeholder | |
| st.info("👈 Set parameters and click 'Generate Im(s) vs z Analysis' to create a visualization.") | |
| st.markdown('</div>', unsafe_allow_html=True) | |
| # Add footer with information | |
| with st.expander("About this Application"): | |
| st.markdown(""" | |
| ## Matrix Analysis Dashboard | |
| This application provides tools for analyzing matrix properties and related cubic equations: | |
| ### Tab 1: Eigenvalue Analysis | |
| Visualizes the relationship between empirical and theoretical eigenvalues of matrices as a function of β. | |
| ### Tab 2: Im(s) vs z Analysis | |
| Explores the imaginary parts of the roots of the cubic equation: | |
| ``` | |
| zas³ + [z(a+1)+a(1-y)]s² + [z+(a+1)-y-yβ(a-1)]s + 1 = 0 | |
| ``` | |
| The application uses C++ for high-performance numerical calculations and Python with Streamlit and Plotly for the interactive user interface and visualizations. | |
| """) |