Math Resources and Tools Complete Guide for 2026

import sympy as sp
from sympy import symbols, Function, Derivative, Integral, simplify, solve, limit

# Define symbols
x, y, z, n = symbols('x y z n')

# Simplify expressions
expr = sp.sin(x)**2 + sp.cos(x)**2
print(sp.simplify(expr))  # Output: 1

# Algebraic manipulation
expr = (x**2 - 4) / (x - 2)
print(sp.simplify(expr))  # Output: x + 2

# Solve equations
solutions = sp.solve(x**2 - 4, x)
print(solutions)  # Output: [-2, 2]

# Solve systems
solutions = sp.solve([x + y - 3, x - y - 1], (x, y))
print(solutions)  # Output: {x: 2, y: 1}

# Derivatives
f = x**3 + 2*x**2 + x
print(sp.diff(f, x))  # Output: 3*x**2 + 4*x + 1
print(sp.diff(f, x, 2))  # Second derivative: 6*x + 4

# Integrals
print(sp.integrate(x**2, x))  # x**3/3
print(sp.integrate(sp.exp(-x**2), (x, -sp.oo, sp.oo)))  # sqrt(pi)

# Limits
print(limit(sp.sin(x)/x, x, 0))  # Output: 1

# Series expansion
print(sp.series(sp.exp(x), x, 0, 6))  # Taylor series

# Matrices
A = sp.Matrix([[1, 2], [3, 4]])
print(A.inv())  # Matrix inverse
print(A.det())  # Determinant
print(A.eigenvalues())  # Eigenvalues

# Wolfram Alpha API usage example
import requests

def query_wolfram(query):
    """Query Wolfram Alpha."""
    url = "https://api.wolframalpha.com/v1/result"
    params = {
        'appid': 'YOUR_APP_ID',
        'i': query
    }
    response = requests.get(url, params=params)
    return response.text

# Example queries
# "integrate x^2 sin(x)"
# "solve x^2 + 4x + 4 = 0"
# "derivative of tan(x)"

import numpy as np

# Basic array operations
arr = np.array([1, 2, 3, 4, 5])
print(np.mean(arr), np.std(arr), np.sum(arr))

# Matrix operations
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# Matrix multiplication
C = A @ B  # or np.matmul(A, B)

# Element-wise operations
D = A * B

# Linear algebra
eigenvalues, eigenvectors = np.linalg.eig(A)
inverse = np.linalg.inv(A)
determinant = np.linalg.det(A)

# Solving linear systems Ax = b
b = np.array([1, 2])
x = np.linalg.solve(A, b)

# SVD
U, S, Vt = np.linalg.svd(A)

import numpy as np
from scipy import integrate, optimize, linalg, stats, signal

# Numerical integration
result, error = integrate.quad(lambda x: x**2, 0, 1)
print(f"Integral: {result}, Error: {error}")

# Double integration
result = integrate.dblquad(
    lambda x, y: x*y, 0, 2, lambda x: 0, lambda x: x
)

# Optimization
result = optimize.minimize(
    lambda x: x[0]**2 + x[1]**2,
    x0=[1, 1],
    method='BFGS'
)

# Root finding
def f(x):
    return x**2 - 4

root = optimize.root(f, x0=[1])
print(root.x)  # Approximately 2

# Linear algebra
A = np.array([[1, 2], [3, 4]])
b = np.array([5, 6])
x = linalg.solve(A, b)

# Statistics
data = np.random.normal(0, 1, 1000)
mean = stats.norm.fit(data)
print(f"Mean: {mean[0]}, Std: {mean[1]}")

# Signal processing
t = np.linspace(0, 1, 1000)
signal = np.sin(2*np.pi*5*t) + 0.5*np.sin(2*np.pi*10*t)
frequencies, power = signal.periodogram()

# Numerical differentiation
from scipy.misc import derivative

def f(x):
    return x**3 + 2*x**2

# First derivative at x=2
df_dx = derivative(f, 2.0, dx=1e-6)
print(f"f'(2) = {df_dx}")

# Numerical solutions to ODEs
from scipy.integrate import odeint

def model(y, t):
    dydt = -0.5 * y
    return dydt

t = np.linspace(0, 10, 100)
y0 = [1]
solution = odeint(model, y0, t)

# Interpolation
from scipy.interpolate import interp1d, CubicSpline

x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 8, 27, 64])

# Linear interpolation
f_linear = interp1d(x, y)
print(f"Linear at 2.5: {f_linear(2.5)}")

# Cubic spline
f_cubic = CubicSpline(x, y)
print(f"Cubic at 2.5: {f_cubic(2.5)}")

# Fourier transforms
from scipy.fft import fft, fftfreq

signal = np.sin(2*np.pi*5*np.linspace(0, 1, 100))
transformed = fft(signal)
frequencies = fftfreq(len(signal), d=0.01)

import matplotlib.pyplot as plt
import numpy as np

# 2D plotting
x = np.linspace(-2*np.pi, 2*np.pi, 100)
y = np.sin(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', linewidth=2)
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.title('Sine Wave')
plt.grid(True)
plt.show()

# Multiple plots
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# Subplot 1: Function
axes[0, 0].plot(x, np.sin(x), 'b-')
axes[0, 0].set_title('sin(x)')

# Subplot 2: Parametric
t = np.linspace(0, 2*np.pi, 100)
axes[0, 1].plot(np.cos(t), np.sin(t), 'r-')
axes[0, 1].set_title('Parametric Circle')
axes[0, 1].set_aspect('equal')

# Subplot 3: 3D surface
from mpl_toolkits.mplot3d import Axes3D
ax = fig.add_subplot(2, 2, 3, projection='3d')
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
Z = np.sin(np.sqrt(X**2 + Y**2))
ax.plot_surface(X, Y, Z, cmap='viridis')

# Subplot 4: Heatmap
im = axes[1, 1].imshow(np.random.rand(10, 10), cmap='hot')
plt.colorbar(im, ax=axes[1, 1])

plt.tight_layout()
plt.show()

import plotly.graph_objects as go
import numpy as np

# 3D Surface
x = np.linspace(-5, 5, 50)
y = np.linspace(-5, 5, 50)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

fig = go.Figure(data=[go.Surface(z=Z, x=X, y=Y)])
fig.update_layout(
    title='3D Surface',
    scene=dict(
        xaxis_title='X',
        yaxis_title='Y',
        zaxis_title='Z'
    )
)
fig.show()

# Interactive line chart
fig = go.Figure()
fig.add_trace(go.Scatter(x=np.linspace(0, 10), y=np.sin(np.linspace(0, 10))))
fig.update_layout(title='Interactive Sine', xaxis_title='x', yaxis_title='sin(x)')
fig.show()

# Statistics formulas
import numpy as np

def mean(data):
    return sum(data) / len(data)

def variance(data):
    m = mean(data)
    return sum((x - m)**2 for x in data) / len(data)

def std_dev(data):
    return variance(data) ** 0.5

def correlation(x, y):
    n = len(x)
    mean_x, mean_y = mean(x), mean(y)
    cov = sum((x[i] - mean_x) * (y[i] - mean_y) for i in range(n)) / n
    return cov / (std_dev(x) * std_dev(y))

# Probability distributions
def normal_pdf(x, mu=0, sigma=1):
    return (1 / (sigma * np.sqrt(2*np.pi))) * \
           np.exp(-0.5 * ((x - mu) / sigma)**2)

import math

# Mathematical constants
PI = math.pi  # 3.14159...
E = math.e    # 2.71828...
PHI = (1 + math.sqrt(5)) / 2  # Golden ratio

# From scipy.constants
# Speed of light: 299792458 m/s
# Planck's constant: 6.62607015e-34 J⋅s
# Boltzmann constant: 1.380649e-23 J/K
# Avogadro constant: 6.02214076e23 mol⁻¹

# Control systems
import control as ct

# Create transfer function
num = [1]
den = [1, 2, 1]  # s^2 + 2s + 1
sys = ct.TransferFunction(num, den)

# Bode plot
w = ct.logspace(-2, 2, 100)
mag, phase, w = ct.bode(sys)

# Signal processing
from scipy import signal

# Design filter
b, a = signal.butter(3, 0.1, 'low')
filtered = signal.filtfilt(b, a, data)

# pandas for data analysis
import pandas as pd
import numpy as np

# Statistical tests
from scipy import stats

# Hypothesis testing
t_stat, p_value = stats.ttest_ind(sample1, sample2)

# ANOVA
f_stat, p_value = stats.f_oneway(group1, group2, group3)

# Chi-square test
chi2, p_value, dof, expected = stats.chi2_contingency(observed)

# Linear regression
slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)

# Linear algebra for ML
import numpy as np

# Vector operations
def dot_product(a, b):
    return sum(x*y for x, y in zip(a, b))

def matrix_multiply(A, B):
    return [[sum(a*b for a, b in zip(A_row, B_col)) 
             for B_col in zip(*B)] 
            for A_row in A]

# Gradient descent
def gradient_descent(f, grad_f, x0, learning_rate=0.01, iterations=1000):
    x = x0
    for _ in range(iterations):
        x = x - learning_rate * grad_f(x)
    return x