Editing Equations, Formulas and Algorithms (section)

=== Integral Equations ===

==== Numerical Integration ====
Numerical integration methods approximate the integral of a function over a specified interval. Common numerical integration techniques include the trapezoidal rule, Simpson's rule, and Gaussian quadrature. These methods are used to compute integrals in situations where analytical solutions are not feasible.

'''Example: Trapezoidal Rule'''
The trapezoidal rule approximates the integral of a function <math> f(x) </math> over the interval <math>[a, b]</math> as follows:
<math mode="display"> \int_{a}^{b} f(x) \, dx \approx \frac{h}{2} \left( f(a) + 2\sum_{i=1}^{n-1} f(x_i) + f(b) \right) </math>
where <math> h = \frac{b - a}{n} </math> is the width of each subinterval and <math> x_i = a + ih </math> are the points at which the function is evaluated.

'''Source Code Example (Python):'''
<syntaxhighlight lang="python">
def trapezoidal_rule(f, a, b, n):
    h = (b - a) / n
    sum_val = 0.5 * (f(a) + f(b))
    for i in range(1, n):
        sum_val += f(a + i * h)
    return h * sum_val

# Example usage:
def func(x):
    return x**2

result = trapezoidal_rule(func, 0, 1, 100)
print("Approximated integral using Trapezoidal Rule:", result)
</syntaxhighlight>

==== Fredholm Integral Equation Solvers ====
Fredholm integral equations of the second kind are solved using numerical approximation methods, iterative techniques, and spectral methods. These algorithms are employed to solve integral equations that arise in various areas, including physics, engineering, and mathematical modeling.

'''Example: Fredholm Integral Equation'''
The Fredholm integral equation of the second kind is given by:
<math mode="display"> \phi(x) = f(x) + \lambda \int_{a}^{b} K(x, s) \phi(s) \, ds </math>
where <math> \phi(x) </math> is the unknown function to be solved for, <math> f(x) </math> is a given function, <math> K(x, s) </math> is the kernel function, and <math> \lambda </math> is a parameter.

'''Source Code Example (Matlab):'''
<syntaxhighlight lang="matlab">
% Example of solving Fredholm integral equation using iterative method
a = 0; b = 1; % Define integration limits
lambda = 0.5; % Define parameter lambda

% Define kernel function
K = @(x, s) exp(x + s);

% Define function f(x)
f = @(x) x^2;

% Define initial guess for phi(x)
phi0 = @(x) 0;

% Define number of iterations
iterations = 100;

% Iterative method
phi = phi0;
for i = 1:iterations
    phi_new = @(x) f(x) + lambda * integral(@(s) K(x, s) * phi(s), a, b);
    phi = phi_new;
end

% Display result
disp('Approximated solution for phi(x):');
disp(phi(0.5));
</syntaxhighlight>

==== Volterra Integral Equation Solvers ====
Similar to Fredholm equations, algorithms for solving Volterra integral equations involve numerical approximation methods and spectral techniques. These algorithms are applied in diverse fields, such as biology, economics, and control theory, to model dynamic systems and processes.

'''Example: Volterra Integral Equation'''
The Volterra integral equation of the second kind is given by: <math> \phi(x) = f(x) + \lambda \int_{a}^{x} K(x, s) \phi(s) \, ds </math> where <math> \phi(x) </math> is the unknown function to be solved for, <math> f(x) </math> is a given function, <math> K(x, s) </math> is the kernel function, and <math> \lambda </math> is a parameter.

'''Source Code Example (Julia):'''
<syntaxhighlight lang="julia">
# Example of solving Volterra integral equation using iterative method
a = 0; b = 1; # Define integration limits
lambda = 0.5; # Define parameter lambda

# Define kernel function
function K(x, s)
    return exp(x + s)
end

# Define function f(x)
function f(x)
    return x^2
end

# Define initial guess for phi(x)
function phi0(x)
    return 0
end

# Define number of iterations
iterations = 100

# Iterative method
phi = phi0
for i = 1:iterations
    phi_new(x) = f(x) + lambda * quadgk(s -> K(x, s) * phi(s), a, x)[1]
    phi = phi_new
end

# Display result
println("Approximated solution for phi(x): ", phi(0.5))
</syntaxhighlight>