B15
Use Theorem 2.1 to find a bound for the number of iterations needed to achieve an
approximation with accuracy 10−4 to the solution of x3 −x−1 = 0 lying in the interval [1, 2].
Find an approximation to the root with this degree of accuracy
1. Given values:
• 𝑎=1a=1
• 𝑏=2b=2
• 𝜖=10−4ϵ=10−4
2. Using the formula:
𝑛≥log(2−1)−log(10−4)log(2)=log(1)−log(10−4)log(2)n
≥log(2)log(2−1)−log(10−4)=log(2)log(1)−log(10−4)
Since log(1)=0log(1)=0, the formula simplifies to:
𝑛≥−log(10−4)log(2)=log(104)log(2)=4log(10)log(2)n≥l
og(2)−log(10−4)=log(2)log(104)=log(2)4log(10)
3. Substitute values:
• log(10)≈2.302585log(10)≈2.302585
• log(2)≈0.693147log(2)≈0.693147
4. Calculate:
𝑛≥4×2.3025850.693147≈9.210340.693147≈13.28n≥0.6931474×2.302
585≈0.6931479.21034≈13.28
Therefore, 𝑛≥14n≥14 (rounding up to the nearest whole number).
import math
# Given values
a = 1
b = 2
epsilon = 1e-4
# Calculate the number of iterations
n = math.ceil((math.log(b - a) - math.log(epsilon)) / math.log(2))
print(f"Number of iterations needed: {n}")
def f(x):
return x**3 - x - 1
def bisection_method(a, b, tol):
if f(a) * f(b) > 0:
raise ValueError("Function has the same sign at the ends of the
interval")
while (b - a) / 2 > tol:
midpoint = (a + b) / 2
if f(midpoint) == 0:
return midpoint # Found exact root
elif f(a) * f(midpoint) < 0:
b = midpoint
else:
a = midpoint
return (a + b) / 2
# Initial interval
a = 1
b = 2
tolerance = 1e-4
root = bisection_method(a, b, tolerance)
print(f"Root: {root}")
def f(x):
return x - 2**(-x)
def bisection_method(a, b, tol):
if f(a) * f(b) > 0:
raise ValueError("Function has the same sign at the ends of the
interval")
while (b - a) / 2 > tol:
midpoint = (a + b) / 2
if f(midpoint) == 0:
return midpoint # Found exact root
elif f(a) * f(midpoint) < 0:
b = midpoint
else:
a = midpoint
return (a + b) / 2
# Initial interval
a = 0
b = 1
tolerance = 1e-5
root_high_precision = bisection_method(a, b, tolerance)
print(f"Root: {root_high_precision}")
import math
def f(x):
return math.exp(x) - x**2 + 3*x - 2
def bisection_method(a, b, tol):
if f(a) * f(b) > 0:
raise ValueError("Function has the same sign at the ends of the
interval")
while (b - a) / 2 > tol:
midpoint = (a + b) / 2
if f(midpoint) == 0:
return midpoint # Found exact root
elif f(a) * f(midpoint) < 0:
b = midpoint
else:
a = midpoint
return (a + b) / 2
# Initial interval
a = 0
b = 1
tolerance = 1e-5
root = bisection_method(a, b, tolerance)
print(f"Root: {root}")
import math
def f(x):
return 2 * x * math.cos(2 * x) - (x + 1) ** 2
def bisection_method(a, b, tol):
if f(a) * f(b) > 0:
raise ValueError("Function has the same sign at the ends of the
interval")
while (b - a) / 2 > tol:
midpoint = (a + b) / 2
if f(midpoint) == 0:
return midpoint # Found exact root
elif f(a) * f(midpoint) < 0:
b = midpoint
else:
a = midpoint
return (a + b) / 2
# Intervals
intervals = [(-3, -2), (-1, 0)]
tolerance = 1e-5
roots = []
for a, b in intervals:
root = bisection_method(a, b, tolerance)
roots.append(root)
print(f"Root in interval [{a}, {b}]: {root}")
roots
import math
def f(x):
return x * math.cos(x) - 2 * x**2 + 3 * x - 1
def bisection_method(a, b, tol):
if f(a) * f(b) > 0:
raise ValueError("Function has the same sign at the ends of the
interval")
while (b - a) / 2 > tol:
midpoint = (a + b) / 2
if f(midpoint) == 0:
return midpoint # Found exact root
elif f(a) * f(midpoint) < 0:
b = midpoint
else:
a = midpoint
return (a + b) / 2
# Intervals
intervals = [(0.2, 0.3), (1.2, 1.3)]
tolerance = 1e-5
roots = []
for a, b in intervals:
root = bisection_method(a, b, tolerance)
roots.append(root)
print(f"Root in interval [{a}, {b}]: {root}")
roots
def g(x):
return (3 * x**2 + 3)**0.25
def fixed_point_iteration(p0, tol, max_iter=1000):
p = p0
for i in range(max_iter):
p_next = g(p)
if abs(p_next - p) < tol:
return p_next
p = p_next
return p # Return the last computed value if max iterations are reached
# Initial guess
p0 = 1
tolerance = 1e-2
solution = fixed_point_iteration(p0, tolerance)
print(f"Solution: {solution}")
import math
def g(x):
return (1 / math.pi) * (math.asin((-1 / 2) * x) + 2 * math.pi)
def fixed_point_iteration(p0, tol, max_iter=1000):
p = p0
for i in range(max_iter):
p_next = g(p)
if abs(p_next - p) < tol:
return p_next
p = p_next
return p # Return the last computed value if max iterations are reached
# Initial guess
p0 = 1
tolerance = 1e-2
solution = fixed_point_iteration(p0, tolerance)
print(f"Solution: {solution}")
def f(x):
return x**3 - 2*x**2 - 5
def df(x):
return 3*x**2 - 4*x
def newton_method(x0, tolerance):
while True:
x1 = x0 - f(x0) / df(x0)
if abs(x1 - x0) < tolerance:
return x1
x0 = x1
# Initial guess and tolerance
x0 = 4
tolerance = 1e-4
# Find the root
root = newton_method(x0, tolerance)
print("Root found using Newton's method:", root)
def f(x):
return x**3 + 3*x**2 - 1
def df(x):
return 3*x**2 + 6*x
def newton_method(x0, tolerance):
while True:
x1 = x0 - f(x0) / df(x0)
if abs(x1 - x0) < tolerance:
return x1
x0 = x1
# Initial guess and tolerance
x0 = -3
tolerance = 1e-4
# Find the root
root = newton_method(x0, tolerance)
print("Root found using Newton's method:", root)
import math
def f(x):
return x - math.cos(x)
def df(x):
return 1 + math.sin(x)
def newton_method(x0, tolerance):
while True:
x1 = x0 - f(x0) / df(x0)
if abs(x1 - x0) < tolerance:
return x1
x0 = x1
# Initial guess and tolerance
x0 = math.pi / 4
tolerance = 1e-4
# Find the root
root = newton_method(x0, tolerance)
print("Root found using Newton's method:", root)
import math
def f(x):
return x - 0.8 - 0.2 * math.sin(x)
def df(x):
return 1 - 0.2 * math.cos(x)
def newton_method(x0, tolerance):
while True:
x1 = x0 - f(x0) / df(x0)
if abs(x1 - x0) < tolerance:
return x1
x0 = x1
# Initial guess and tolerance
x0 = math.pi / 4
tolerance = 1e-4
# Find the root
root = newton_method(x0, tolerance)
print("Root found using Newton's method:", root)
math.log(x,base) default la e
import numpy as np
def g_elim(A, b):
n = len(A)
E = np.zeros([n, n+1], dtype=float)
for i in range(n):
E[i, :-1] = A[i, :]
E[i, n] = b[i]
x = np.zeros(n)
for i in range(n):
T = [j for j in E[i:,i] if j !=0]
if len(T) == 0:
print("No unique solution")
return
p = i + list(E[i:,i]).index(T[0])
if p != i:
print("E", p, "<-> E", i)
E[[i, p]] = E[[p, i]]
print(E, "\n")
for j in range(i+1, n):
m = E[j, i]/E[i, i]
print("m=", m)
E[j, :] = E[j, :] - m*E[i, :]
print(E, "\n")
if E[n-1, n-1] == 0:
print("No solution exists")
return
x[n-1] = E[n-1, n]/E[n-1, n-1]
for i in reversed(range(n-1)):
x[i] = (E[i, n] - sum([E[i, j]*x[j] for j in range(i,
n)]))/E[i, i]
print("solution :", x)
##### problem (a) #######
A = np.array([[1, -1, 3], [3, -3, 1], [1, 1, 0]], dtype=float)
b = np.array([[2], [-1], [3]], dtype = float)
g_elim(A, b)
##### problem (b) #######
A = np.array([[2, -1.5, 3], [-1, 0, 2], [4, -4.5, 5]],
dtype=float)
b = np.array([[1], [3], [1]], dtype = float)
g_elim(A, b)
##### problem (c) #######
A = np.array([[2, 0, 0, 0],
[1, 1.5, 0, 0],
[0,-3, 0.5, 0],
[2, -2, 1, 1]], dtype=float)
b = np.array([[3], [4.5], [-6.6], [0.8]], dtype = float)
g_elim(A, b)
##### problem (d) #######
A = np.array([[1, 1, 0, 1],
[2, 1, -1, 1],
[4, -1, -2, 2],
[3, -1, -1, 2]], dtype=float)
b = np.array([[2], [1], [0], [-3]], dtype = float)
g_elim(A, b)
import numpy as np
import re
def rnd(n, k):
if n == 0: return 0
s = re.search(r'.*e([+|-]){1}([0-9]*)',
format(n, "."+ str(k) + "e"))
if s.group(1) == "-": e = -1*int(s.group(2))
else : e = int(s.group(2))
n = n + 5*10**(e - (k+1))
return float(format(n, "."+ str(k-1) + "e"))
def rnd_v(v, k):
return np.array([rnd(j, k) for j in v])
def g_back_subs(A, b):
n = len(A)
E = np.zeros([n, n+1], dtype=float)
for i in range(n):
E[i, :-1] = A[i, :]
E[i, n] = b[i]
x = np.zeros(n)
for i in range(n):
T = [j for j in E[i:,i] if j !=0]
if len(T) == 0:
print("No unique solution")
return
p = i + list(E[i:,i]).index(T[0])
if p != i:
print("E", p, "<-> E", i)
E[[i, p]] = E[[p, i]]
for j in range(i+1, n):
m = rnd(E[j, i]/E[i, i], 2)
print("m=", m)
temp = rnd_v(m*E[i, :], 2)
E[j, :] = rnd_v(E[j, :] - temp, 2)
print(E, "\n")
if E[n-1, n-1] == 0:
print("No solution exists")
return
x[n-1] = rnd(E[n-1, n]/E[n-1, n-1], 2)
for i in reversed(range(n-1)):
temp = [rnd(E[i, j]*x[j], 2) for j in range(i, n)]
temp = rnd(sum(temp), 2)
temp = rnd(E[i, n] - temp, 2)
x[i] = rnd(temp/E[i, i],2)
print(x)
# problem (a)
A = np.array([[4, -1, 1], [2, 5, 2], [1, 2, 4]], dtype=float)
b = np.array([[8], [3], [11]], dtype = float)
g_back_subs(A, b)
# problem (b)
A = np.array([[4, 1, 2], [2, 4, -1], [1, 1, -3]], dtype=float)
b = np.array([[9], [-5], [-9]], dtype = float)
g_back_subs(A, b)
import numpy as np
def doolittle(A, b):
n = len(A)
L = np.zeros((n, n))
U = np.zeros((n, n))
# Step 1: Initialize L as an identity matrix and U as a zero matrix
for i in range(n):
L[i, i] = 1
# Step 2: Fill in the elements of U and L
for j in range(n):
U[j, j] = A[j, j] - np.dot(L[j, :j], U[:j, j])
for i in range(j+1, n):
L[i, j] = (A[i, j] - np.dot(L[i, :j], U[:j, j])) / U[j, j]
for i in range(j, n):
U[j, i] = A[j, i] - np.dot(L[j, :j], U[:j, i])
# Step 3: Solve the system of equations using forward and backward
substitution
y = np.zeros(n)
x = np.zeros(n)
# Forward substitution
for i in range(n):
y[i] = b[i] - np.dot(L[i, :i], y[:i])
# Backward substitution
for i in range(n-1, -1, -1):
x[i] = (y[i] - np.dot(U[i, i+1:], x[i+1:])) / U[i, i]
return x
# Coefficient matrix A
A = np.array([[3, 9, 6],
[18, 48, 39],
[9, -27, 42]])
# Right-hand side vector b
b = np.array([4.6, 27.2, 9.0])
# Solve the system using Doolittle's method
solution = doolittle(A, b)
print("Solution using Doolittle's method:", solution)
import numpy as np
# Define the Gauss-Seidel method
def gauss_seidel(A, b, x0, iterations):
n = len(b)
x = x0.copy()
for _ in range(iterations):
for i in range(n):
sum_ax = sum(A[i][j] * x[j] for j in range(n) if j != i)
x[i] = (b[i] - sum_ax) / A[i][i]
return x
# System of equations
A = np.array([[10, 1, 1],
[1, 10, 1],
[1, 1, 10]])
b = np.array([6, 6, 6])
# Initial guess
x0 = np.array([1, 1, 1], dtype=float)
# Number of iterations
iterations = 5
# Solve using Gauss-Seidel method
solution = gauss_seidel(A, b, x0, iterations)
print(solution
import numpy as np
# Define the Gauss-Seidel method with 6 significant figures
def gauss_seidel_6s(A, b, x0, iterations):
n = len(b)
x = x0.copy()
for _ in range(iterations):
for i in range(n):
sum_ax = sum(A[i][j] * x[j] for j in range(n) if j != i)
x[i] = round((b[i] - sum_ax) / A[i][i], 6)
return x
# System of equations
A = np.array([[10, 1, 1],
[1, 10, 1],
[1, 1, 10]])
b = np.array([6, 6, 6])
# Initial guess
x0 = np.array([1, 1, 1], dtype=float)
# Number of iterations
iterations = 5
# Solve using Gauss-Seidel method with 6 significant figures
solution_6s = gauss_seidel_6s(A, b, x0, iterations)
print(solution_6s)
import numpy as np
# Define the Jacobi method with 6 significant figures
def jacobi_6s(A, b, x0, iterations):
n = len(b)
x = x0.copy()
x_new = np.zeros_like(x)
for _ in range(iterations):
for i in range(n):
sum_ax = sum(A[i][j] * x[j] for j in range(n) if j != i)
x_new[i] = round((b[i] - sum_ax) / A[i][i], 6)
x = x_new.copy()
return x
# System of equations
A = np.array([[5, 1, 2],
[1, 4, -2],
[2, 3, 8]])
b = np.array([19, -2, 39])
# Initial guess
x0 = np.array([1, 1, 1], dtype=float)
# Number of iterations
iterations = 5
# Solve using Jacobi method with 6 significant figures
solution_6s = jacobi_6s(A, b, x0, iterations)
print(solution_6s)
import numpy as np
def lagrange_interpolating_polynomial(x_values, y_values, x):
n = len(x_values)
result = 0
for i in range(n):
term = y_values[i]
for j in range(n):
if j != i:
term *= (x - x_values[j]) / (x_values[i] - x_values[j])
result += term
return result
# Given data points
x_values = np.array([8.1, 8.3, 8.6, 8.7])
y_values = np.array([16.94410, 17.56492, 18.50515, 18.82091])
# Value to interpolate
x = 8.4
# Degree 1 interpolation
x_values_deg1 = x_values[:2]
y_values_deg1 = y_values[:2]
f_approx_deg1 = lagrange_interpolating_polynomial(x_values_deg1,
y_values_deg1, x)
# Degree 2 interpolation
x_values_deg2 = x_values[:3]
y_values_deg2 = y_values[:3]
f_approx_deg2 = lagrange_interpolating_polynomial(x_values_deg2,
y_values_deg2, x)
# Degree 3 interpolation
f_approx_deg3 = lagrange_interpolating_polynomial(x_values, y_values, x)
f_approx_deg1, f_approx_deg2, f_approx_deg3
b. f −1 3 if f (−0.75) = −0.07181250, f (−0.5) = −0.02475000, f (−0.25) = 0.33493750, f (0) =
1.10100000
c. f (0.25) if f (0.1) = 0.62049958, f (0.2) = −0.28398668, f (0.3) = 0.00660095, f (0.4) = 0.24842440
d. f (0.9) if f (0.6) = −0.17694460, f (0.7) = 0.01375227, f (0.8) = 0.22363362, f (1.0) = 0.65809197
import numpy as np
# Function to create the backward difference table
def backward_difference_table(x, y):
n = len(x)
diff_table = np.zeros((n, n))
diff_table[:, 0] = y
for j in range(1, n):
for i in range(n-1, j-2, -1):
diff_table[i][j] = diff_table[i][j-1] - diff_table[i-1][j-
1]
return diff_table
# Function to compute the Newton backward polynomial
def newton_backward_polynomial(x, y, x_to_approx, degree):
n = len(x)
diff_table = backward_difference_table(x, y)
h = x[1] - x[0]
u = (x_to_approx - x[-1]) / h
approx_value = y[-1]
u_product = 1
for i in range(1, degree + 1):
u_product *= (u + i - 1) / i
approx_value += u_product * diff_table[-1][i]
return round(approx_value, 6)
# Part a: Approximate f(-1/3)
x_values_a = np.array([-0.75, -0.5, -0.25, 0])
y_values_a = np.array([-0.07181250, -0.02475000, 0.33493750,
1.10100000])
x_to_approx_a = -1/3
# Degree 1 interpolation
approx_a_deg1 = newton_backward_polynomial(x_values_a, y_values_a,
x_to_approx_a, 1)
# Degree 2 interpolation
approx_a_deg2 = newton_backward_polynomial(x_values_a, y_values_a,
x_to_approx_a, 2)
# Degree 3 interpolation
approx_a_deg3 = newton_backward_polynomial(x_values_a, y_values_a,
x_to_approx_a, 3)
# Part b: Approximate f(0.25)
x_values_b = np.array([0.1, 0.2, 0.3, 0.4])
y_values_b = np.array([-0.62049958, -0.28398668, 0.00660095,
0.24842440])
x_to_approx_b = 0.25
# Degree 1 interpolation
approx_b_deg1 = newton_backward_polynomial(x_values_b, y_values_b,
x_to_approx_b, 1)
# Degree 2 interpolation
approx_b_deg2 = newton_backward_polynomial(x_values_b, y_values_b,
x_to_approx_b, 2)
# Degree 3 interpolation
approx_b_deg3 = newton_backward_polynomial(x_values_b, y_values_b,
x_to_approx_b, 3)
approx_a_deg1, approx_a_deg2, approx_a_deg3, approx_b_deg1,
approx_b_deg2, approx_b_deg3
import numpy as np
import matplotlib.pyplot as plt
# Given data
xi = np.array([4.0, 4.2, 4.5, 4.7, 5.1, 5.5, 5.9, 6.3, 6.8, 7.1])
yi = np.array([102.56, 113.18, 130.11, 142.05, 167.53, 195.14, 224.87,
256.73, 299.50, 326.72])
# Fit a polynomial of degree 1
coefficients = np.polyfit(xi, yi, 1)
# Compute the fitted values
yi_fit = np.polyval(coefficients, xi)
# Calculate the Sum of Squared Errors (SSE)
sse = np.sum((yi - yi_fit) ** 2)
print("Sum of Squared Errors:", sse)
# Plot the data and the fitted line
plt.scatter(xi, yi, color='blue', label='Data points')
plt.plot(xi, yi_fit, color='red', label='Fitted line')
plt.xlabel('xi')
plt.ylabel('yi')
plt.legend()
plt.title(f"Linear Fit: y = {coefficients[0]:.2f}x +
{coefficients[1]:.2f}\nSSE: {sse:.2f}")
plt.show()
B15 xem trong giải
import numpy as np
import matplotlib.pyplot as plt
# Given data
xi = np.array([4.0, 4.2, 4.5, 4.7, 5.1, 5.5, 5.9, 6.3, 6.8, 7.1])
yi = np.array([102.56, 113.18, 130.11, 142.05, 167.53, 195.14, 224.87,
256.73, 299.50, 326.72])
# Fit a polynomial of degree 2
coefficients_deg2 = np.polyfit(xi, yi, 2)
yi_fit_deg2 = np.polyval(coefficients_deg2, xi)
sse_deg2 = np.sum((yi - yi_fit_deg2) ** 2)
print("Degree 2 coefficients:", coefficients_deg2)
print("Degree 2 SSE:", sse_deg2)
# Fit a polynomial of degree 3
coefficients_deg3 = np.polyfit(xi, yi, 3)
yi_fit_deg3 = np.polyval(coefficients_deg3, xi)
sse_deg3 = np.sum((yi - yi_fit_deg3) ** 2)
print("Degree 3 coefficients:", coefficients_deg3)
print("Degree 3 SSE:", sse_deg3)
# Plotting the data and the fitted lines
plt.scatter(xi, yi, color='blue', label='Data points')
# Plot the polynomial fits
plt.plot(xi, yi_fit_deg2, color='green', label='Degree 2 fit')
plt.plot(xi, yi_fit_deg3, color='purple', label='Degree 3 fit')
plt.xlabel('xi')
plt.ylabel('yi')
plt.legend()
plt.title('Least Squares Polynomial Fits')
plt.show()
import numpy as np
from scipy.stats import linregress
# Given data
xi = np.array([4.0, 4.2, 4.5, 4.7, 5.1, 5.5, 5.9, 6.3, 6.8, 7.1])
yi = np.array([102.56, 113.18, 130.11, 142.05, 167.53, 195.14, 224.87,
256.73, 299.50, 326.72])
# Calculate natural logarithm of yi
Y = np.log(yi)
# Perform linear regression
slope, intercept, _, _, _ = linregress(xi, Y)
# Compute a and b
a = slope
B = intercept
b = np.exp(B)
# Compute least squares approximation
def least_squares(x):
return b * np.exp(a * x)
# Compute the error
error = np.sum((yi - least_squares(xi)) ** 2)
print("a:", a)
print("b:", b)
print("Error:", error)
import numpy as np
from scipy.stats import linregress
# Given data
xi = np.array([4.0, 4.2, 4.5, 4.7, 5.1, 5.5, 5.9, 6.3, 6.8, 7.1])
yi = np.array([102.56, 113.18, 130.11, 142.05, 167.53, 195.14, 224.87,
256.73, 299.50, 326.72])
# Calculate logarithm of xi and yi
log_xi = np.log10(xi)
log_yi = np.log10(yi)
# Perform linear regression
slope, intercept, _, _, _ = linregress(log_xi, log_yi)
# Compute a and b
a = slope
B = intercept
b = 10 ** B
# Compute least squares approximation
def least_squares(x):
return b * (x ** a)
# Compute the error
error = np.sum((yi - least_squares(xi)) ** 2)
print("a:", a)
print("b:", b)
print("Error:", error)
def three_point_endpoint_formula(f_x0, f_x1, f_x2, h):
return (1 / (2 * h)) * (-3 * f_x0 + 4 * f_x1 - f_x2)
def three_point_midpoint_formula(f_x_minus_h, f_x, f_x_plus_h, h):
return (1 / (2 * h)) * (f_x_plus_h - f_x_minus_h) - (h**2 / 6) *
(f_x_plus_h - 2*f_x + f_x_minus_h)
# Given data
x_values = [1.1, 1.2, 1.3, 1.4]
f_values = [9.025013, 11.02318, 13.46374, 16.44465]
h = x_values[1] - x_values[0] # Assuming equally spaced points
# Calculate f'(1.4) using the three-point endpoint formula
f_prime_1_4 = three_point_endpoint_formula(f_values[0], f_values[1],
f_values[2], h)
# Calculate the missing entry at x = 1.4
missing_value_1_4_endpoint = three_point_endpoint_formula(f_values[3],
f_values[2], f_values[1], -h)
# Calculate the missing entries using the three-point midpoint formula
missing_value_1_2_midpoint = three_point_midpoint_formula(f_values[0],
f_values[1], f_values[2], h)
missing_value_1_3_midpoint = three_point_midpoint_formula(f_values[1],
f_values[2], f_values[3], h)
# Print the missing values
print(f"The missing value at x = 1.1 (Endpoint Formula) is
approximately: {f_prime_1_4}")
print(f"The missing value at x = 1.4 (Endpoint Formula) is
approximately: {missing_value_1_4_endpoint}")
print(f"The missing value at x = 1.2 (Midpoint Formula) is
approximately: {missing_value_1_2_midpoint}")
print(f"The missing value at x = 1.3 (Midpoint Formula) is
approximately: {missing_value_1_3_midpoint}")
from scipy.integrate import simps
# Define the integrand function
def integrand(x):
return x**4
# Define the integration limits
lower_limit = 0.5
upper_limit = 1
# Define the sample points
sample_points = [lower_limit, (lower_limit + upper_limit) / 2,
upper_limit]
# Compute the integral using Simpson's rule
result = simps([integrand(x) for x in sample_points], sample_points)
# Print the result
print("The approximate value of the integral using Simpson's rule is:",
result)
# Define the function to approximate the integral using the Trapezoidal rule
def trapezoidal_rule(f, a, b, n):
"""
Approximates the integral of f(x) from a to b using the Trapezoidal rule with n subintervals.
"""
# Calculate the width of each subinterval
h = (b - a) / n
# Initialize the sum
integral_sum = 0
# Compute the sum of the function values at the endpoints and the midpoint of each
subinterval
for i in range(n):
x0 = a + i * h
x1 = a + (i + 1) * h
integral_sum += (f(x0) + f(x1)) / 2 * h
return integral_sum
# Define the integrand function
def integrand(x):
return x**4
# Define the integration limits
lower_limit = 0.5
upper_limit = 1
# Define the number of subintervals
num_subintervals = 1000
# Approximate the integral using the Trapezoidal rule
result = trapezoidal_rule(integrand, lower_limit, upper_limit, num_subintervals)
# Print the result
print("The approximate value of the integral using the Trapezoidal rule is:", result)
# Define the function to approximate the integral using the Midpoint
rule
def midpoint_rule(f, a, b, n):
"""
Approximates the integral of f(x) from a to b using the Midpoint
rule with n subintervals.
"""
# Calculate the width of each subinterval
h = (b - a) / n
# Initialize the sum
integral_sum = 0
# Compute the sum of the function values at the midpoints of each
subinterval
for i in range(n):
midpoint = a + (i + 0.5) * h
integral_sum += f(midpoint) * h
return integral_sum
# Define the integrand function
def integrand(x):
return x**4
# Define the integration limits
lower_limit = 0.5
upper_limit = 1
# Define the number of subintervals
num_subintervals = 1000
# Approximate the integral using the Midpoint rule
result = midpoint_rule(integrand, lower_limit, upper_limit,
num_subintervals)
# Print the result
print("The approximate value of the integral using the Midpoint rule
is:", result)
from scipy.misc import derivative
# Define the integrand function
def integrand(x):
return x**4
# Define the integration limits
a = 0.5
b = 1
# Calculate the maximum value of the fourth derivative of the integrand
function
M = max(abs(derivative(integrand, a, n=4)), abs(derivative(integrand,
b, n=4)))
# Define the number of subintervals
n = 10 # Adjust the number of subintervals as needed
# Calculate the bound error for Simpson's rule
error_bound = ((b - a)**5 / (180 * n**4)) * M
# Print the result
print("The bound error for Simpson's rule is:", error_bound)
import numpy as np
# Define the quadrature formula
def quadrature_formula(f):
return f(-np.sqrt(3)/3) + f(np.sqrt(3)/3)
# Define a function to test the quadrature formula
def test_quadrature_formula(deg):
# Define a polynomial function of degree deg
def poly(x):
return x**deg
# Evaluate the integral of the polynomial function using the
quadrature formula
integral_approximation = quadrature_formula(poly)
# Compute the exact integral of the polynomial function
exact_integral = 2 / (deg + 1)
# Compute the error
error = abs(integral_approximation - exact_integral)
return error
# Test the quadrature formula with polynomials of degrees 0 to 5
for deg in range(6):
error = test_quadrature_formula(deg)
print(f"Degree {deg} polynomial: Error = {error}")
def euler_method(f, a, b, y0, h):
"""
Approximates the solution of the initial-value problem y' = f(t,
y), a <= t <= b, y(a) = y0 using Euler's method.
"""
# Initialize lists to store values of t and y
t_values = [a]
y_values = [y0]
# Initialize t and y
t = a
y = y0
# Perform Euler's method
while t < b:
# Update y using Euler's method
y += h * f(t, y)
# Update t
t += h
# Append new values to lists
t_values.append(t)
y_values.append(y)
return t_values, y_values
# Define the differential equation y' = f(t, y)
def f(t, y):
return y / t - (y / t)**2
# Define the initial conditions
a = 1
b = 2
y0 = 1
# Define the step size
h = 0.1
# Use Euler's method to approximate the solution
t_values, y_values = euler_method(f, a, b, y0, h)
# Print the results
print("t values:", t_values)
print("Approximate solution (y values):", y_values)
def taylors_method_order_two(f, df_dt, a, b, y0, h):
"""
Approximates the solution of the initial-value problem y' = f(t,
y), a <= t <= b, y(a) = y0 using Taylor's method of order two.
"""
# Initialize lists to store values of t and y
t_values = [a]
y_values = [y0]
# Initialize t and y
t = a
y = y0
# Perform Taylor's method
while t < b:
# Compute the next value of y using Taylor's method of order
two
y += h * f(t, y) + (h**2 / 2) * df_dt(t, y)
# Update t
t += h
# Append new values to lists
t_values.append(t)
y_values.append(y)
return t_values, y_values
# Define the differential equation y' = f(t, y)
def f(t, y):
return y / t - (y / t)**2
# Define the derivative of the differential equation with respect to t,
df/dt = f_t(t, y)
def f_t(t, y):
return (1 / t) - 2 * (y / t)**2
# Define the initial conditions
a = 1
b = 1.2
y0 = 1
# Define the step size
h = 0.1
# Use Taylor's method of order two to approximate the solution
t_values, y_values = taylors_method_order_two(f, f_t, a, b, y0, h)
# Print the results
print("t values:", t_values)
print("Approximate solution (y values):", y_values)
import sympy as sp
def taylors_method_order_two(f, df_dt, df_dy, a, b, y0, h):
"""
Approximates the solution of the initial-value problem y' = f(t,
y), a <= t <= b, y(a) = y0 using Taylor's method of order two.
"""
# Initialize lists to store values of t and y
t_values = [a]
y_values = [y0]
# Initialize t and y
t = a
y = y0
# Perform Taylor's method
while t < b:
# Compute the next value of y using Taylor's method of order
two
y += h * f(t, y) + (h**2 / 2) * (df_dt(t, y) + df_dy(t, y) *
f(t, y))
# Update t
t += h
# Append new values to lists
t_values.append(t)
y_values.append(y)
return t_values, y_values
# Define the differential equation y' = f(t, y)
t, y = sp.symbols('t y')
f_expr = y / t - (y / t)**2
f = sp.lambdify((t, y), f_expr)
# Tính đạo hàm của f theo t và y
df_dt_expr = sp.diff(f_expr, t)
df_dy_expr = sp.diff(f_expr, y)
df_dt = sp.lambdify((t, y), df_dt_expr)
df_dy = sp.lambdify((t, y), df_dy_expr)
# Define the initial conditions
a = 1
b = 1.2
y0 = 1
# Define the step size
h = 0.1
# Use Taylor's method of order two to approximate the solution
t_values, y_values = taylors_method_order_two(f, df_dt, df_dy, a, b,
y0, h)
# Print the results
print("t values:", t_values)
print("Approximate solution (y values):", y_values)
import sympy as sp
def taylors_method_order_three(f, df_dt, df_dy, d2f_dt2, d2f_dydt,
d2f_dy2, a, b, y0, h):
"""
Approximates the solution of the initial-value problem y' = f(t,
y), a <= t <= b, y(a) = y0 using Taylor's method of order three.
"""
# Initialize lists to store values of t and y
t_values = [a]
y_values = [y0]
# Initialize t and y
t = a
y = y0
# Perform Taylor's method
while t < b:
# Compute the next value of y using Taylor's method of order
three
y += h * f(t, y) + (h**2 / 2) * df_dt(t, y) + (h**3 / 6) *
d2f_dt2(t, y) + (h**3 / 6) * (df_dy(t, y) * f(t, y) + d2f_dydt(t, y) *
df_dt(t, y)) + (h**3 / 6) * d2f_dy2(t, y) * f(t, y)
# Update t
t += h
# Append new values to lists
t_values.append(t)
y_values.append(y)
return t_values, y_values
# Define the differential equation y' = f(t, y)
t, y = sp.symbols('t y')
f_expr = y / t - (y / t)**2
f = sp.lambdify((t, y), f_expr)
# Tính đạo hàm của f theo t và y
df_dt_expr = sp.diff(f_expr, t)
df_dy_expr = sp.diff(f_expr, y)
df_dt = sp.lambdify((t, y), df_dt_expr)
df_dy = sp.lambdify((t, y), df_dy_expr)
# Tính đạo hàm thứ hai của f theo t và y
d2f_dt2_expr = sp.diff(df_dt_expr, t)
d2f_dydt_expr = sp.diff(df_dt_expr, y)
d2f_dy2_expr = sp.diff(df_dy_expr, y)
d2f_dt2 = sp.lambdify((t, y), d2f_dt2_expr)
d2f_dydt = sp.lambdify((t, y), d2f_dydt_expr)
d2f_dy2 = sp.lambdify((t, y), d2f_dy2_expr)
# Define the initial conditions
a = 1
b = 1.2
y0 = 1
# Define the step size
h = 0.1
# Use Taylor's method of order three to approximate the solution
t_values, y_values = taylors_method_order_three(f, df_dt, df_dy,
d2f_dt2, d2f_dydt, d2f_dy2, a, b, y0, h)
# Print the results
print("t values:", t_values)
print("Approximate solution (y values):", y_values)
def modified_euler_method(f, a, b, alpha, h):
"""
Approximates the solution of the initial-value problem y' = f(t,
y), a <= t <= b, y(a) = alpha using Modified Euler's method.
"""
t_values = [a]
w_values = [alpha]
t = a
w = alpha
while t < b:
# Compute the slopes at the current point and the predicted
next point
slope_current = f(t, w)
slope_predicted = f(t + h, w + h * slope_current)
# Update w using Modified Euler's method formula
w_next = w + h / 2 * (slope_current + slope_predicted)
# Update t and w for the next iteration
t += h
w = w_next
# Append new values to lists
t_values.append(t)
w_values.append(w)
return t_values, w_values
# Example usage:
# Define the differential equation y' = f(t, y)
def f(t, y):
return t * sp.exp(3 * t) - 2 * y
# Define the initial conditions
a = 0
b = 1
alpha = 0
h = 0.5
# Use Modified Euler's method to approximate the solution
t_values, w_values = modified_euler_method(f, a, b, alpha, h)
# Print the results
print("t values:", t_values)
print("Approximate solution (w values):", w_values)
def midpoint_method(f, a, b, alpha, h):
"""
Approximates the solution of the initial-value problem y' = f(t,
y), a <= t <= b, y(a) = alpha using the Midpoint method.
"""
t_values = [a]
w_values = [alpha]
t = a
w = alpha
while t < b:
# Compute the slope at the current point
slope = f(t, w)
# Predict w at the midpoint of the interval
w_midpoint = w + h * slope / 2
# Compute the slope at the midpoint
slope_midpoint = f(t + h / 2, w_midpoint)
# Update w using the slope at the midpoint
w_next = w + h * slope_midpoint
# Update t and w for the next iteration
t += h
w = w_next
# Append new values to lists
t_values.append(t)
w_values.append(w)
return t_values, w_values
# Example usage:
# Define the differential equation y' = f(t, y)
def f(t, y):
return t * sp.exp(3 * t) - 2 * y
# Define the initial conditions
a = 0
b = 1
alpha = 0
h = 0.5
# Use the Midpoint method to approximate the solution
t_values, w_values = midpoint_method(f, a, b, alpha, h)
# Print the results
print("t values:", t_values)
print("Approximate solution (w values):", w_values)
def runge_kutta_order_four(f, a, b, y0, h):
"""
Approximates the solution of the initial-value problem y' = f(t,
y), a <= t <= b, y(a) = y0 using the Runge-Kutta method of order four.
"""
t_values = [a]
y_values = [y0]
t = a
y = y0
while t < b:
# Compute slopes at several points within the interval
k1 = h * f(t, y)
k2 = h * f(t + h/2, y + k1/2)
k3 = h * f(t + h/2, y + k2/2)
k4 = h * f(t + h, y + k3)
# Use a weighted average of these slopes to approximate the
change in y
y += (k1 + 2*k2 + 2*k3 + k4) / 6
# Update t
t += h
# Append new values to lists
t_values.append(t)
y_values.append(y)
return t_values, y_values
# Define the differential equation y' = f(t, y)
def f(t, y):
return y / t - (y / t)**2
# Define the actual solution
def actual_solution(t):
return t / (1 + sp.ln(t))
# Define the initial conditions
a = 1
b = 2
y0 = 1
h = 0.1
# Use the Runge-Kutta method of order four to approximate the solution
t_values, y_values = runge_kutta_order_four(f, a, b, y0, h)
# Calculate the actual solution
actual_y_values = [actual_solution(t) for t in t_values]
# Print the results
print("t values:", t_values)
print("Approximate solution (y values):", y_values)
print("Actual solution (y values):", actual_y_values)
def runge_kutta_order_four(f, t, w, h):
"""
Approximates w(t + h) using the Runge-Kutta method of order 4.
"""
k1 = h * f(t, w)
k2 = h * f(t + h/2, w + k1/2)
k3 = h * f(t + h/2, w + k2/2)
k4 = h * f(t + h, w + k3)
return w + (k1 + 2*k2 + 2*k3 + k4) / 6
def predictor_corrector_order_four(f, a, b, alpha, N):
"""
Approximates the solution of the initial-value problem y' = f(t,
y), a <= t <= b, y(a) = alpha using the Predictor-Corrector method of
order 4.
"""
h = (b - a) / N
t_values = [a]
w_values = [alpha]
t = a
w = alpha
# Perform initial steps using Runge-Kutta method of order 4
for i in range(1, 4):
w = runge_kutta_order_four(f, t, w, h)
t += h
t_values.append(t)
w_values.append(w)
# Perform Predictor-Corrector steps
while t < b:
# Predictor step
w_star = w + h / 24 * (55 * f(t, w) - 59 * f(t - h, w_values[-
2]) + 37 * f(t - 2*h, w_values[-3]) - 9 * f(t - 3*h, w_values[-4]))
# Corrector step
w_next = w + h / 24 * (9 * f(t + h, w_star) + 19 * f(t, w) - 5
* f(t - h, w_values[-2]) + f(t - 2*h, w_values[-3]))
# Update t and w for the next iteration
t += h
w = w_next
# Append new values to lists
t_values.append(t)
w_values.append(w)
return t_values, w_values
# Define the differential equation y' = f(t, y)
def f(t, y):
return t * sp.exp(3 * t) - 2 * y
# Define the initial conditions
a = 0
b = 1
alpha = 0
N = 5 # Number of steps
# Use the Predictor-Corrector method of order 4 to approximate the
solution
t_values, w_values = predictor_corrector_order_four(f, a, b, alpha, N)
# Print the results
print("t values:", t_values)
print("Approximate solution (w values):", w_values)
import numpy as np
from scipy.interpolate import CubicSpline
# Define the function
def f(x):
return x * np.log(x)
# Given data points
x_values = np.array([8.3, 8.6])
y_values =np.array([17.56492,18.50515])
# Construct cubic spline interpolant
cubic_spline = CubicSpline(x_values, y_values)
# Approximate f(8.4) and f'(8.4)
x_new = 8.4
f_8_4_approx = cubic_spline(x_new)
f_prime_8_4_approx = cubic_spline(x_new, 1) # 1 indicates first
derivative
# Calculate actual values
f_8_4_actual = f(x_new)
f_prime_8_4_actual = x_new / 8.4 + np.log(x_new)
# Calculate actual error
error_f = abs(f_8_4_actual - f_8_4_approx)
error_f_prime = abs(f_prime_8_4_actual - f_prime_8_4_approx)
print("Approximation of f(8.4):", f_8_4_approx)
print("Approximation of f'(8.4):", f_prime_8_4_approx)
print("Actual value of f(8.4):", f_8_4_actual)
print("Actual value of f'(8.4):", f_prime_8_4_actual)
print("Error in approximation of f(8.4):", error_f)
print("Error in approximation of f'(8.4):", error_f_prime)
np.sin(np.exp(x) - 2)
np.log(np.exp(x) + 2)
import numpy as np
from scipy.interpolate import CubicSpline
# Given data points
x_values = np.array([0, 1, 2])
y_values = np.array([0, 1, 2])
# Define the derivatives at the boundary
s_prime_0 = 1
s_prime_2 = 1
# Construct clamped cubic spline interpolant
cubic_spline = CubicSpline(x_values, y_values, bc_type=((1, s_prime_0), (1, s_prime_2)))
# Evaluate the spline at some points
x_eval = np.linspace(0, 2, 100)
y_eval = cubic_spline(x_eval)
# Print the coefficients of the spline
print("Coefficients of the spline:")
print(cubic_spline.c)
# Plot the interpolated spline
import matplotlib.pyplot as plt
plt.plot(x_eval, y_eval, label='Clamped Cubic Spline')
plt.scatter(x_values, y_values, color='red', label='Data Points')
plt.xlabel('x')
plt.ylabel('s(x)')
plt.title('Clamped Cubic Spline Interpolation')
plt.legend()
plt.grid(True)
plt.show()