import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# Load data
data = pd.read_csv('sales_data.csv')

# Basic statistics
print("Dataset Overview:")
print(data.describe())

# Calculate monthly growth
data['growth_rate'] = data['sales'].pct_change() * 100

# Create visualization
plt.figure(figsize=(10, 6))
plt.plot(data['month'], data['sales'], marker='o')
plt.title('Monthly Sales Trend')
plt.xlabel('Month')
plt.ylabel('Sales ($)')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Generate insights
avg_growth = data['growth_rate'].mean()
print(f"Average monthly growth rate: {avg_growth:.2f}%")

import numpy as np
from datetime import datetime, timedelta

def calculate_compound_interest(principal, rate, time, compound_freq=12):
    """Calculate compound interest"""
    amount = principal * (1 + rate/compound_freq) ** (compound_freq * time)
    interest = amount - principal
    return amount, interest

def calculate_loan_payment(principal, rate, years):
    """Calculate monthly loan payment"""
    monthly_rate = rate / 12
    num_payments = years * 12
    payment = principal * (monthly_rate * (1 + monthly_rate)**num_payments) / ((1 + monthly_rate)**num_payments - 1)
    return payment

# Investment projection
initial_investment = 10000
annual_rate = 0.07
years = 10

final_amount, earned_interest = calculate_compound_interest(initial_investment, annual_rate, years)
print(f"Investment of ${initial_investment:,.2f}")
print(f"After {years} years at {annual_rate*100}% annual rate:")
print(f"Final amount: ${final_amount:,.2f}")
print(f"Interest earned: ${earned_interest:,.2f}")

# Loan calculation
loan_amount = 250000
loan_rate = 0.045
loan_years = 30

monthly_payment = calculate_loan_payment(loan_amount, loan_rate, loan_years)
total_paid = monthly_payment * loan_years * 12
total_interest = total_paid - loan_amount

print(f"\nLoan Analysis for ${loan_amount:,.2f}:")
print(f"Monthly payment: ${monthly_payment:,.2f}")
print(f"Total interest: ${total_interest:,.2f}")

import re
from collections import Counter
import json

def analyze_text(text):
    """Comprehensive text analysis"""
    # Basic metrics
    word_count = len(text.split())
    char_count = len(text)
    sentence_count = len(re.split(r'[.!?]+', text))
    
    # Word frequency analysis
    words = re.findall(r'\b\w+\b', text.lower())
    word_freq = Counter(words)
    most_common = word_freq.most_common(10)
    
    # Reading statistics
    avg_words_per_sentence = word_count / sentence_count if sentence_count > 0 else 0
    
    # Extract key information
    emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)
    phone_numbers = re.findall(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', text)
    dates = re.findall(r'\b\d{1,2}/\d{1,2}/\d{4}\b', text)
    
    return {
        'word_count': word_count,
        'character_count': char_count,
        'sentence_count': sentence_count,
        'avg_words_per_sentence': round(avg_words_per_sentence, 2),
        'most_common_words': most_common,
        'emails_found': emails,
        'phone_numbers': phone_numbers,
        'dates_found': dates
    }

# Example usage
sample_text = """
This is a sample document for analysis. It contains various types of information
including contact details like [email protected] and phone numbers such as 
555-123-4567. Important dates mentioned include 12/25/2024 and 01/15/2025.
The document discusses business metrics and performance indicators.
"""

analysis = analyze_text(sample_text)
print(json.dumps(analysis, indent=2))

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
from scipy.optimize import minimize

# Monte Carlo simulation
def monte_carlo_pi(num_samples):
    """Estimate π using Monte Carlo method"""
    x = np.random.uniform(-1, 1, num_samples)
    y = np.random.uniform(-1, 1, num_samples)
    
    # Check if points are inside unit circle
    inside_circle = (x**2 + y**2) <= 1
    pi_estimate = 4 * np.sum(inside_circle) / num_samples
    
    return pi_estimate

# Statistical analysis
def analyze_dataset(data):
    """Comprehensive statistical analysis"""
    results = {
        'mean': np.mean(data),
        'median': np.median(data),
        'std_dev': np.std(data),
        'variance': np.var(data),
        'min': np.min(data),
        'max': np.max(data),
        'quartiles': np.percentile(data, [25, 50, 75])
    }
    
    # Normality test
    _, p_value = stats.normaltest(data)
    results['is_normal'] = p_value > 0.05
    results['p_value'] = p_value
    
    return results

# Generate sample data
np.random.seed(42)
sample_data = np.random.normal(100, 15, 1000)

# Run analyses
pi_estimate = monte_carlo_pi(100000)
print(f"π estimate using Monte Carlo: {pi_estimate:.6f}")
print(f"Actual π: {np.pi:.6f}")
print(f"Error: {abs(pi_estimate - np.pi):.6f}")

print("\nStatistical Analysis:")
stats_results = analyze_dataset(sample_data)
for key, value in stats_results.items():
    if isinstance(value, (int, float)):
        print(f"{key}: {value:.4f}")
    else:
        print(f"{key}: {value}")

# Create visualization
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.hist(sample_data, bins=50, alpha=0.7, edgecolor='black')
plt.title('Data Distribution')
plt.xlabel('Value')
plt.ylabel('Frequency')

plt.subplot(1, 2, 2)
stats.probplot(sample_data, dist="norm", plot=plt)
plt.title('Q-Q Plot (Normal Distribution)')

plt.tight_layout()
plt.show()