def jacobie_method(matrix, vector, precision, norm, n):
# norm can be maximum or euclidean
x_error = create_vector(n)
x = create_vector(n)
for i in range(n):
x[i] = 0
for i in range(n):
vector[i] = vector[i] / matrix[i][i]
for j in range(n):
if i == j:
continue
matrix[i][j] /= matrix[i][i]
x_error[i] = float("inf")
steps = 0
# while norm(x_error) > precision and steps < MAX_STEPS:
while norm(count_system_error(matrix, x, vector, n)) > precision and steps < MAX_STEPS:
print(norm(count_system_error(matrix, x, vector, n)))
steps += 1
for i in range(n):
temp = vector[i]
for j in range(n):
if i == j:
continue
temp -= matrix[i][j] * x[j]
x_error[i] = x[i] - temp
x[i] = temp
print("steps: " + str(steps))
return x
def SOR(matrix, B, omega, n, eps):
x_error = create_vector(n)
x = create_vector(n)
temp2 = create_vector(n)
iteration = create_matrix(n)
temp = create_matrix(n)
for i in range(n):
for j in range(n):
if j > i:
iteration[i][j] = 0
elif j == i:
iteration[i][j] = (1.0 / omega) * matrix[i][j]
else:
iteration[i][j] = (-1) * matrix[i][j]
iteration = reverse_matrix(iteration, n)
for i in range(n):
for j in range(n):
temp[i][j] = 0
for k in range(n):
temp[i][j] += iteration[i][k] * matrix[k][j]
for i in range(n):
temp2[i] = 0
for j in range(n):
temp2[i] += iteration[i][j] * B[j]
for i in range(n):
for j in range(n):
if i == j:
iteration[i][j] = 1 - temp[i][j]
else:
iteration[i][j] = (-1) * temp[i][j]
B[i] = temp2[i]
for i in range(n):
x_error[i] = 1e+300
x[i] = 1
epsilon = eps
steps = 0
while maximum_norm(x_error) > epsilon and steps < MAX_STEPS:
steps += 1
for i in range(n):
for j in range(n):
temp3 = 0
for k in range(n):
temp3 += iteration[j][k] * x[k]
temp3 += B[j]
x_error[j] = x[j] - temp3
x[j] = temp3
# print("steps:" + str(steps))
return x, steps
def SOR(matrix, B, omega, n, eps):
x_error = create_vector(n)
x = create_vector(n)
temp2 = create_vector(n)
iteration = create_matrix(n)
temp = create_matrix(n)
for i in range(n):
for j in range(n):
if j > i:
iteration[i][j] = 0
elif j == i:
iteration[i][j] = (1.0/omega) * matrix[i][j]
else:
iteration[i][j] = (-1) * matrix[i][j]
iteration = reverse_matrix(iteration, n)
for i in range(n):
for j in range(n):
temp[i][j] = 0
for k in range(n):
temp[i][j] += iteration[i][k] * matrix[k][j]
for i in range(n):
temp2[i] = 0
for j in range(n):
temp2[i] += iteration[i][j] * B[j]
for i in range(n):
for j in range(n):
if i == j:
iteration[i][j] = 1 - temp[i][j]
else:
iteration[i][j] = (-1) * temp[i][j]
B[i] = temp2[i]
for i in range(n):
x_error[i] = 1e+300
x[i] = 1
epsilon = eps
steps = 0
while maximum_norm(x_error) > epsilon and steps < MAX_STEPS:
steps += 1
for i in range(n):
for j in range(n):
temp3 = 0
for k in range(n):
temp3 += iteration[j][k] * x[k]
temp3 += B[j]
x_error[j] = x[j] - temp3
x[j] = temp3
# print("steps:" + str(steps))
return x, steps
def calculate_system(n, initial_vector, function_for_solution, derivative_for_solution):
epsilon = 1e-10
steps = 0
solution = initial_vector
previous = create_vector(n)
for i in range(n):
previous[i] = initial_vector[i]
# while (steps == 0) or (maximum_norm(vector_difference(solution, previous)) > epsilon and steps < MAX_STEPS):
while maximum_norm(calculate_solution(solution, n)) > epsilon and steps < MAX_STEPS:
steps += 1
function = function_for_solution(solution, n)
derivative = derivative_for_solution(solution, n)
for i in range(n):
previous[i] = solution[i]
temp = gaussian_elimination(matrix_a=derivative, vector_b=function, n=n)
if temp is None:
return
# print(temp)
for i in range(n):
temp[i] += previous[i]
solution[i] = temp[i]
# print(previous)
# print(solution)
# print(vector_difference(solution, previous))
return steps, solution
def trigonometric_approximation(n, m, points, values):
vals = create_vector(2 * m + 1)
vals[0] = 0
for i in range(n):
vals[0] += values[i]
vals[0] *= 2.0 / n
for k in range(1, m + 1, 1):
a = 0
for i in range(n):
a += values[i] * math.cos(k * ((2 * math.pi) /
(6 * math.pi)) * points[i])
a *= 2.0 / n
b = 0
for i in range(n):
b += values[i] * math.sin(k * ((2 * math.pi) /
(6 * math.pi)) * points[i])
b *= 2.0 / n
vals[2 * k - 1] = a
vals[2 * k] = b
return vals
def function_for_solution(solution, n):
x = solution[0]
y = solution[1]
z = solution[2]
function = create_vector(n)
function[0] = (x*x + y*y - z*z - 1) * (-1)
function[1] = (x - 2*y*y*y + 2*z*z + 1) * (-1)
function[2] = (2*x*x + y - 2*z*z - 1) * (-1)
return function
def function_for_solution(solution, n):
x = solution[0]
y = solution[1]
z = solution[2]
function = create_vector(n)
function[0] = (x * x + y * y - z * z - 1) * (-1)
function[1] = (x - 2 * y * y * y + 2 * z * z + 1) * (-1)
function[2] = (2 * x * x + y - 2 * z * z - 1) * (-1)
return function
def calculate_solution(vector, n):
x = vector[0]
y = vector[1]
z = vector[2]
result = create_vector(n)
result[0] = x*x + y*y - z*z - 1
result[1] = x - 2*y*y*y + 2*z*z + 1
result[2] = 2*x*x + y - 2*z*z - 1
return result
def jacobie_method(matrix, vector, precision, norm, n):
# norm can be maximum or euclidean
x_error = create_vector(n)
x = create_vector(n)
for i in range(n):
x[i] = 0
for i in range(n):
vector[i] = vector[i] / matrix[i][i]
for j in range(n):
if i == j:
continue
matrix[i][j] /= matrix[i][i]
x_error[i] = float("inf")
steps = 0
# while norm(x_error) > precision and steps < MAX_STEPS:
while norm(count_system_error(matrix, x, vector,
n)) > precision and steps < MAX_STEPS:
print(norm(count_system_error(matrix, x, vector, n)))
steps += 1
for i in range(n):
temp = vector[i]
for j in range(n):
if i == j:
continue
temp -= matrix[i][j] * x[j]
x_error[i] = x[i] - temp
x[i] = temp
print("steps: " + str(steps))
return x
def algebraic_approximation(n, m, points, values):
matrix_a = create_matrix(n, m+1)
for i in range(n):
for j in range(m+1):
matrix_a[i][j] = math.pow(points[i], j)
matrix_b = create_matrix(m+1, n)
for i in range(n):
for j in range(m+1):
matrix_b[j][i] = matrix_a[i][j]
coefficients = create_matrix(m+1, m+1)
coefficients = multiply_matrixes(matrix_a, matrix_b, coefficients, n, m)
vals = create_vector(m+1)
vals = multiply_vector(matrix_b, vals, n, m+1, values)
result = gaussian_elimination(coefficients, vals, m+1)
return result
def algebraic_approximation(n, m, points, values):
matrix_a = create_matrix(n, m + 1)
for i in range(n):
for j in range(m + 1):
matrix_a[i][j] = math.pow(points[i], j)
matrix_b = create_matrix(m + 1, n)
for i in range(n):
for j in range(m + 1):
matrix_b[j][i] = matrix_a[i][j]
coefficients = create_matrix(m + 1, m + 1)
coefficients = multiply_matrixes(matrix_a, matrix_b, coefficients, n, m)
vals = create_vector(m + 1)
vals = multiply_vector(matrix_b, vals, n, m + 1, values)
result = gaussian_elimination(coefficients, vals, m + 1)
return result
def create_system_for_cubic(n, variant):
matrix_a = create_tridiagonal(n-2)
vector_b = create_vector(n-2)
for i in range(n-2):
matrix_a[i][0] = 1
matrix_a[i][1] = 4
matrix_a[i][2] = 1
if n >= 3:
matrix_a[0][0] = 0
matrix_a[n-3][2] = 0
if variant == 'parabolic':
matrix_a[0][1] = 5
matrix_a[n-3][1] = 5
elif variant == 'parabolic':
matrix_a[0] = 0
matrix_a[1] = 5
matrix_a[2] = 0
return matrix_a, vector_b
def trigonometric_approximation(n, m, points, values):
vals = create_vector(2*m+1)
vals[0] = 0
for i in range(n):
vals[0] += values[i]
vals[0] *= 2.0/n
for k in range(1, m+1, 1):
a = 0
for i in range(n):
a += values[i] * math.cos(k*((2*math.pi)/(6*math.pi)) * points[i])
a *= 2.0 / n
b = 0
for i in range(n):
b += values[i] * math.sin(k*((2*math.pi)/(6*math.pi)) * points[i])
b *= 2.0 / n
vals[2*k - 1] = a
vals[2*k] = b
return vals
def create_system_for_square(points, values, n, variant):
matrix_a = create_matrix(3 * (n - 1))
vector_b = create_vector(3 * (n - 1))
distance = points[1] - points[0]
for i in range(0, 3 * (n - 1), 3):
if i != 3 * (n - 2):
matrix_a[i][i] = 2 * distance
matrix_a[i][i + 1] = 1
matrix_a[i][i + 4] = -1
else:
calculate_variant(variant, matrix_a, i, distance)
j = i + 1
matrix_a[j][j - 1] = distance * distance
matrix_a[j][j] = distance
vector_b[j] = values[int(j / 3) + 1] - values[int(j / 3)]
k = j + 1
matrix_a[k][k] = 1
vector_b[k] = values[int(k / 3)]
return matrix_a, vector_b
def create_system_for_square(points, values, n, variant):
matrix_a = create_matrix(3*(n-1))
vector_b = create_vector(3*(n-1))
distance = points[1] - points[0]
for i in range(0, 3*(n-1), 3):
if i != 3 * (n-2):
matrix_a[i][i] = 2 * distance
matrix_a[i][i+1] = 1
matrix_a[i][i+4] = -1
else:
calculate_variant(variant, matrix_a, i, distance)
j = i + 1
matrix_a[j][j-1] = distance * distance
matrix_a[j][j] = distance
vector_b[j] = values[int(j / 3) + 1] - values[int(j / 3)]
k = j + 1
matrix_a[k][k] = 1
vector_b[k] = values[int(k / 3)]
return matrix_a, vector_b
def cubic_spline(points, values, n, variant):
matrix_a, vector_b = create_system_for_cubic(n, variant)
vector_b = free_column(vector_b, points, values, n)
matrix_a, vector_b = thomas_algorithm(matrix_a, vector_b, n-2)
z = create_vector(n)
for i in range(1, n-1):
z[i] = vector_b[i-1]
if variant == 'natural':
z[0] = 0
z[n-1] = 0
elif variant == 'parabolic':
z[0] = z[1]
z[n-1] = z[n-2]
distance = points[1] - points[0]
splines = []
for i in range(n-1):
splines.append(CubicPolynomial((1/(6*distance))*(z[i+1] - z[i]), 0.5 * z[i],
(values[i+1] - values[i])/distance - (distance/6)*(z[i+1] + 2*z[i]), values[i]))
return splines
def fdm_implicit():
x_start = 0
x_end = 2 * math.pi
t_start = 0
t_end = 3.5
a = 2
for pair in [(20, 480)]:
x_points = pair[0] + 1
t_points = pair[1] + 1
x_step = (x_end - x_start) / (x_points - 1)
t_step = (t_end - t_start) / (t_points - 1)
x_coord = create_vector(x_points)
# vectors created,
x_step = (x_end - x_start) / (x_points - 1)
t_step = (t_end - t_start) / (t_points - 1)
x_coord = create_vector(x_points)
for i in range(x_points):
x_coord[i] = x_start + i * x_step
t_cord = create_vector(t_points)
for i in range(t_points):
t_cord[i] = t_start + i * t_step
# grid created
meshgrid = create_matrix(t_points, x_points)
for i in range(x_points):
meshgrid[0][i] = 2 * math.sin(
2 * x_coord[i]) * math.exp(-x_coord[i])
for i in range(t_points):
meshgrid[i][0] = 0
meshgrid[i][x_points - 1] = 0
coefficient = (math.pow(a, 2) * t_step) / math.pow(x_step, 2)
values = create_vector(x_points)
matrix = create_tridiagonal(x_points)
for j in range(1, t_points):
for k in range(1, x_points - 1):
matrix[k][0] = (-1) * coefficient
matrix[k][1] = 1 + 2 * coefficient
matrix[k][2] = (-1) * coefficient
values[k] = meshgrid[j - 1][k]
matrix[0][0] = 0
matrix[0][1] = 1
matrix[0][2] = 0
matrix[x_points - 1][0] = 0
matrix[x_points - 1][1] = 1
matrix[x_points - 1][2] = 0
values[0] = meshgrid[j][0]
values[x_points - 1] = meshgrid[j][x_points - 1]
thomas_algorithm(matrix, values, x_points)
for i in range(x_points - 1):
meshgrid[j][i] = values[i]
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = x_coord
y = t_cord
X, Y = np.meshgrid(x, y)
ax.plot_surface(
X,
Y,
meshgrid,
cstride=1,
rstride=1,
linewidth=0.0,
cmap=cm.get_cmap("gist_rainbow"),
)
ax.set_xlabel("os x")
ax.set_ylabel("os t")
ax.set_zlabel("rozwiazanie")
file_name = '../plots/fdm/imp' + str(x_points) + "," + str(
t_points) + '.png'
plt.savefig(file_name)
# plt.show()
plt.close()
max_val = 0
for i in range(x_points):
for j in range(t_points):
if math.fabs(meshgrid[j][i] > max_val):
max_val = abs(meshgrid[j][i])
print(
str(x_points) + ", " + str(t_points) + ", " + str(coefficient) +
", " + str(max_val))
def fdm():
x_start = 0
x_end = 2 * math.pi
t_start = 0
t_end = 3.5
a = 2
for pair in [(20, 480)]:
x_points = pair[0] + 1
t_points = pair[1] + 1
# vectors created,
x_step = (x_end - x_start) / (x_points - 1)
t_step = (t_end - t_start) / (t_points - 1)
x_coord = create_vector(x_points)
for i in range(x_points):
x_coord[i] = x_start + i * x_step
t_cord = create_vector(t_points)
for i in range(t_points):
t_cord[i] = t_start + i * t_step
# grid created
meshgrid = create_matrix(t_points, x_points)
for i in range(x_points):
meshgrid[0][i] = 2 * math.sin(
2 * x_coord[i]) * math.exp(-x_coord[i])
for i in range(t_points):
meshgrid[i][0] = 0
meshgrid[i][x_points - 1] = 0
# a*a+k/h*h
coefficient = (math.pow(a, 2) * t_step) / math.pow(x_step, 2)
for j in range(1, t_points):
for i in range(1, x_points - 1):
meshgrid[j][i] = coefficient * meshgrid[j-1][i-1] + \
(1-2*coefficient)*meshgrid[j-1][i] + coefficient * meshgrid[j-1][i+1]
# plot drawing
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = x_coord
y = t_cord
X, Y = np.meshgrid(x, y)
try:
ax.plot_surface(
X,
Y,
meshgrid,
cstride=1,
rstride=1,
linewidth=0.0,
cmap=cm.get_cmap("gist_rainbow"),
)
ax.set_xlabel("os x")
ax.set_ylabel("os t")
ax.set_zlabel("rozwiazanie")
file_name = '../plots/fdm/ex' + str(x_points) + "," + str(
t_points) + '.png'
plt.savefig(file_name)
# plt.show()
plt.close()
except Exception as e:
print(e.__class__)
max_val = 0
for i in range(x_points):
for j in range(t_points):
if math.fabs(meshgrid[j][i] > max_val):
max_val = abs(meshgrid[j][i])
print(
str(x_points) + ", " + str(t_points) + ", " + str(coefficient) +
", " + str(max_val))
def fdm_implicit():
x_start = 0
x_end = 2*math.pi
t_start = 0
t_end = 3.5
a = 2
for pair in [
(20, 480)
]:
x_points = pair[0] + 1
t_points = pair[1] + 1
x_step = (x_end - x_start) / (x_points - 1)
t_step = (t_end - t_start) / (t_points - 1)
x_coord = create_vector(x_points)
# vectors created,
x_step = (x_end - x_start) / (x_points - 1)
t_step = (t_end - t_start) / (t_points - 1)
x_coord = create_vector(x_points)
for i in range(x_points):
x_coord[i] = x_start + i * x_step
t_cord = create_vector(t_points)
for i in range(t_points):
t_cord[i] = t_start + i * t_step
# grid created
meshgrid = create_matrix(t_points, x_points)
for i in range(x_points):
meshgrid[0][i] = 2 * math.sin(2*x_coord[i]) * math.exp(-x_coord[i])
for i in range(t_points):
meshgrid[i][0] = 0
meshgrid[i][x_points-1] = 0
coefficient = (math.pow(a, 2) * t_step) / math.pow(x_step, 2)
values = create_vector(x_points)
matrix = create_tridiagonal(x_points)
for j in range(1, t_points):
for k in range(1, x_points-1):
matrix[k][0] = (-1) * coefficient
matrix[k][1] = 1 + 2*coefficient
matrix[k][2] = (-1)*coefficient
values[k] = meshgrid[j-1][k]
matrix[0][0] = 0
matrix[0][1] = 1
matrix[0][2] = 0
matrix[x_points-1][0] = 0
matrix[x_points-1][1] = 1
matrix[x_points-1][2] = 0
values[0] = meshgrid[j][0]
values[x_points-1] = meshgrid[j][x_points-1]
thomas_algorithm(matrix, values, x_points)
for i in range(x_points-1):
meshgrid[j][i] = values[i]
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = x_coord
y = t_cord
X, Y = np.meshgrid(x, y)
ax.plot_surface(X, Y, meshgrid, cstride=1, rstride=1, linewidth=0.0, cmap=cm.get_cmap("gist_rainbow"),)
ax.set_xlabel("os x")
ax.set_ylabel("os t")
ax.set_zlabel("rozwiazanie")
file_name = '../plots/fdm/imp' + str(x_points) + "," + str(t_points) + '.png'
plt.savefig(file_name)
# plt.show()
plt.close()
max_val = 0
for i in range(x_points):
for j in range(t_points):
if math.fabs(meshgrid[j][i] > max_val):
max_val = abs(meshgrid[j][i])
print(str(x_points) + ", " + str(t_points) + ", " + str(coefficient) + ", " + str(max_val))
matrix[j][j] = M / j
else:
matrix[j][j] = 0
matrix[j][j] = K
def fill_vector(vector, n):
for j in range(n):
if j % 2 == 0:
vector[j] = -1
else:
vector[j] = 1
if __name__ == "__main__":
for i in [10, 30, 50, 100, 150, 250, 500, 750, 1000, 5000]:
matrix_A = create_matrix(i)
fill_matrix(matrix_A, i)
vector_X = create_vector(i)
fill_vector(vector_X, i)
vector_B = calculate_constant_terms_vector(matrix_A, vector_X, i)
x = jacobie_method(matrix_A, vector_B, 1e-15, euclidean_norm, i)
euclidean = euclidean_norm(vector_difference(vector_X, x))
maximum = maximum_norm(vector_difference(vector_X, x))
print("Matrix size: " + str(i))
print(euclidean)
print(maximum)
radius = spectral_radius(matrix_A, i)
print("Matrix size: " + str(i) + "\tspectral radius: " + str(radius))
else:
matrix[j][j] = 0
matrix[j][j] = K
def fill_vector(vector, n):
for j in range(n):
if j % 2 == 0:
vector[j] = -1
else:
vector[j] = 1
if __name__ == "__main__":
for i in [10, 30, 50, 100, 150, 250, 500, 750, 1000, 5000]:
matrix_A = create_matrix(i)
fill_matrix(matrix_A, i)
vector_X = create_vector(i)
fill_vector(vector_X, i)
vector_B = calculate_constant_terms_vector(matrix_A, vector_X, i)
x = jacobie_method(matrix_A, vector_B, 1e-15, euclidean_norm, i)
euclidean = euclidean_norm(vector_difference(vector_X, x))
maximum = maximum_norm(vector_difference(vector_X, x))
print("Matrix size: " + str(i))
print(euclidean)
print(maximum)
radius = spectral_radius(matrix_A, i)
print("Matrix size: " + str(i) + "\tspectral radius: " + str(radius))
def fdm():
x_start = 0
x_end = 2*math.pi
t_start = 0
t_end = 3.5
a = 2
for pair in [
(20, 480)
]:
x_points = pair[0] + 1
t_points = pair[1] + 1
# vectors created,
x_step = (x_end - x_start) / (x_points - 1)
t_step = (t_end - t_start) / (t_points - 1)
x_coord = create_vector(x_points)
for i in range(x_points):
x_coord[i] = x_start + i * x_step
t_cord = create_vector(t_points)
for i in range(t_points):
t_cord[i] = t_start + i * t_step
# grid created
meshgrid = create_matrix(t_points, x_points)
for i in range(x_points):
meshgrid[0][i] = 2 * math.sin(2*x_coord[i]) * math.exp(-x_coord[i])
for i in range(t_points):
meshgrid[i][0] = 0
meshgrid[i][x_points-1] = 0
# a*a+k/h*h
coefficient = (math.pow(a, 2) * t_step) / math.pow(x_step, 2)
for j in range(1, t_points):
for i in range(1, x_points-1):
meshgrid[j][i] = coefficient * meshgrid[j-1][i-1] + \
(1-2*coefficient)*meshgrid[j-1][i] + coefficient * meshgrid[j-1][i+1]
# plot drawing
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = x_coord
y = t_cord
X, Y = np.meshgrid(x, y)
try:
ax.plot_surface(X, Y, meshgrid, cstride=1, rstride=1, linewidth=0.0, cmap=cm.get_cmap("gist_rainbow"),)
ax.set_xlabel("os x")
ax.set_ylabel("os t")
ax.set_zlabel("rozwiazanie")
file_name = '../plots/fdm/ex' + str(x_points) + "," + str(t_points) + '.png'
plt.savefig(file_name)
# plt.show()
plt.close()
except Exception as e:
print(e.__class__)
max_val = 0
for i in range(x_points):
for j in range(t_points):
if math.fabs(meshgrid[j][i] > max_val):
max_val = abs(meshgrid[j][i])
print(str(x_points) + ", " + str(t_points) + ", " + str(coefficient) + ", " + str(max_val))
