Update app.py

app.py

@@ -4,14 +4,13 @@ import os
 import json
 import numpy as np
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 from PIL import Image
 import time
 import io
 
 # Set page config with wider layout
 st.set_page_config(
-    page_title="Eigenvalue Analysis Dashboard",
+    page_title="Matrix Analysis Dashboard",
     page_icon="📊",
     layout="wide",
     initial_sidebar_state="expanded"
@@ -43,28 +42,27 @@ st.markdown("""
         border-left: 4px solid #1E88E5;
         padding-left: 10px;
     }
-    .stats-card {
-        background-color: white;
-        padding: 1rem;
-        border-radius: 8px;
-        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
-        text-align: center;
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 12px;
     }
-    .stats-value {
-        font-size: 1.8rem;
-        font-weight: bold;
-        color: #1E88E5;
+    .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;
     }
-    .stats-label {
-        font-size: 0.9rem;
-        color: #616161;
-        margin-top: 0.3rem;
+    .stTabs [aria-selected="true"] {
+        background-color: #1E88E5 !important;
+        color: white !important;
     }
 </style>
 """, unsafe_allow_html=True)
 
 # Dashboard Header
-st.markdown('<h1 class="main-header">Eigenvalue Analysis Dashboard</h1>', unsafe_allow_html=True)
+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()
@@ -75,20 +73,14 @@ os.makedirs(output_dir, exist_ok=True)
 cpp_file = os.path.join(current_dir, "app.cpp")
 executable = os.path.join(current_dir, "eigen_analysis")
 
-# Two-column layout for the dashboard
-left_column, right_column = st.columns([1, 3])
+# 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()
 
-with left_column:
-    st.markdown('<div class="dashboard-container">', unsafe_allow_html=True)
-    st.markdown('<div class="panel-header">Control Panel</div>', unsafe_allow_html=True)
-    
-    # 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.button("Recompile C++ Code"):
+# 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",
@@ -116,160 +108,307 @@ with left_column:
             # Make sure the executable is executable
             os.chmod(executable, 0o755)
             st.success("C++ code compiled successfully")
+
+# 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])
     
-    # 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")
-    p = st.number_input("Dimension (p)", min_value=5, max_value=1000, value=50, step=5, help="Dimensionality")
-    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")
-    
-    # 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)"
-    )
-    
-    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"
-        )
-        
-        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"
-        )
-    
-    # Generate button
-    generate_button = st.button("Generate Analysis", type="primary", use_container_width=True)
-    st.markdown('</div>', unsafe_allow_html=True)
-    
-    # About section
-    with st.expander("About Eigenvalue Analysis"):
-        st.markdown("""
-        ## Theory
-        
-        This application visualizes the relationship between empirical and theoretical eigenvalues for matrices with specific properties.
-        
-        The analysis examines:
+    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)
         
-        - **Empirical Max/Min Eigenvalues**: The maximum and minimum eigenvalues calculated from the generated matrices
-        - **Theoretical Max/Min Functions**: The theoretical bounds derived from mathematical analysis
+        # 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")
         
-        ### Key Parameters
+        # Automatically calculate y = p/n (as requested)
+        y = p/n
+        st.info(f"Value for y = p/n: {y:.4f}")
         
-        - **n**: Sample size
-        - **p**: Dimension
-        - **a**: Value > 1 that affects the distribution of eigenvalues
-        - **y**: Value calculated as p/n that affects scaling
-        
-        ### Calculation Controls
+        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"
+        )
         
-        - **Beta points**: Number of points calculated along the β range (0 to 1)
-        - **Theoretical grid points**: Number of points in initial grid search for finding theoretical max/min
-        - **Theoretical tolerance**: Convergence tolerance for golden section search algorithm
+        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"
+            )
         
-        ### Mathematical Formulas
+        # 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)
         
-        Max Function: 
-        max{k ∈ (0,∞)} [yβ(a-1)k + (ak+1)((y-1)k-1)]/[(ak+1)(k²+k)]
+        # Container for the analysis results
+        eig_results_container = st.container()
         
-        Min Function: 
-        min{t ∈ (-1/a,0)} [yβ(a-1)t + (at+1)((y-1)t-1)]/[(at+1)(t²+t)]
-        """)
-
-with right_column:
-    # Main visualization area
-    st.markdown('<div class="dashboard-container">', unsafe_allow_html=True)
-    st.markdown('<div class="panel-header">Eigenvalue Analysis Visualization</div>', unsafe_allow_html=True)
-    
-    # Container for the analysis results
-    results_container = st.container()
-    
-    # Process when generate button is clicked
-    if generate_button:
-        with results_container:
-            # Show progress
-            progress_container = st.container()
-            with progress_container:
-                progress_bar = st.progress(0)
-                status_text = st.empty()
-            
-            try:
-                # Run the C++ executable with the parameters in JSON output mode
-                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)
+        # 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()
                 
-                # Execute the C++ program
-                cmd = [
-                    executable, 
-                    str(n), 
-                    str(p), 
-                    str(a), 
-                    str(y), 
-                    str(fineness), 
-                    str(theory_grid_points),
-                    str(theory_tolerance),
-                    data_file
-                ]
-                
-                process = subprocess.Popen(
-                    cmd, 
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    text=True
-                )
-                
-                # Show output in a status area
-                status_text.text("Starting calculations...")
-                
-                last_progress = 0
-                while process.poll() is None:
-                    output = process.stdout.readline()
-                    if output:
-                        if output.startswith("PROGRESS:"):
-                            try:
-                                # Update progress bar
-                                progress_value = float(output.split(":")[1].strip())
-                                progress_bar.progress(progress_value)
-                                last_progress = progress_value
-                                status_text.text(f"Calculating... {int(progress_value * 100)}% complete")
-                            except:
-                                pass
-                        else:
-                            status_text.text(output.strip())
-                    time.sleep(0.1)
-                
-                return_code = process.poll()
-                
-                if return_code != 0:
-                    error = process.stderr.read()
-                    st.error(f"Error executing the analysis: {error}")
-                else:
-                    progress_bar.progress(1.0)
-                    status_text.text("Calculations complete! Generating visualization...")
+                try:
+                    # Run the C++ executable with the parameters in JSON output mode
+                    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)
                     
-                    # Load the results from the JSON file
+                    # Execute the C++ program
+                    cmd = [
+                        executable,
+                        "eigenvalues",
+                        str(n), 
+                        str(p), 
+                        str(a), 
+                        str(y), 
+                        str(fineness), 
+                        str(theory_grid_points),
+                        str(theory_tolerance),
+                        data_file
+                    ]
+                    
+                    process = subprocess.Popen(
+                        cmd, 
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True
+                    )
+                    
+                    # Show output in a status area
+                    status_text.text("Starting calculations...")
+                    
+                    last_progress = 0
+                    while process.poll() is None:
+                        output = process.stdout.readline()
+                        if output:
+                            if output.startswith("PROGRESS:"):
+                                try:
+                                    # Update progress bar
+                                    progress_value = float(output.split(":")[1].strip())
+                                    progress_bar.progress(progress_value)
+                                    last_progress = progress_value
+                                    status_text.text(f"Calculating... {int(progress_value * 100)}% complete")
+                                except:
+                                    pass
+                            else:
+                                status_text.text(output.strip())
+                        time.sleep(0.1)
+                    
+                    return_code = process.poll()
+                    
+                    if return_code != 0:
+                        error = process.stderr.read()
+                        st.error(f"Error executing the analysis: {error}")
+                    else:
+                        progress_bar.progress(1.0)
+                        status_text.text("Calculations complete! Generating visualization...")
+                        
+                        # 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)}")
+        
+        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)
                     
@@ -347,7 +486,7 @@ with right_column:
                     # Configure layout for better appearance
                     fig.update_layout(
                         title={
-                            'text': f'Eigenvalue Analysis: n={n}, p={p}, a={a}, y={y:.4f}',
+                            'text': f'Eigenvalue Analysis (Previous Result)',
                             'font': {'size': 24, 'color': '#1E88E5'},
                             'y': 0.95,
                             'x': 0.5,
@@ -378,256 +517,342 @@ with right_column:
                             '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
-                            }
-                        ]
+                        height=600
                     )
                     
-                    # 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)
+                    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 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"
+        )
+        
+        cubic_range = st.slider(
+            "z range", 
+            min_value=0.1, 
+            max_value=20.0, 
+            value=(0.01, 10.0), 
+            step=0.1,
+            help="Range of z values to calculate",
+            key="cubic_range"
+        )
+        
+        # Show cubic equation
+        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")
+        
+        # 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")
                     
-                    # Generate static image for download
-                    output_file = os.path.join(output_dir, "eigenvalue_analysis.png")
-                    fig.write_image(output_file, scale=2)
+                    # Delete previous output if exists
+                    if os.path.exists(data_file):
+                        os.remove(data_file)
                     
-                    # Provide download button
-                    col1, col2, col3 = st.columns([1, 2, 1])
-                    with col2:
-                        with open(output_file, "rb") as file:
-                            btn = st.download_button(
-                                label="Download Plot",
-                                data=file,
-                                file_name=f"eigenvalue_analysis_n{n}_p{p}_a{a}_y{y:.4f}.png",
-                                mime="image/png",
-                                use_container_width=True
-                            )
+                    # Execute the C++ program
+                    cmd = [
+                        executable,
+                        "cubic",
+                        str(cubic_a), 
+                        str(cubic_y), 
+                        str(cubic_beta), 
+                        str(cubic_points),
+                        data_file
+                    ]
                     
-                    # Add statistics section with cards
-                    st.markdown("### Results Summary")
+                    status_text.text("Calculating Im(s) vs z values...")
                     
-                    # Calculate key statistics
-                    emp_max = max(max_eigenvalues)
-                    emp_min = min(min_eigenvalues)
-                    theo_max = max(theoretical_max)
-                    theo_min = min(theoretical_min)
-                    max_diff = abs(emp_max - theo_max)
-                    min_diff = abs(emp_min - theo_min)
+                    process = subprocess.run(
+                        cmd, 
+                        capture_output=True,
+                        text=True
+                    )
                     
-                    # Display statistics in a card layout
-                    col1, col2, col3, col4 = st.columns(4)
+                    if process.returncode != 0:
+                        st.error(f"Error executing the analysis: {process.stderr}")
+                    else:
+                        status_text.text("Calculations complete! Generating visualization...")
+                        
+                        # 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',
+                                '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
+                                'title': 'z (logarithmic scale)'
+                            },
+                            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)}")
+        
+        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)
                     
-                    with col1:
-                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
-                        st.markdown(f'<div class="stats-value">{emp_max:.4f}</div>', unsafe_allow_html=True)
-                        st.markdown('<div class="stats-label">Empirical Maximum</div>', unsafe_allow_html=True)
-                        st.markdown('</div>', unsafe_allow_html=True)
+                    # 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'])
                     
-                    with col2:
-                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
-                        st.markdown(f'<div class="stats-value">{emp_min:.4f}</div>', unsafe_allow_html=True)
-                        st.markdown('<div class="stats-label">Empirical Minimum</div>', unsafe_allow_html=True)
-                        st.markdown('</div>', unsafe_allow_html=True)
+                    # Create an interactive plot using Plotly
+                    fig = go.Figure()
                     
-                    with col3:
-                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
-                        st.markdown(f'<div class="stats-value">{theo_max:.4f}</div>', unsafe_allow_html=True)
-                        st.markdown('<div class="stats-label">Theoretical Maximum</div>', unsafe_allow_html=True)
-                        st.markdown('</div>', unsafe_allow_html=True)
+                    # 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>'
+                    ))
                     
-                    with col4:
-                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
-                        st.markdown(f'<div class="stats-value">{theo_min:.4f}</div>', unsafe_allow_html=True)
-                        st.markdown('<div class="stats-label">Theoretical Minimum</div>', unsafe_allow_html=True)
-                        st.markdown('</div>', unsafe_allow_html=True)
+                    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>'
+                    ))
                     
-                    st.markdown("<br>", unsafe_allow_html=True)
+                    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>'
+                    ))
                     
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
-                        st.markdown(f'<div class="stats-value">{max_diff:.4f}</div>', unsafe_allow_html=True)
-                        st.markdown('<div class="stats-label">Max Difference</div>', unsafe_allow_html=True)
-                        st.markdown('</div>', unsafe_allow_html=True)
+                    # 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
+                    )
                     
-                    with col2:
-                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
-                        st.markdown(f'<div class="stats-value">{min_diff:.4f}</div>', unsafe_allow_html=True)
-                        st.markdown('<div class="stats-label">Min Difference</div>', unsafe_allow_html=True)
-                        st.markdown('</div>', unsafe_allow_html=True)
+                    # 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.")
                     
-                    # Add calculation settings
-                    with st.expander("Calculation Details"):
-                        st.markdown(f"""
-                        - **Matrix Dimensions**: {n} × {p}
-                        - **Parameter a**: {a}
-                        - **Parameter y (p/n)**: {y:.4f}
-                        - **Beta points**: {fineness}
-                        - **Theoretical grid points**: {theory_grid_points}
-                        - **Theoretical tolerance**: {theory_tolerance:.1e}
-                        """)
-            
-            except Exception as e:
-                st.error(f"An error occurred: {str(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 Analysis' to create a visualization.")
-        else:
-            # Show placeholder
-            st.info("👈 Set parameters and click 'Generate Analysis' to create a visualization.")
-    
-    st.markdown('</div>', unsafe_allow_html=True)
+                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)