mirror of
https://github.com/TheAlgorithms/Python.git
synced 2024-11-23 21:11:08 +00:00
a8b6bda993
* Remove eval from arithmetic_analysis/newton_raphson.py
* Relocate contents of arithmetic_analysis/
Delete the arithmetic_analysis/ directory and relocate its files because
the purpose of the directory was always ill-defined. "Arithmetic
analysis" isn't a field of math, and the directory's files contained
algorithms for linear algebra, numerical analysis, and physics.
Relocated the directory's linear algebra algorithms to linear_algebra/,
its numerical analysis algorithms to a new subdirectory called
maths/numerical_analysis/, and its single physics algorithm to physics/.
* updating DIRECTORY.md
---------
Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
87 lines
2.2 KiB
Python
87 lines
2.2 KiB
Python
"""
|
|
Numerical integration or quadrature for a smooth function f with known values at x_i
|
|
|
|
This method is the classical approach of summing 'Equally Spaced Abscissas'
|
|
|
|
method 2:
|
|
"Simpson Rule"
|
|
|
|
"""
|
|
|
|
|
|
def method_2(boundary: list[int], steps: int) -> float:
|
|
# "Simpson Rule"
|
|
# int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
|
|
"""
|
|
Calculate the definite integral of a function using Simpson's Rule.
|
|
:param boundary: A list containing the lower and upper bounds of integration.
|
|
:param steps: The number of steps or resolution for the integration.
|
|
:return: The approximate integral value.
|
|
|
|
>>> round(method_2([0, 2, 4], 10), 10)
|
|
2.6666666667
|
|
>>> round(method_2([2, 0], 10), 10)
|
|
-0.2666666667
|
|
>>> round(method_2([-2, -1], 10), 10)
|
|
2.172
|
|
>>> round(method_2([0, 1], 10), 10)
|
|
0.3333333333
|
|
>>> round(method_2([0, 2], 10), 10)
|
|
2.6666666667
|
|
>>> round(method_2([0, 2], 100), 10)
|
|
2.5621226667
|
|
>>> round(method_2([0, 1], 1000), 10)
|
|
0.3320026653
|
|
>>> round(method_2([0, 2], 0), 10)
|
|
Traceback (most recent call last):
|
|
...
|
|
ZeroDivisionError: Number of steps must be greater than zero
|
|
>>> round(method_2([0, 2], -10), 10)
|
|
Traceback (most recent call last):
|
|
...
|
|
ZeroDivisionError: Number of steps must be greater than zero
|
|
"""
|
|
if steps <= 0:
|
|
raise ZeroDivisionError("Number of steps must be greater than zero")
|
|
|
|
h = (boundary[1] - boundary[0]) / steps
|
|
a = boundary[0]
|
|
b = boundary[1]
|
|
x_i = make_points(a, b, h)
|
|
y = 0.0
|
|
y += (h / 3.0) * f(a)
|
|
cnt = 2
|
|
for i in x_i:
|
|
y += (h / 3) * (4 - 2 * (cnt % 2)) * f(i)
|
|
cnt += 1
|
|
y += (h / 3.0) * f(b)
|
|
return y
|
|
|
|
|
|
def make_points(a, b, h):
|
|
x = a + h
|
|
while x < (b - h):
|
|
yield x
|
|
x = x + h
|
|
|
|
|
|
def f(x): # enter your function here
|
|
y = (x - 0) * (x - 0)
|
|
return y
|
|
|
|
|
|
def main():
|
|
a = 0.0 # Lower bound of integration
|
|
b = 1.0 # Upper bound of integration
|
|
steps = 10.0 # number of steps or resolution
|
|
boundary = [a, b] # boundary of integration
|
|
y = method_2(boundary, steps)
|
|
print(f"y = {y}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import doctest
|
|
|
|
doctest.testmod()
|
|
main()
|