Wave Equation Solver

Topic: advanced.pde.wave_equation

The wave equation governs oscillatory phenomena and wave propagation in physical systems. Solves hyperbolic PDEs with boundary conditions and two initial conditions (position and velocity).

Mathematical Definition

$$\frac{{\partial }^{2}u}{\partial t^2}=c^2{\nabla }^{2}u$$

where:

• $u(x,t)$ is displacement at position $x$ and time $t$
• $c$ is wave speed (m/s)
• ${\nabla }^{2}u=\frac{{\partial }^{2}u}{\partial x^2}$ (1D)

Newton's Second Law for string element: $$\rho \frac{{\partial }^{2}u}{\partial t^2}=T\frac{{\partial }^{2}u}{\partial x^2}$$

Wave speed: $c=\sqrt{T/\rho }$ where $\rho$ = linear mass density, $T$ = tension

Wave Equation Solver

Mathematical Model

The wave equation governs oscillatory phenomena and wave propagation:

$$\frac{{\partial }^{2}u}{\partial t^2}=c^2{\nabla }^{2}u$$

where:

• $u(x,t)$ is displacement at position $x$ and time $t$
• $c$ is wave speed (m/s)
• ${\nabla }^{2}u=\frac{{\partial }^{2}u}{\partial x^2}$ (1D)

Physical Interpretation

Newton's Second Law applied to small element of string/membrane:

$$\rho \frac{{\partial }^{2}u}{\partial t^2}=T\frac{{\partial }^{2}u}{\partial x^2}$$

where $\rho$ = linear mass density, $T$ = tension.

Wave speed: $c=\sqrt{T/\rho }$

Key property: Waves propagate at finite speed $c$ (unlike heat equation's infinite speed).

Real-World Example: Vibrating Guitar String

Problem Setup

A guitar string of length $L=0.65$ m (standard scale length) is plucked at the center, displaced $5$ mm, and released from rest.

Material (steel E string):

• Tension: $T=73.4$ N
• Linear density: $\rho =3.75\times 10^{-4}$ kg/m
• Wave speed: $c=\sqrt{T/\rho }=\sqrt{73.4/3.75\times 10^{-4}}\approx 442$ m/s

Mathematical Formulation

PDE: $$\frac{{\partial }^{2}u}{\partial t^2}=c^2\frac{{\partial }^{2}u}{\partial x^2},0<x<L,t>0$$

Boundary Conditions (fixed ends): $$u(0,t)=0,u(L,t)=0$$

Initial Position (triangular pluck at center): $$u(x,0)=\{\begin{array}{ll}\frac{2h}{L}x& 0\le x\le L/2\\ \frac{2h}{L}(L-x)& L/2<x\le L\end{array}$$

where $h=0.005$ m (5 mm displacement).

Initial Velocity (released from rest): $$\frac{\partial u}{\partial t}(x,0)=0$$

Analytical Solution

General solution:

$$u(x,t)=\sum _{n=1}^{\infty }\left[A_n\cos ({\omega }_{n}t)+B_n\sin ({\omega }_{n}t)\right]\sin \left(\frac{n\pi x}{L}\right)$$

where:

• Eigenvalues: ${\lambda }_n=(n\pi /L{)}^2$
• Angular frequencies: ${\omega }_n=c{\lambda }_n^{1/2}=\frac{n\pi c}{L}$
• Physical frequencies: $f_n=\frac{{\omega }_n}{2\pi }=\frac{nc}{2L}$

Fourier coefficients from initial position:

$$A_n=\frac{2}{L}{\int }_0^{L}u(x,0)\sin \left(\frac{n\pi x}{L}\right)dx$$

For triangular pluck:

$$A_n=\frac{8h}{n^2{\pi }^2}\sin \left(\frac{n\pi }{2}\right)=\{\begin{array}{ll}\frac{8h}{n^2{\pi }^2}(-1{)}^{(n-1)/2}& \text{if }n\text{ odd}\\ 0& \text{if }n\text{ even}\end{array}$$

From initial velocity (released from rest: $\partial u/\partial t=0$):

$$B_n=0\text{for all }n$$

Final solution:

$$u(x,t)=\frac{8h}{{\pi }^2}\sum _{k=0}^{\infty }\frac{(-1{)}^k}{(2k+1{)}^2}\sin \left(\frac{(2k+1)\pi x}{L}\right)\cos \left(\frac{(2k+1)\pi ct}{L}\right)$$

Musical Harmonics

Fundamental Frequency (n=1)

$$f_1=\frac{c}{2L}=\frac{442}{2\times 0.65}\approx 340\text{Hz}$$

This is close to E4 note (329.63 Hz) - the open E string frequency.

Overtones (n=2, 3, 4, ...)

$$f_n=n{f}_1$$

• $f_2=680$ Hz (octave)
• $f_3=1020$ Hz (octave + fifth)
• $f_4=1360$ Hz (two octaves)

Timbre: Combination of harmonics determines sound quality. Triangular pluck emphasizes odd harmonics.

Standing Waves

Physical interpretation: Superposition of left-traveling and right-traveling waves.

D'Alembert solution:

$$u(x,t)=\frac{1}{2}[f(x-ct)+f(x+ct)]$$

where $f(x)$ is the initial shape extended periodically.

Standing wave form: Separation of variables gives standing waves (nodes don't move).

Nodes: Points where $u(x,t)=0$ for all $t$:

$$\sin \left(\frac{n\pi x}{L}\right)=0⟹x=\frac{kL}{n},k=0,1,\dots ,n$$

Mode $n$ has $n+1$ nodes (including endpoints).

Energy Conservation

Total energy (kinetic + potential):

$$E(t)=\frac{1}{2}{\int }_0^L\left[\rho {\left(\frac{\partial u}{\partial t}\right)}^2+T{\left(\frac{\partial u}{\partial x}\right)}^2\right]dx$$

Theorem: For wave equation with fixed BCs, $E(t)=E(0)$ (constant).

Proof sketch: $\frac{dE}{dt}=0$ using PDE and integration by parts.

Physical meaning: No energy dissipation (ideal string). Real strings have damping → telegraph equation.

Limitations

⚠️ Symbolic coefficients only (same as heat equation)

⚠️ Damped waves NOT supported: Telegraph equation $u_{tt}+2\alpha u_t=c^2{u}_{xx}$ requires different solver.

⚠️ Forcing terms NOT supported: $u_{tt}=c^2{u}_{xx}+F(x,t)$ requires inhomogeneous solution methods.

Examples

Vibrating Guitar String

A 0.65m guitar string plucked at center with 5mm displacement, demonstrating wave propagation and standing waves.

#![allow(unused)]
fn main() {
use mathhook::prelude::*;

// Variables
let u = symbol!(u);
let x = symbol!(x);
let t = symbol!(t);

// PDE
let equation = expr!(u);
let pde = Pde::new(equation, u, vec![x.clone(), t.clone()]);

// Wave speed
let c = expr!(442);  // m/s for steel E string

// Boundary conditions
let bc1 = BoundaryCondition::dirichlet(
    expr!(0),
    BoundaryLocation::Simple {
        variable: x.clone(),
        value: expr!(0),
    },
);
let bc2 = BoundaryCondition::dirichlet(
    expr!(0),
    BoundaryLocation::Simple {
        variable: x,
        value: expr!(0.65),  // L = 0.65 m
    },
);

// Initial conditions
let ic_position = InitialCondition::value(
    // Triangular function (symbolic - not yet computable)
    expr!(0.005)  // Placeholder for triangular shape
);
let ic_velocity = InitialCondition::derivative(expr!(0));  // Released from rest

// Solve
let solver = WaveEquationSolver::new();
let result = solver.solve_wave_equation_1d(
    &pde,
    &c,
    &[bc1, bc2],
    &ic_position,
    &ic_velocity
)?;

// What you get:
println!("Solution: {}", result.solution);
// u(x,t) = [A_1*cos(ω₁*t) + B_1*sin(ω₁*t)]*sin(π*x/L) + ...

println!("Eigenvalues: {:?}", result.eigenvalues);
// [λ₁, λ₂, λ₃, ...] where λₙ = (nπ/L)²

println!("Position coefficients (A_n): {:?}", result.position_coefficients);
println!("Velocity coefficients (B_n): {:?}", result.velocity_coefficients);

}

from mathhook import symbol, expr, Pde, BoundaryCondition, BoundaryLocation, InitialCondition, WaveEquationSolver

# Variables
u = symbol('u')
x = symbol('x')
t = symbol('t')

# PDE
equation = expr(u)
pde = Pde(equation, u, [x, t])

# Wave speed
c = expr(442)

# Boundary conditions
bc1 = BoundaryCondition.dirichlet(
    expr(0),
    BoundaryLocation.simple(variable=x, value=expr(0))
)
bc2 = BoundaryCondition.dirichlet(
    expr(0),
    BoundaryLocation.simple(variable=x, value=expr(0.65))
)

# Initial conditions
ic_position = InitialCondition.value(expr(0.005))
ic_velocity = InitialCondition.derivative(expr(0))

# Solve
solver = WaveEquationSolver()
result = solver.solve_wave_equation_1d(pde, c, [bc1, bc2], ic_position, ic_velocity)

print(f"Solution: {result.solution}")
print(f"Eigenvalues: {result.eigenvalues}")

const { symbol, expr, Pde, BoundaryCondition, BoundaryLocation, InitialCondition, WaveEquationSolver } = require('mathhook');

// Variables
const u = symbol('u');
const x = symbol('x');
const t = symbol('t');

// PDE
const equation = expr(u);
const pde = new Pde(equation, u, [x, t]);

// Wave speed
const c = expr(442);

// Boundary conditions
const bc1 = BoundaryCondition.dirichlet(
    expr(0),
    BoundaryLocation.simple({ variable: x, value: expr(0) })
);
const bc2 = BoundaryCondition.dirichlet(
    expr(0),
    BoundaryLocation.simple({ variable: x, value: expr(0.65) })
);

// Initial conditions
const icPosition = InitialCondition.value(expr(0.005));
const icVelocity = InitialCondition.derivative(expr(0));

// Solve
const solver = new WaveEquationSolver();
const result = solver.solveWaveEquation1d(pde, c, [bc1, bc2], icPosition, icVelocity);

console.log(`Solution: ${result.solution}`);
console.log(`Eigenvalues: ${result.eigenvalues}`);

Performance

Time Complexity: O(n) for n Fourier modes

API Reference

• Rust: mathhook_core::pde::WaveEquationSolver
• Python: mathhook.pde.wave_equation_solver
• JavaScript: mathhook.pde.waveEquationSolver

See Also

• advanced.pde.heat_equation

• advanced.pde.laplace_equation

• advanced.pde.separation_of_variables

• advanced.pde.examples