Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,802 @@
-import altair as alt
+import streamlit as st
 import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
 import pandas as pd
-import streamlit as st
+from math import sin, cos, tan, asin, acos, atan2, sqrt, degrees, radians, pi
+import time
+
+def calculate_triangle_area(a, b, c):
+    """Calculate triangle area using Heron's formula"""
+    s = (a + b + c) / 2  # semi-perimeter
+    area = sqrt(s * (s - a) * (s - b) * (s - c))
+    return area
+
+def draw_triangle(side_a, side_b, side_c, angle_A, angle_B, angle_C, title="Triangle"):
+    """Draw a triangle with labeled sides and angles using Plotly"""
+    
+    # Place vertices (C at origin, B on x-axis)
+    C = np.array([0, 0])
+    B = np.array([side_a, 0])
+    A = np.array([side_b * cos(radians(angle_C)), side_b * sin(radians(angle_C))])
+    
+    # Create triangle coordinates for plotting
+    triangle_x = [A[0], B[0], C[0], A[0]]  # Close the triangle
+    triangle_y = [A[1], B[1], C[1], A[1]]
+    
+    # Create the figure
+    fig = go.Figure()
+    
+    # Add triangle fill
+    fig.add_trace(go.Scatter(
+        x=triangle_x,
+        y=triangle_y,
+        fill='toself',
+        fillcolor='rgba(173, 216, 230, 0.3)',
+        line=dict(color='blue', width=3),
+        mode='lines',
+        name='Triangle',
+        showlegend=False
+    ))
+    
+    # Add vertices
+    fig.add_trace(go.Scatter(
+        x=[A[0]], y=[A[1]],
+        mode='markers+text',
+        marker=dict(color='red', size=12),
+        text=['A'],
+        textposition='top center',
+        textfont=dict(size=16, color='black'),
+        name='Vertex A',
+        showlegend=True
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=[B[0]], y=[B[1]],
+        mode='markers+text',
+        marker=dict(color='green', size=12),
+        text=['B'],
+        textposition='bottom center',
+        textfont=dict(size=16, color='black'),
+        name='Vertex B',
+        showlegend=True
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=[C[0]], y=[C[1]],
+        mode='markers+text',
+        marker=dict(color='blue', size=12),
+        text=['C'],
+        textposition='middle left',
+        textfont=dict(size=16, color='black'),
+        name='Vertex C',
+        showlegend=True
+    ))
+    
+    # Calculate midpoints for side labels
+    mid_AB = (A + B) / 2
+    mid_BC = (B + C) / 2
+    mid_CA = (C + A) / 2
+    
+    # Add side labels
+    fig.add_trace(go.Scatter(
+        x=[mid_AB[0]], y=[mid_AB[1]],
+        mode='text',
+        text=[f'c = {side_c:.2f}'],
+        textfont=dict(size=12, color='black'),
+        textposition='top center',
+        showlegend=False
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=[mid_BC[0]], y=[mid_BC[1]],
+        mode='text',
+        text=[f'a = {side_a:.2f}'],
+        textfont=dict(size=12, color='black'),
+        textposition='bottom center',
+        showlegend=False
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=[mid_CA[0]], y=[mid_CA[1]],
+        mode='text',
+        text=[f'b = {side_b:.2f}'],
+        textfont=dict(size=12, color='black'),
+        textposition='middle left',
+        showlegend=False
+    ))
+    
+    # Add angle labels
+    fig.add_trace(go.Scatter(
+        x=[A[0] - 0.3], y=[A[1] - 0.3],
+        mode='text',
+        text=[f'∠A = {angle_A:.1f}°'],
+        textfont=dict(size=10, color='black'),
+        showlegend=False
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=[B[0] + 0.2], y=[B[1] + 0.2],
+        mode='text',
+        text=[f'∠B = {angle_B:.1f}°'],
+        textfont=dict(size=10, color='black'),
+        showlegend=False
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=[C[0] + 0.2], y=[C[1] + 0.2],
+        mode='text',
+        text=[f'∠C = {angle_C:.1f}°'],
+        textfont=dict(size=10, color='black'),
+        showlegend=False
+    ))
+    
+    # Set layout
+    all_x = [A[0], B[0], C[0]]
+    all_y = [A[1], B[1], C[1]]
+    margin = 1.0
+    
+    fig.update_layout(
+        title=dict(text=title, font=dict(size=18, color='black'), x=0.5),
+        xaxis=dict(
+            range=[min(all_x) - margin, max(all_x) + margin],
+            showgrid=True,
+            gridcolor='lightgray',
+            zeroline=True,
+            zerolinecolor='gray'
+        ),
+        yaxis=dict(
+            range=[min(all_y) - margin, max(all_y) + margin],
+            showgrid=True,
+            gridcolor='lightgray',
+            zeroline=True,
+            zerolinecolor='gray',
+            scaleanchor="x",
+            scaleratio=1
+        ),
+        plot_bgcolor='white',
+        paper_bgcolor='white',
+        width=700,
+        height=600,
+        margin=dict(l=50, r=50, t=80, b=50)
+    )
+    
+    return fig
+
+def draw_vectors(a_x, a_y, b_x, b_y, angle_between):
+    """Draw two vectors and show the angle between them using Plotly"""
+    
+    fig = go.Figure()
+    
+    # Draw vectors from origin
+    fig.add_trace(go.Scatter(
+        x=[0, a_x], y=[0, a_y],
+        mode='lines+markers',
+        line=dict(color='red', width=4),
+        marker=dict(symbol='arrow', angle=90, size=15, color='red'),
+        name=f'Vector A ({a_x:.2f}, {a_y:.2f})'
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=[0, b_x], y=[0, b_y],
+        mode='lines+markers',
+        line=dict(color='blue', width=4),
+        marker=dict(symbol='arrow', angle=90, size=15, color='blue'),
+        name=f'Vector B ({b_x:.2f}, {b_y:.2f})'
+    ))
+    
+    # Create angle arc
+    magnitude_a = sqrt(a_x**2 + a_y**2)
+    magnitude_b = sqrt(b_x**2 + b_y**2)
+    
+    angle_a = atan2(a_y, a_x)
+    angle_b = atan2(b_y, b_x)
+    
+    if angle_a < angle_b:
+        arc_angles = np.linspace(angle_a, angle_b, 50)
+    else:
+        arc_angles = np.linspace(angle_b, angle_a, 50)
+    
+    arc_radius = min(magnitude_a, magnitude_b) * 0.3
+    arc_x = arc_radius * np.cos(arc_angles)
+    arc_y = arc_radius * np.sin(arc_angles)
+    
+    # Add angle arc
+    fig.add_trace(go.Scatter(
+        x=arc_x, y=arc_y,
+        mode='lines',
+        line=dict(color='green', width=4),
+        showlegend=False
+    ))
+    
+    # Add angle label
+    mid_angle = (angle_a + angle_b) / 2
+    label_x = (arc_radius + 0.5) * cos(mid_angle)
+    label_y = (arc_radius + 0.5) * sin(mid_angle)
+    
+    fig.add_trace(go.Scatter(
+        x=[label_x], y=[label_y],
+        mode='text',
+        text=[f'{angle_between:.1f}°'],
+        textfont=dict(size=14, color='green'),
+        showlegend=False
+    ))
+    
+    # Add vector endpoint labels
+    fig.add_trace(go.Scatter(
+        x=[a_x], y=[a_y],
+        mode='text',
+        text=['A'],
+        textfont=dict(size=16, color='red'),
+        textposition='top right',
+        showlegend=False
+    ))
+    
+    fig.add_trace(go.Scatter(
+        x=[b_x], y=[b_y],
+        mode='text',
+        text=['B'],
+        textfont=dict(size=16, color='blue'),
+        textposition='top right',
+        showlegend=False
+    ))
+    
+    # Set layout
+    max_range = max(magnitude_a, magnitude_b) * 1.2
+    
+    fig.update_layout(
+        title=dict(text=f'Vectors with {angle_between:.1f}° angle between them', 
+                  font=dict(size=18, color='black'), x=0.5),
+        xaxis=dict(
+            range=[-max_range * 0.1, max_range],
+            showgrid=True,
+            gridcolor='lightgray',
+            zeroline=True,
+            zerolinecolor='black',
+            zerolinewidth=2
+        ),
+        yaxis=dict(
+            range=[-max_range * 0.1, max_range],
+            showgrid=True,
+            gridcolor='lightgray',
+            zeroline=True,
+            zerolinecolor='black',
+            zerolinewidth=2,
+            scaleanchor="x",
+            scaleratio=1
+        ),
+        plot_bgcolor='white',
+        paper_bgcolor='white',
+        width=700,
+        height=600,
+        margin=dict(l=50, r=50, t=80, b=50)
+    )
+    
+    return fig
+
+def law_of_sines_calculator():
+    st.header("📏 Law of Sines Calculator")
+    st.markdown("**Formula:** a/sin(A) = b/sin(B) = c/sin(C)")
+    st.markdown("**Equivalent:** sin(A)/a = sin(B)/b = sin(C)/c")
+    
+    # Add formula explanation
+    with st.expander("📚 Understanding the Law of Sines"):
+        st.markdown("""
+        The Law of Sines can be written in two equivalent forms:
+        
+        **Form 1:** a/sin(A) = b/sin(B) = c/sin(C)
+        
+        **Form 2:** sin(A)/a = sin(B)/b = sin(C)/c
+        
+        Both forms are mathematically identical and lead to the same calculations:
+        - To find a side: side = (other_side × sin(opposite_angle)) / sin(known_angle)
+        - To find an angle: sin(angle) = (opposite_side × sin(known_angle)) / known_side
+        
+        **Use the Law of Sines when you have:**
+        - **AAS (Angle-Angle-Side)**: Two angles and one side
+        - **ASA (Angle-Side-Angle)**: Two angles and the included side  
+        - **SSA (Side-Side-Angle)**: Two sides and one angle (ambiguous case)
+        """)
+    
+    # Add a visual demonstration of the relationship
+    with st.expander("🔍 See the calculation steps"):
+        st.markdown("""
+        **Example calculation process:**
+        
+        If we know: angle A, angle B, and side a
+        
+        **Step 1:** Find angle C
+        C = 180° - A - B
+        
+        **Step 2:** Use Law of Sines to find side b
+        From: a/sin(A) = b/sin(B)
+        
+        Rearrange: b = (a × sin(B)) / sin(A)
+        
+        **Step 3:** Find side c  
+        From: a/sin(A) = c/sin(C)
+        
+        Rearrange: c = (a × sin(C)) / sin(A)
+        """)
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("📝 Input Triangle Data")
+        
+        known_case = st.selectbox(
+            "What do you know about the triangle?",
+            ["Two angles and one side (AAS/ASA)", "Two sides and one angle (SSA)"]
+        )
+        
+        if known_case == "Two angles and one side (AAS/ASA)":
+            st.write("**Enter two angles and one side:**")
+            angle_A = st.number_input("Angle A (degrees):", min_value=0.1, max_value=179.9, value=60.0, key="sines_angleA")
+            angle_B = st.number_input("Angle B (degrees):", min_value=0.1, max_value=179.9, value=50.0, key="sines_angleB")
+            side_a = st.number_input("Side a (opposite to angle A):", min_value=0.1, value=10.0, key="sines_sidea")
+            
+            # Calculate third angle
+            angle_C = 180 - angle_A - angle_B
+            
+            if angle_C <= 0:
+                st.error("❌ Invalid triangle! Sum of angles must be less than 180°")
+                return
+            
+            # Calculate other sides using Law of Sines
+            side_b = side_a * sin(radians(angle_B)) / sin(radians(angle_A))
+            side_c = side_a * sin(radians(angle_C)) / sin(radians(angle_A))
+            
+            # Validate triangle
+            if side_b <= 0 or side_c <= 0:
+                st.error("❌ Invalid triangle! Check your inputs.")
+                return
+                
+        else:  # SSA case
+            st.write("**Enter two sides and one angle (ambiguous case):**")
+            side_a = st.number_input("Side a:", min_value=0.1, value=10.0, key="sines_ssa_sidea")
+            side_b = st.number_input("Side b:", min_value=0.1, value=8.0, key="sines_ssa_sideb")
+            angle_A = st.number_input("Angle A (opposite to side a):", min_value=0.1, max_value=179.9, value=60.0, key="sines_ssa_angleA")
+            
+            # Check for validity
+            sin_B = side_b * sin(radians(angle_A)) / side_a
+            
+            if sin_B > 1:
+                st.error("❌ No triangle possible with these measurements!")
+                return
+            elif abs(sin_B - 1) < 1e-10:  # sin_B == 1 (within floating point precision)
+                angle_B = 90.0
+                angle_C = 90 - angle_A
+                side_c = side_a * cos(radians(angle_A))
+                st.info("✅ Right triangle solution found!")
+            else:
+                angle_B = degrees(asin(sin_B))
+                angle_C = 180 - angle_A - angle_B
+                side_c = side_a * sin(radians(angle_C)) / sin(radians(angle_A))
+                
+                # Check for ambiguous case
+                if side_b < side_a and angle_A < 90:
+                    angle_B2 = 180 - angle_B
+                    angle_C2 = 180 - angle_A - angle_B2
+                    if angle_C2 > 0:
+                        side_c2 = side_a * sin(radians(angle_C2)) / sin(radians(angle_A))
+                        st.warning(f"⚠️ Ambiguous case! Two triangles possible:")
+                        st.write(f"**Triangle 1:** B = {angle_B:.2f}°, C = {angle_C:.2f}°, c = {side_c:.3f}")
+                        st.write(f"**Triangle 2:** B = {angle_B2:.2f}°, C = {angle_C2:.2f}°, c = {side_c2:.3f}")
+                        
+                        # Let user choose which triangle to display
+                        triangle_choice = st.radio("Choose triangle to visualize:", ["Triangle 1", "Triangle 2"])
+                        if triangle_choice == "Triangle 2":
+                            angle_B, angle_C, side_c = angle_B2, angle_C2, side_c2
+    
+    with col2:
+        st.subheader("📊 Results")
+        
+        # Display results in a nice table
+        results_df = pd.DataFrame({
+            'Element': ['Side a', 'Side b', 'Side c', 'Angle A', 'Angle B', 'Angle C'],
+            'Value': [f'{side_a:.3f}', f'{side_b:.3f}', f'{side_c:.3f}', 
+                     f'{angle_A:.2f}°', f'{angle_B:.2f}°', f'{angle_C:.2f}°'],
+            'Type': ['Given' if known_case == "Two angles and one side (AAS/ASA)" else 'Given',
+                    'Calculated' if known_case == "Two angles and one side (AAS/ASA)" else 'Given', 
+                    'Calculated', 
+                    'Given' if known_case == "Two angles and one side (AAS/ASA)" else 'Given',
+                    'Given' if known_case == "Two angles and one side (AAS/ASA)" else 'Calculated',
+                    'Calculated']
+        })
+        st.dataframe(results_df, use_container_width=True)
+        
+        # Calculate area using formula: Area = (1/2)ab*sin(C)
+        area = 0.5 * side_a * side_b * sin(radians(angle_C))
+        perimeter = side_a + side_b + side_c
+        
+        col_metric1, col_metric2 = st.columns(2)
+        with col_metric1:
+            st.metric("Area", f"{area:.3f} sq units")
+        with col_metric2:
+            st.metric("Perimeter", f"{perimeter:.3f} units")
+        
+        # Draw the triangle
+        fig = draw_triangle(side_a, side_b, side_c, angle_A, angle_B, angle_C, "Law of Sines Triangle")
+        st.plotly_chart(fig, use_container_width=True)
+
+def law_of_cosines_calculator():
+    st.header("📐 Law of Cosines Calculator")
+    st.markdown("**Formula:** c² = a² + b² - 2ab⋅cos(C)")
+    
+    # Add formula explanation
+    with st.expander("📚 When to use Law of Cosines"):
+        st.markdown("""
+        Use the Law of Cosines when you have:
+        - **SSS (Side-Side-Side)**: All three sides known
+        - **SAS (Side-Angle-Side)**: Two sides and the included angle
+        
+        This is especially useful when the Law of Sines doesn't apply directly.
+        """)
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("📝 Input Triangle Data")
+        
+        known_case = st.selectbox(
+            "What do you know?",
+            ["Three sides (SSS)", "Two sides and included angle (SAS)"]
+        )
+        
+        if known_case == "Three sides (SSS)":
+            st.write("**Enter all three sides:**")
+            side_a = st.number_input("Side a:", min_value=0.1, value=5.0, key="cosines_sss_sidea")
+            side_b = st.number_input("Side b:", min_value=0.1, value=7.0, key="cosines_sss_sideb")
+            side_c = st.number_input("Side c:", min_value=0.1, value=9.0, key="cosines_sss_sidec")
+            
+            # Check triangle inequality
+            if not (side_a + side_b > side_c and side_b + side_c > side_a and side_a + side_c > side_b):
+                st.error("❌ Invalid triangle! Triangle inequality not satisfied.")
+                st.write("**Triangle Inequality Rules:**")
+                st.write(f"• a + b > c: {side_a:.2f} + {side_b:.2f} = {side_a + side_b:.2f} {'✓' if side_a + side_b > side_c else '✗'} {side_c:.2f}")
+                st.write(f"• b + c > a: {side_b:.2f} + {side_c:.2f} = {side_b + side_c:.2f} {'✓' if side_b + side_c > side_a else '✗'} {side_a:.2f}")
+                st.write(f"• a + c > b: {side_a:.2f} + {side_c:.2f} = {side_a + side_c:.2f} {'✓' if side_a + side_c > side_b else '✗'} {side_b:.2f}")
+                return
+            
+            # Calculate angles using Law of Cosines
+            try:
+                angle_A = degrees(acos((side_b**2 + side_c**2 - side_a**2) / (2 * side_b * side_c)))
+                angle_B = degrees(acos((side_a**2 + side_c**2 - side_b**2) / (2 * side_a * side_c)))
+                angle_C = 180 - angle_A - angle_B
+            except ValueError:
+                st.error("❌ Error calculating angles. Check your side lengths.")
+                return
+            
+        else:  # SAS case
+            st.write("**Enter two sides and the included angle:**")
+            side_a = st.number_input("Side a:", min_value=0.1, value=5.0, key="cosines_sas_sidea")
+            side_b = st.number_input("Side b:", min_value=0.1, value=7.0, key="cosines_sas_sideb")
+            angle_C = st.number_input("Angle C (between sides a and b):", min_value=0.1, max_value=179.9, value=60.0, key="cosines_sas_angleC")
+            
+            # Calculate third side using Law of Cosines
+            side_c = sqrt(side_a**2 + side_b**2 - 2 * side_a * side_b * cos(radians(angle_C)))
+            
+            # Calculate other angles using Law of Cosines
+            try:
+                angle_A = degrees(acos((side_b**2 + side_c**2 - side_a**2) / (2 * side_b * side_c)))
+                angle_B = 180 - angle_A - angle_C
+            except ValueError:
+                st.error("❌ Error calculating angles. Check your inputs.")
+                return
+    
+    with col2:
+        st.subheader("📊 Results")
+        
+        # Display results
+        results_df = pd.DataFrame({
+            'Element': ['Side a', 'Side b', 'Side c', 'Angle A', 'Angle B', 'Angle C'],
+            'Value': [f'{side_a:.3f}', f'{side_b:.3f}', f'{side_c:.3f}', 
+                     f'{angle_A:.2f}°', f'{angle_B:.2f}°', f'{angle_C:.2f}°'],
+            'Type': ['Given', 'Given', 
+                    'Given' if known_case == "Three sides (SSS)" else 'Calculated',
+                    'Calculated', 'Calculated',
+                    'Calculated' if known_case == "Three sides (SSS)" else 'Given']
+        })
+        st.dataframe(results_df, use_container_width=True)
+        
+        # Calculate area and perimeter
+        area = calculate_triangle_area(side_a, side_b, side_c)
+        perimeter = side_a + side_b + side_c
+        
+        col_metric1, col_metric2 = st.columns(2)
+        with col_metric1:
+            st.metric("Area", f"{area:.3f} sq units")
+        with col_metric2:
+            st.metric("Perimeter", f"{perimeter:.3f} units")
+        
+        # Determine triangle type
+        if abs(angle_A - 90) < 0.01 or abs(angle_B - 90) < 0.01 or abs(angle_C - 90) < 0.01:
+            triangle_type = "Right Triangle"
+        elif angle_A > 90 or angle_B > 90 or angle_C > 90:
+            triangle_type = "Obtuse Triangle"
+        else:
+            triangle_type = "Acute Triangle"
+        
+        st.info(f"**Triangle Type:** {triangle_type}")
+        
+        # Draw the triangle
+        fig = draw_triangle(side_a, side_b, side_c, angle_A, angle_B, angle_C, "Law of Cosines Triangle")
+        st.plotly_chart(fig, use_container_width=True)
+
+def vector_angle_calculator():
+    st.header("🔄 Vector Angle Calculator")
+    st.markdown("**Formula:** cos(θ) = (A⋅B) / (|A|⋅|B|)")
+    
+    # Add explanation
+    with st.expander("📚 Understanding Vector Angles"):
+        st.markdown("""
+        **Dot Product Formula:** A⋅B = |A||B|cos(θ)
+        
+        **Applications:**
+        - Physics: Work = Force⋅Displacement⋅cos(θ)
+        - Computer Graphics: Lighting calculations
+        - Engineering: Force analysis
+        - Navigation: Direction calculations
+        """)
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("📝 Enter Vectors")
+        
+        # Vector input methods
+        input_method = st.radio("Input method:", ["Component form", "Magnitude & Direction"])
+        
+        if input_method == "Component form":
+            st.write("**Vector A:**")
+            a_x = st.number_input("A_x component:", value=3.0, key="vector_ax")
+            a_y = st.number_input("A_y component:", value=4.0, key="vector_ay")
+            
+            st.write("**Vector B:**")
+            b_x = st.number_input("B_x component:", value=1.0, key="vector_bx")
+            b_y = st.number_input("B_y component:", value=2.0, key="vector_by")
+            
+        else:
+            st.write("**Vector A:**")
+            mag_a = st.number_input("Magnitude of A:", min_value=0.1, value=5.0, key="vector_mag_a")
+            dir_a = st.number_input("Direction of A (degrees):", value=53.0, key="vector_dir_a")
+            
+            st.write("**Vector B:**")
+            mag_b = st.number_input("Magnitude of B:", min_value=0.1, value=2.24, key="vector_mag_b")
+            dir_b = st.number_input("Direction of B (degrees):", value=63.4, key="vector_dir_b")
+            
+            # Convert to components
+            a_x = mag_a * cos(radians(dir_a))
+            a_y = mag_a * sin(radians(dir_a))
+            b_x = mag_b * cos(radians(dir_b))
+            b_y = mag_b * sin(radians(dir_b))
+        
+        # Calculate vector properties
+        dot_product = a_x * b_x + a_y * b_y
+        magnitude_a = sqrt(a_x**2 + a_y**2)
+        magnitude_b = sqrt(b_x**2 + b_y**2)
+        
+        if magnitude_a == 0 or magnitude_b == 0:
+            st.error("❌ Zero vector detected! Cannot calculate angle.")
+            return
+        
+        cos_theta = dot_product / (magnitude_a * magnitude_b)
+        # Clamp to [-1, 1] to avoid floating point errors
+        cos_theta = max(-1, min(1, cos_theta))
+        angle_degrees = degrees(acos(cos_theta))
+        
+        # Calculate cross product for 2D (gives scalar)
+        cross_product = a_x * b_y - a_y * b_x
+    
+    with col2:
+        st.subheader("📊 Results")
+        
+        # Vector information table
+        vector_info = pd.DataFrame({
+            'Property': ['A_x', 'A_y', 'B_x', 'B_y', '|A|', '|B|'],
+            'Value': [f'{a_x:.3f}', f'{a_y:.3f}', f'{b_x:.3f}', f'{b_y:.3f}', 
+                     f'{magnitude_a:.3f}', f'{magnitude_b:.3f}']
+        })
+        st.dataframe(vector_info, use_container_width=True)
+        
+        # Key results
+        col_metric1, col_metric2 = st.columns(2)
+        with col_metric1:
+            st.metric("Dot Product (A⋅B)", f"{dot_product:.3f}")
+            st.metric("Angle", f"{angle_degrees:.2f}°")
+        with col_metric2:
+            st.metric("Cross Product (2D)", f"{cross_product:.3f}")
+            st.metric("cos(θ)", f"{cos_theta:.4f}")
+        
+        # Vector relationship
+        if abs(dot_product) < 1e-10:
+            st.info("🔄 **Vectors are perpendicular (orthogonal)**")
+        elif cos_theta > 0:
+            st.info("📐 **Vectors point in similar directions (acute angle)**")
+        else:
+            st.info("📐 **Vectors point in opposite directions (obtuse angle)**")
+        
+        # Draw vectors
+        fig = draw_vectors(a_x, a_y, b_x, b_y, angle_degrees)
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Additional calculations
+        st.subheader("🧮 Additional Calculations")
+        
+        # Unit vectors
+        unit_a_x = a_x / magnitude_a if magnitude_a != 0 else 0
+        unit_a_y = a_y / magnitude_a if magnitude_a != 0 else 0
+        unit_b_x = b_x / magnitude_b if magnitude_b != 0 else 0
+        unit_b_y = b_y / magnitude_b if magnitude_b != 0 else 0
+        
+        st.write(f"**Unit vector A:** ({unit_a_x:.3f}, {unit_a_y:.3f})")
+        st.write(f"**Unit vector B:** ({unit_b_x:.3f}, {unit_b_y:.3f})")
+        
+        # Vector sum and difference
+        sum_x, sum_y = a_x + b_x, a_y + b_y
+        diff_x, diff_y = a_x - b_x, a_y - b_y
+        
+        st.write(f"**A + B:** ({sum_x:.3f}, {sum_y:.3f})")
+        st.write(f"**A - B:** ({diff_x:.3f}, {diff_y:.3f})")
+
+def triangle_visualizer():
+    st.header("🎨 Interactive Triangle Visualizer")
+    st.markdown("Explore how changing triangle properties affects its shape and calculations!")
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("🎛️ Triangle Controls")
+        
+        # Interactive sliders for triangle properties
+        side_a = st.slider("Side a:", min_value=1.0, max_value=15.0, value=8.0, step=0.1)
+        side_b = st.slider("Side b:", min_value=1.0, max_value=15.0, value=6.0, step=0.1)
+        angle_C = st.slider("Angle C (degrees):", min_value=10.0, max_value=170.0, value=60.0, step=1.0)
+        
+        # Calculate using Law of Cosines
+        side_c = sqrt(side_a**2 + side_b**2 - 2 * side_a * side_b * cos(radians(angle_C)))
+        
+        # Calculate other angles
+        try:
+            angle_A = degrees(acos((side_b**2 + side_c**2 - side_a**2) / (2 * side_b * side_c)))
+            angle_B = 180 - angle_A - angle_C
+        except ValueError:
+            st.error("Invalid triangle configuration!")
+            return
+        
+        # Real-time calculations
+        area = 0.5 * side_a * side_b * sin(radians(angle_C))
+        perimeter = side_a + side_b + side_c
+        
+        # Display live results
+        st.subheader("📊 Live Results")
+        col_live1, col_live2 = st.columns(2)
+        with col_live1:
+            st.metric("Side c", f"{side_c:.2f}")
+            st.metric("Angle A", f"{angle_A:.1f}°")
+            st.metric("Area", f"{area:.2f}")
+        with col_live2:
+            st.metric("Angle B", f"{angle_B:.1f}°")
+            st.metric("Perimeter", f"{perimeter:.2f}")
+            
+        # Triangle type
+        if abs(angle_A - 90) < 0.1 or abs(angle_B - 90) < 0.1 or abs(angle_C - 90) < 0.1:
+            triangle_type = "Right"
+        elif angle_A > 90 or angle_B > 90 or angle_C > 90:
+            triangle_type = "Obtuse"
+        else:
+            triangle_type = "Acute"
+        
+        st.info(f"**Triangle Type:** {triangle_type}")
+    
+    with col2:
+        st.subheader("📐 Interactive Triangle")
+        
+        # Draw the interactive triangle
+        fig = draw_triangle(side_a, side_b, side_c, angle_A, angle_B, angle_C, "Interactive Triangle")
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Show which laws apply
+        st.subheader("📚 Applicable Laws")
+        st.write("**Given:** Two sides (a, b) and included angle (C)")
+        st.write("**Use:** Law of Cosines to find side c")
+        st.write("**Then:** Law of Cosines or Sines to find remaining angles")
+        
+        # Show the calculations
+        with st.expander("🔍 See the calculations"):
+            st.write("**Step 1: Find side c using Law of Cosines**")
+            st.latex(r"c^2 = a^2 + b^2 - 2ab \cos(C)")
+            st.write(f"c² = {side_a}² + {side_b}² - 2({side_a})({side_b})cos({angle_C}°)")
+            st.write(f"c² = {side_a**2:.2f} + {side_b**2:.2f} - {2*side_a*side_b:.2f} × {cos(radians(angle_C)):.4f}")
+            st.write(f"c = {side_c:.3f}")
+            
+            st.write("**Step 2: Find angle A using Law of Cosines**")
+            st.latex(r"\cos(A) = \frac{b^2 + c^2 - a^2}{2bc}")
+            st.write(f"cos(A) = ({side_b}² + {side_c:.2f}² - {side_a}²) / (2 × {side_b} × {side_c:.2f})")
+            st.write(f"A = {angle_A:.2f}°")
+            
+            st.write("**Step 3: Find angle B**")
+            st.write(f"B = 180° - A - C = 180° - {angle_A:.2f}° - {angle_C}° = {angle_B:.2f}°")
+
+def main():
+    st.set_page_config(page_title="Triangle Solver & Vector Calculator", page_icon="📐", layout="wide")
+    
+    st.title("📐 Triangle Solver & Vector Calculator")
+    st.markdown("### Master the Law of Sines, Law of Cosines, and Vector Applications!")
+    
+    # Add educational tips
+    tips = [
+        "💡 **Law of Sines**: Use when you have angle-side-angle (ASA) or side-angle-angle (SAA)",
+        "🎯 **Law of Cosines**: Use when you have side-side-side (SSS) or side-angle-side (SAS)",
+        "📊 **Vector Tip**: The angle between vectors uses the dot product formula",
+        "🔄 **Remember**: Always check if your triangle is valid (triangle inequality)",
+        "⚡ **Practical**: These laws help in navigation, engineering, and physics!"
+    ]
+    
+    st.info(np.random.choice(tips))
+    
+    # Sidebar for mode selection
+    st.sidebar.header("🎛️ Calculator Mode")
+    mode = st.sidebar.radio(
+        "Choose what to calculate:",
+        ["Law of Sines", "Law of Cosines", "Vector Angle Calculator", "Triangle Visualizer"]
+    )
+    
+    # Educational content sidebar
+    with st.sidebar.expander("📚 Quick Reference"):
+        st.markdown("""
+        **Law of Sines:**
+        a/sin(A) = b/sin(B) = c/sin(C)
+        
+        **Law of Cosines:**
+        c² = a² + b² - 2ab⋅cos(C)
+        
+        **Vector Angle:**
+        cos(θ) = (A⋅B)/(|A||B|)
+        
+        **Triangle Inequality:**
+        a + b > c, b + c > a, a + c > b
+        """)
+    
+    # Main content based on mode
+    if mode == "Law of Sines":
+        law_of_sines_calculator()
+    elif mode == "Law of Cosines":
+        law_of_cosines_calculator()
+    elif mode == "Vector Angle Calculator":
+        vector_angle_calculator()
+    else:
+        triangle_visualizer()
+    
+    # Footer with applications
+    st.markdown("---")
+    st.subheader("🌟 Real-World Applications")
+    
+    app_col1, app_col2, app_col3 = st.columns(3)
+    
+    with app_col1:
+        st.markdown("""
+        **🏗️ Engineering**
+        - Structural analysis
+        - Force calculations
+        - Bridge design
+        """)
+    
+    with app_col2:
+        st.markdown("""
+        **🧭 Navigation**
+        - GPS systems
+        - Ship navigation
+        - Flight paths
+        """)
+    
+    with app_col3:
+        st.markdown("""
+        **🎮 Technology**
+        - Computer graphics
+        - Game physics
+        - Robotics
+        """)
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()