Editing Equations, Formulas and Algorithms (section)

= Differential Equations =

== Finite Difference Methods ==
Finite difference methods discretize differential equations by approximating derivatives using finite differences. These methods are widely used for solving ordinary and partial differential equations in various domains, including fluid dynamics, heat transfer, and structural mechanics.

'''Example: Finite Difference Method'''
Consider the one-dimensional heat equation:
<math mode="display"> \frac{\partial u}{\partial t} = \alpha \frac{\partial^2 u}{\partial x^2} </math>
where <math> u(x, t) </math> is the temperature distribution, <math> \alpha </math> is the thermal diffusivity, <math> x </math> is the spatial coordinate, and <math> t </math> is time.

'''Source Code Example (C++):'''
<syntaxhighlight lang="c++">
#include <iostream>
#include <vector>

// Function to solve the heat equation using the finite difference method
std::vector<double> solve_heat_equation(int nx, int nt, double alpha) {
    double dx = 1.0 / (nx - 1);
    double dt = 0.01;
    double r = alpha * dt / (dx * dx);

    // Initialize temperature distribution
    std::vector<double> u(nx);
    for (int i = 0; i < nx; ++i) {
        u[i] = 0.0; // Initial condition: u(x,0) = 0
    }

    // Apply finite difference method
    for (int t = 0; t < nt; ++t) {
        std::vector<double> u_new(nx);
        for (int i = 1; i < nx - 1; ++i) {
            u_new[i] = u[i] + r * (u[i+1] - 2 * u[i] + u[i-1]);
        }
        u = u_new;
    }

    return u;
}

// Example usage
int main() {
    int nx = 101; // Number of spatial points
    int nt = 1000; // Number of time steps
    double alpha = 0.01; // Thermal diffusivity

    std::vector<double> temperature = solve_heat_equation(nx, nt, alpha);

    // Print temperature distribution
    for (int i = 0; i < nx; ++i) {
        std::cout << "Temperature at x=" << i / double(nx-1) << ": " << temperature[i] << std::endl;
    }

    return 0;
}
</syntaxhighlight>

== Finite Element Methods (FEM) ==
Finite element methods divide the domain of a differential equation into smaller elements, allowing for the approximation of the solution within each element. FEM is employed in structural analysis, electromagnetics, and other fields to solve partial differential equations and boundary value problems.

'''Example: Finite Element Method'''
Consider the one-dimensional Poisson equation:
<math mode="display"> -\frac{d^2 u}{dx^2} = f(x) </math>
where <math> u(x) </math> is the unknown function to be solved for and <math> f(x) </math> is a given function.

'''Source Code Example (Python with FEniCS):'''
<syntaxhighlight lang="python">
from fenics import *

# Define mesh
mesh = IntervalMesh(100, 0, 1)

# Define function space
V = FunctionSpace(mesh, 'CG', 1)

# Define boundary conditions
u_L = Constant(0.0)
u_R = Constant(1.0)
bc_L = DirichletBC(V, u_L, 'on_boundary && near(x[0], 0)')
bc_R = DirichletBC(V, u_R, 'on_boundary && near(x[0], 1)')
bcs = [bc_L, bc_R]

# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
f = Constant(1.0)
a = inner(grad(u), grad(v)) * dx
L = f * v * dx

# Solve variational problem
u = Function(V)
solve(a == L, u, bcs)

# Plot solution
plot(u)
plt.show()
</syntaxhighlight>

== Finite Volume Methods (FVM) ==
Finite volume methods discretize differential equations by integrating them over control volumes. FVM is commonly used in computational fluid dynamics and heat transfer simulations to solve conservation equations governing fluid flow and heat transfer phenomena.

'''Example: Finite Volume Method'''
Consider the one-dimensional advection equation:
<math mode="display"> \frac{\partial u}{\partial t} + c \frac{\partial u}{\partial x} = 0 </math>
where <math> u(x, t) </math> is the quantity being advected, <math> c </math> is the advection velocity, <math> x </math> is the spatial coordinate, and <math> t </math> is time.

'''Source Code Example (Python with FEniCS):'''
<syntaxhighlight lang="python">
# Define mesh
mesh = IntervalMesh(100, 0, 1)

# Define function space
V = FunctionSpace(mesh, 'CG', 1)

# Define initial condition
u0 = Expression('sin(pi*x[0])', degree=2)

# Define advection velocity
c = Constant(1.0)

# Define boundary conditions (if any)

# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
F = (u - u0) * v * dx + dt * c * dot(grad(u), grad(v)) * dx

# Time-stepping
t = 0
T = 1
dt = 0.01
while t < T:
    solve(F == 0, u)
    u0.assign(u)
    t += dt

# Plot solution
plot(u)
plt.show()
</syntaxhighlight>

== Boundary Element Methods (BEM) ==
Boundary element methods reduce differential equations to integral equations over the boundary of the domain. BEM is useful for problems with infinite domains or complex geometries, such as acoustic and electromagnetic scattering problems.

'''Example: Boundary Element Method'''
Consider the Laplace equation in two dimensions:
<math mode="display"> \nabla^2 u = 0 </math>
where <math> u(x, y) </math> is the unknown function to be solved for.

'''Source Code Example (MATLAB with BEM++):'''
<syntaxhighlight lang="matlab">
% Define boundary conditions
% For simplicity, let's consider Dirichlet boundary conditions.

% Define geometry and boundary elements
radius = 1;
num_elements = 50;
theta = linspace(0, 2*pi, num_elements+1);
theta = theta(1:end-1);
boundary_points = [radius * cos(theta); radius * sin(theta)];

% Solve Laplace's equation analytically for demonstration
analytical_solution = @(r, theta) r.^2 .* sin(2*theta);
boundary_solution = analytical_solution(radius, theta);

% Plot analytical solution and boundary points
figure;
plot(theta, boundary_solution, 'r-', 'LineWidth', 2);
hold on;
scatter(theta, zeros(size(theta)), 'k', 'filled');
title('Analytical Solution for Laplace''s Equation (Circular Domain)');
xlabel('\theta');
ylabel('Solution');
legend('Analytical Solution', 'Boundary Points');
grid on;
hold off;
</syntaxhighlight>

== Spectral Methods ==
Spectral methods approximate the solution of differential equations using expansions in terms of basis functions, such as Fourier series or Chebyshev polynomials. These methods offer high accuracy and convergence rates and are used in various scientific and engineering applications.

'''Example: Spectral Method'''
Consider the one-dimensional wave equation:
<math mode="display"> \frac{\partial^2 u}{\partial t^2} = c^2 \frac{\partial^2 u}{\partial x^2} </math>
where <math> u(x, t) </math> is the displacement of a vibrating string, <math> c </math> is the wave speed, <math> x </math> is the spatial coordinate, and <math> t </math> is time.

'''Source Code Example (MATLAB with Chebfun):'''
<syntaxhighlight lang="matlab">
% Define domain and initial conditions
domain = [-1, 1]; % Define the spatial domain
initial_condition = chebfun(@(x) exp(-20*x.^2), domain); % Define initial condition

% Define Chebfun objects for functions and derivatives
c = 1; % Wave speed
wave_equation = @(t, u) -c^2 * diff(u, 2); % Define the wave equation
t_span = [0, 1]; % Time span for simulation

% Solve the wave equation using Chebfun's time-stepping capabilities
u = pdepe(0, wave_equation, initial_condition, @(x, t) 0, domain, t_span);

% Plot solution
figure;
plot(u(end, :));
title('Solution of the One-dimensional Wave Equation');
xlabel('Spatial Domain');
ylabel('Solution');
</syntaxhighlight>

== Runge-Kutta Methods ==
Runge-Kutta methods are numerical techniques for solving ordinary differential equations. They involve iterative procedures to approximate the solution trajectory of the differential equation over a specified time interval. Runge-Kutta methods are widely used in numerical simulations and scientific computing.

'''Example: Runge-Kutta Method'''
Consider the following ordinary differential equation:
<math mode="display"> \frac{dy}{dt} = f(t, y) </math>
where <math> y(t) </math> is the solution and <math> f(t, y) </math> is the derivative function.

'''Source Code Example (Python):'''
<syntaxhighlight lang="python">
import numpy as np

# Define derivative function
def f(t, y):
    return -y

# Define initial conditions
y0 = 1
t0 = 0
t_end = 10
dt = 0.1

# Initialize arrays to store solution
t_values = [t0]
y_values = [y0]

# Runge-Kutta integration loop
while t_values[-1] < t_end:
    t = t_values[-1]
    y = y_values[-1]
    k1 = f(t, y)
    k2 = f(t + dt/2, y + dt/2 * k1)
    k3 = f(t + dt/2, y + dt/2 * k2)
    k4 = f(t + dt, y + dt * k3)
    y_new = y + dt / 6 * (k1 + 2*k2 + 2*k3 + k4)
    t_values.append(t + dt)
    y_values.append(y_new)

# Plot solution
import matplotlib.pyplot as plt
plt.plot(t_values, y_values)
plt.xlabel('Time')
plt.ylabel('Solution')
plt.title('Runge-Kutta Method')
plt.show()
</syntaxhighlight>

== Adaptive Methods ==
Adaptive algorithms adjust the step size or mesh resolution dynamically based on solution properties to achieve a desired level of accuracy. These methods are employed to solve differential equations efficiently while minimizing computational cost and resource usage.

'''Example: Adaptive Method'''
Consider the following ordinary differential equation:
<math mode="display"> \frac{dy}{dt} = f(t, y) </math>
where <math> y(t) </math> is the solution and <math> f(t, y) </math> is the derivative function.

'''Source Code Example (Python with SciPy):'''
<syntaxhighlight lang="python">
from scipy.integrate import solve_ivp

# Define derivative function
def f(t, y):
    return -y

# Define initial conditions
y0 = 1
t_span = (0, 10)

# Solve differential equation using adaptive method
sol = solve_ivp(f, t_span, [y0], method='RK45')

# Plot solution
import matplotlib.pyplot as plt
plt.plot(sol.t, sol.y[0])
plt.xlabel('Time')
plt.ylabel('Solution')
plt.title('Adaptive Method')
plt.show()
</syntaxhighlight>