From 948cd873f36c0c5d34c2c0ab497faea805d6a08c Mon Sep 17 00:00:00 2001 From: unknown Date: Sun, 27 Dec 2020 12:08:13 +0200 Subject: [PATCH 1/5] The first laboratory from the subject numeric methods was added --- numeric_lab1/.idea/.gitignore | 3 + .../inspectionProfiles/Project_Default.xml | 12 ++++ .../inspectionProfiles/profiles_settings.xml | 6 ++ numeric_lab1/.idea/misc.xml | 4 ++ numeric_lab1/.idea/modules.xml | 8 +++ numeric_lab1/.idea/numeric_lab1.iml | 8 +++ numeric_lab1/matrix.py | 67 +++++++++++++++++++ 7 files changed, 108 insertions(+) create mode 100644 numeric_lab1/.idea/.gitignore create mode 100644 numeric_lab1/.idea/inspectionProfiles/Project_Default.xml create mode 100644 numeric_lab1/.idea/inspectionProfiles/profiles_settings.xml create mode 100644 numeric_lab1/.idea/misc.xml create mode 100644 numeric_lab1/.idea/modules.xml create mode 100644 numeric_lab1/.idea/numeric_lab1.iml create mode 100644 numeric_lab1/matrix.py diff --git a/numeric_lab1/.idea/.gitignore b/numeric_lab1/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/numeric_lab1/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/numeric_lab1/.idea/inspectionProfiles/Project_Default.xml b/numeric_lab1/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..3dce9c6 --- /dev/null +++ b/numeric_lab1/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,12 @@ + + + + \ No newline at end of file diff --git a/numeric_lab1/.idea/inspectionProfiles/profiles_settings.xml b/numeric_lab1/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/numeric_lab1/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/numeric_lab1/.idea/misc.xml b/numeric_lab1/.idea/misc.xml new file mode 100644 index 0000000..a2e120d --- /dev/null +++ b/numeric_lab1/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/numeric_lab1/.idea/modules.xml b/numeric_lab1/.idea/modules.xml new file mode 100644 index 0000000..57d773f --- /dev/null +++ b/numeric_lab1/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/numeric_lab1/.idea/numeric_lab1.iml b/numeric_lab1/.idea/numeric_lab1.iml new file mode 100644 index 0000000..d0876a7 --- /dev/null +++ b/numeric_lab1/.idea/numeric_lab1.iml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/numeric_lab1/matrix.py b/numeric_lab1/matrix.py new file mode 100644 index 0000000..10a5b94 --- /dev/null +++ b/numeric_lab1/matrix.py @@ -0,0 +1,67 @@ +def main(): + matrix = [[8.3, 3.2, 4.1, 1.9], + [3.92, 8.45, 7.2, 2.46], + [3.77, 7.79, 8.04, 2.28], + [2.21, 3.07, 1.69, 6.69]] + matrix_l = [[0 for _ in range(4)] for _ in range(4)] + matrix_u = [[0 for _ in range(4)] for _ in range(4)] + matrix_b = [-10.23, 12.21, 15.03, -8.35] + matrix_y = [0, 0, 0, 0] + matrix_x = [0, 0, 0, 0] + + + for k in range(0, 4): + for i in range(k, 4): + matrix_l[i][k] = matrix[i][k] - sum([matrix_l[i][m] * matrix_u[m][k] for m in range(0, k - 1)]) + for j in range(k + 1, 4): + matrix_u[k][j] = (matrix[k][j] - sum([matrix_l[k][m] * matrix_u[m][j] for m in + range(0, k - 1)])) / matrix_l[k][k] + + matrix_y[0] = matrix_b[0] / matrix_l[0][0] + for i in range(1, 4): + matrix_y[i] = (matrix_b[i] - sum([matrix_l[i][m] * matrix_y[m] for m in range(0, k - 1)])) / matrix_l[i][i] + + matrix_x[3] = matrix_y[3] + for i in reversed(range(0, 3)): + matrix_x[i] = (matrix_y[i] - sum([matrix_u[i][m] * matrix_x[m] for m in range(i + 1, 4)])) / matrix_l[i][i] + + + return matrix_x + + def read_input(): + matrix_a = [[]] + matrix_b = [[]] + for i in range(4): + matrix_b[i] = float(input("Enter element for matrix B: ")) + for j in range(4): + matrix_a[i][j] = float(input("Enter element for matrix A: ")) + + + +if __name__ == '__main__': + matrix_x = main() + k = 20 + p = 21 + s = 0.02 * k + B = 0.02 * p + + a = [[8.3, 2.62 + s, 4.1, 1.9], + [3.92, 8.45, 7.78 - s, 2.46], + [3.77, 7.21 + s, 8.04, 2.28], + [2.21, 3.65 - s, 1.69, 6.69]] + + b = [-10.65 + B, 12.21, 15.45 - B, -8.35] + + print(matrix_x) + print(a) + + sums = [] + for equation in a: + sum = 0 + for iterator in range(len(equation)): + sum += equation[iterator] * matrix_x[iterator] + sums.append(sum) + print(sums) + print(b) + + From cc332a3b3b41705f1838ceb68e37f2e3812a993b Mon Sep 17 00:00:00 2001 From: unknown Date: Sun, 27 Dec 2020 12:15:35 +0200 Subject: [PATCH 2/5] The third laboratory from the subject numeric methods was added --- numeric_lab1/.idea/.gitignore | 3 - .../inspectionProfiles/Project_Default.xml | 12 -- .../inspectionProfiles/profiles_settings.xml | 6 - numeric_lab1/.idea/misc.xml | 4 - numeric_lab1/.idea/modules.xml | 8 - numeric_lab1/.idea/numeric_lab1.iml | 8 - numeric_lab1/matrix.py | 67 ------- numeric_lab3/newton-jakobi.py | 187 ++++++++++++++++++ 8 files changed, 187 insertions(+), 108 deletions(-) delete mode 100644 numeric_lab1/.idea/.gitignore delete mode 100644 numeric_lab1/.idea/inspectionProfiles/Project_Default.xml delete mode 100644 numeric_lab1/.idea/inspectionProfiles/profiles_settings.xml delete mode 100644 numeric_lab1/.idea/misc.xml delete mode 100644 numeric_lab1/.idea/modules.xml delete mode 100644 numeric_lab1/.idea/numeric_lab1.iml delete mode 100644 numeric_lab1/matrix.py create mode 100644 numeric_lab3/newton-jakobi.py diff --git a/numeric_lab1/.idea/.gitignore b/numeric_lab1/.idea/.gitignore deleted file mode 100644 index 26d3352..0000000 --- a/numeric_lab1/.idea/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -# Default ignored files -/shelf/ -/workspace.xml diff --git a/numeric_lab1/.idea/inspectionProfiles/Project_Default.xml b/numeric_lab1/.idea/inspectionProfiles/Project_Default.xml deleted file mode 100644 index 3dce9c6..0000000 --- a/numeric_lab1/.idea/inspectionProfiles/Project_Default.xml +++ /dev/null @@ -1,12 +0,0 @@ - - - - \ No newline at end of file diff --git a/numeric_lab1/.idea/inspectionProfiles/profiles_settings.xml b/numeric_lab1/.idea/inspectionProfiles/profiles_settings.xml deleted file mode 100644 index 105ce2d..0000000 --- a/numeric_lab1/.idea/inspectionProfiles/profiles_settings.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - \ No newline at end of file diff --git a/numeric_lab1/.idea/misc.xml b/numeric_lab1/.idea/misc.xml deleted file mode 100644 index a2e120d..0000000 --- a/numeric_lab1/.idea/misc.xml +++ /dev/null @@ -1,4 +0,0 @@ - - - - \ No newline at end of file diff --git a/numeric_lab1/.idea/modules.xml b/numeric_lab1/.idea/modules.xml deleted file mode 100644 index 57d773f..0000000 --- a/numeric_lab1/.idea/modules.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/numeric_lab1/.idea/numeric_lab1.iml b/numeric_lab1/.idea/numeric_lab1.iml deleted file mode 100644 index d0876a7..0000000 --- a/numeric_lab1/.idea/numeric_lab1.iml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/numeric_lab1/matrix.py b/numeric_lab1/matrix.py deleted file mode 100644 index 10a5b94..0000000 --- a/numeric_lab1/matrix.py +++ /dev/null @@ -1,67 +0,0 @@ -def main(): - matrix = [[8.3, 3.2, 4.1, 1.9], - [3.92, 8.45, 7.2, 2.46], - [3.77, 7.79, 8.04, 2.28], - [2.21, 3.07, 1.69, 6.69]] - matrix_l = [[0 for _ in range(4)] for _ in range(4)] - matrix_u = [[0 for _ in range(4)] for _ in range(4)] - matrix_b = [-10.23, 12.21, 15.03, -8.35] - matrix_y = [0, 0, 0, 0] - matrix_x = [0, 0, 0, 0] - - - for k in range(0, 4): - for i in range(k, 4): - matrix_l[i][k] = matrix[i][k] - sum([matrix_l[i][m] * matrix_u[m][k] for m in range(0, k - 1)]) - for j in range(k + 1, 4): - matrix_u[k][j] = (matrix[k][j] - sum([matrix_l[k][m] * matrix_u[m][j] for m in - range(0, k - 1)])) / matrix_l[k][k] - - matrix_y[0] = matrix_b[0] / matrix_l[0][0] - for i in range(1, 4): - matrix_y[i] = (matrix_b[i] - sum([matrix_l[i][m] * matrix_y[m] for m in range(0, k - 1)])) / matrix_l[i][i] - - matrix_x[3] = matrix_y[3] - for i in reversed(range(0, 3)): - matrix_x[i] = (matrix_y[i] - sum([matrix_u[i][m] * matrix_x[m] for m in range(i + 1, 4)])) / matrix_l[i][i] - - - return matrix_x - - def read_input(): - matrix_a = [[]] - matrix_b = [[]] - for i in range(4): - matrix_b[i] = float(input("Enter element for matrix B: ")) - for j in range(4): - matrix_a[i][j] = float(input("Enter element for matrix A: ")) - - - -if __name__ == '__main__': - matrix_x = main() - k = 20 - p = 21 - s = 0.02 * k - B = 0.02 * p - - a = [[8.3, 2.62 + s, 4.1, 1.9], - [3.92, 8.45, 7.78 - s, 2.46], - [3.77, 7.21 + s, 8.04, 2.28], - [2.21, 3.65 - s, 1.69, 6.69]] - - b = [-10.65 + B, 12.21, 15.45 - B, -8.35] - - print(matrix_x) - print(a) - - sums = [] - for equation in a: - sum = 0 - for iterator in range(len(equation)): - sum += equation[iterator] * matrix_x[iterator] - sums.append(sum) - print(sums) - print(b) - - diff --git a/numeric_lab3/newton-jakobi.py b/numeric_lab3/newton-jakobi.py new file mode 100644 index 0000000..bfecf53 --- /dev/null +++ b/numeric_lab3/newton-jakobi.py @@ -0,0 +1,187 @@ +def f1(x1, x2): + return x2**2 + 0.8 * x2**2 + 0.1 - x1 + + +def f2(x1, x2): + return 2*x1*x2 + 0.1 - x2 + + +def newton_jakobi(): + eps = 0.001 + argument_vector = [1, 1] + prev_vector = [0, 0] + identity_matrix = initialize_matrix() + f = [0, 0] + while True: + f[0] = f1(argument_vector[0], argument_vector[1]) + f[1] = f2(argument_vector[0], argument_vector[1]) + jacobian = build_jacobian(argument_vector, f) + reversed_jacobian = reverse_matrix(jacobian, identity_matrix) + for i in range(len(f)): + x_old = argument_vector[i] + prev_vector[i] = x_old + increment = 0.0 + for j in range(2): + increment += reversed_jacobian[i][j] * f[i] + argument_vector[i] = prev_vector[i] - increment + if abs((argument_vector[0] - prev_vector[0])/argument_vector[0]) < eps: + break + elif abs((argument_vector[1] - prev_vector[1])/argument_vector[1]) < eps: + break + + print(argument_vector) + print(f1(argument_vector[0], argument_vector[1])) + print(f2(argument_vector[0], argument_vector[1])) + + +def build_jacobian(argument_vector, function_vector): + h = 1 + args = [0, 0] + f = [0, 0] + jacobian = [[0, 0], [0, 0]] + for i in range(2): + for j in range(2): + for k in range(2): + args[k] = argument_vector[k] + args[j] = argument_vector[j] + h + f[0] = f1(args[0], args[1]) + f[1] = f2(args[0], args[1]) + jacobian[i][j] = (f[i] - function_vector[i])/h + return jacobian + + +def initialize_matrix(): + matrix = [[0 for _ in range(4)] for _ in range(4)] + for i in range(len(matrix)): + for j in range(len(matrix[i])): + if i == j: + matrix[i][j] = 1 + else: + matrix[i][j] = 0 + return matrix + + +def reverse_matrix(matrix, identity_matrix): + size = len(matrix) + reversed_matrix = [[0 for _ in range(size)] for _ in range(size)] + for i in range(size): + solution = roots(i, matrix, identity_matrix) + for j in range(len(solution)): + reversed_matrix[j][i] = solution[j] + return reversed_matrix + + +def roots(counter, matrix, identity_matrix): + size = len(matrix) + coefficients = [[0 for _ in range(size)] for _ in range(size)] + free_members = [0 for _ in range(size)] + argument_positions = [0 for _ in range(size)] + result_coefficients = [[0 for _ in range(size)] for _ in range(size)] + result_free_members = [0 for _ in range(size)] + free_members, coefficients, argument_positions = initialize_system( + free_members, identity_matrix, counter, argument_positions, coefficients, matrix) + result_free_members, free_members, coefficients, result_coefficients = direct_way( + result_free_members, free_members, coefficients, result_coefficients, argument_positions, size) + result = reverse_way(result_free_members, result_coefficients) + result, argument_positions = order_vector(result, argument_positions) + return result + + +def order_vector(result, argument_positions): + for i in range(len(result)): + if argument_positions != i: + arg = argument_positions[i] + value = result[i] + result[i] = result[arg] + result[arg] = value + argument_positions[i] = argument_positions[arg] + argument_positions[arg] = arg + return result, argument_positions + + +def direct_way(result_free_members, free_members, coefficients, result_coefficients, argument_positions, size): + for i in range(size): + coefficients, free_members, argument_positions, result_coefficients = optimize_matrix( + i, coefficients, free_members, argument_positions, result_coefficients, size) + result_free_members[i] = free_members[i] / coefficients[i][i] + for j in range(i + 1, size): + free_members[j] = free_members[j] - coefficients[j][i] * result_free_members[i] + for k in range(i + 1, size): + result_coefficients[i][k] = coefficients[i][k] / coefficients[i][i] + coefficients[j][k] = coefficients[j][k] - coefficients[j][i] * result_coefficients[i][k] + return result_free_members, free_members, coefficients, result_coefficients + + +def reverse_way(result_free_members, result_coefficients): + size = len(result_free_members) + solution = [0 for _ in range(size)] + for i in range(size -1, -1, -1): + sum = 0.0 + for j in range(i + 1, size): + sum += result_coefficients[i][j] * solution[j] + solution[i] = result_free_members[i] - sum + return solution + + +def initialize_system(free_members, identity_matrix, counter, argument_positions, coefficients, matrix): + size = len(matrix) + for i in range(size): + free_members[i] = identity_matrix[i][counter] + argument_positions[i] = i + for j in range(size): + coefficients[i][j] = matrix[i][j] + return free_members, coefficients, argument_positions + + +def optimize_matrix(r, coefficients, free_members, argument_positions, result_coefficients, size): + max_coefficient = coefficients[r][r] + max_row = r + max_col = r + for i in range(size): + for j in range(size): + if max_coefficient < abs(coefficients[i][j]): + max_coefficient = abs(coefficients[i][j]) + max_row = i + max_col = j + free_members = swap_array_values(free_members, r, max_row) + for l in range(size): + coefficients = swap_matrix_values_row(coefficients, r, max_row, l) + argument_positions = swap_argument_positions(argument_positions, r, max_col) + for m in range(size): + if m < r: + result_coefficients = swap_matrix_values_columns(result_coefficients, m, r, max_col) + else: + coefficients = swap_matrix_values_columns(coefficients, m, r, max_col) + return coefficients, free_members, argument_positions, result_coefficients + + +def swap_matrix_values_columns(matrix, r, fc, sc): + temp = matrix[r][fc] + matrix[r][fc] = matrix[r][sc] + matrix[r][sc] = temp + return matrix + + +def swap_argument_positions(argument_positions, r, max_col): + temp = argument_positions[r] + argument_positions[r] = argument_positions[max_col] + argument_positions[max_col] = temp + return argument_positions + + +def swap_array_values(free_members, fc, sc): + temp = free_members[fc] + free_members[fc] = free_members[sc] + free_members[sc] = temp + return free_members + + +def swap_matrix_values_row(matrix, fc, sc, col): + temp = matrix[fc][col] + matrix[fc][col] = matrix[sc][col] + matrix[sc][col] = temp + return matrix + + +if __name__ == '__main__': + newton_jakobi() From 984ea216e1b5ab2733a059436805f093b49c2665 Mon Sep 17 00:00:00 2001 From: unknown Date: Sun, 27 Dec 2020 12:21:08 +0200 Subject: [PATCH 3/5] The fourth laboratory from the subject numeric methods was added --- numeric_lab3/newton-jakobi.py | 187 ---------------------------------- numeric_lab4/rectangles.py | 32 ++++++ 2 files changed, 32 insertions(+), 187 deletions(-) delete mode 100644 numeric_lab3/newton-jakobi.py create mode 100644 numeric_lab4/rectangles.py diff --git a/numeric_lab3/newton-jakobi.py b/numeric_lab3/newton-jakobi.py deleted file mode 100644 index bfecf53..0000000 --- a/numeric_lab3/newton-jakobi.py +++ /dev/null @@ -1,187 +0,0 @@ -def f1(x1, x2): - return x2**2 + 0.8 * x2**2 + 0.1 - x1 - - -def f2(x1, x2): - return 2*x1*x2 + 0.1 - x2 - - -def newton_jakobi(): - eps = 0.001 - argument_vector = [1, 1] - prev_vector = [0, 0] - identity_matrix = initialize_matrix() - f = [0, 0] - while True: - f[0] = f1(argument_vector[0], argument_vector[1]) - f[1] = f2(argument_vector[0], argument_vector[1]) - jacobian = build_jacobian(argument_vector, f) - reversed_jacobian = reverse_matrix(jacobian, identity_matrix) - for i in range(len(f)): - x_old = argument_vector[i] - prev_vector[i] = x_old - increment = 0.0 - for j in range(2): - increment += reversed_jacobian[i][j] * f[i] - argument_vector[i] = prev_vector[i] - increment - if abs((argument_vector[0] - prev_vector[0])/argument_vector[0]) < eps: - break - elif abs((argument_vector[1] - prev_vector[1])/argument_vector[1]) < eps: - break - - print(argument_vector) - print(f1(argument_vector[0], argument_vector[1])) - print(f2(argument_vector[0], argument_vector[1])) - - -def build_jacobian(argument_vector, function_vector): - h = 1 - args = [0, 0] - f = [0, 0] - jacobian = [[0, 0], [0, 0]] - for i in range(2): - for j in range(2): - for k in range(2): - args[k] = argument_vector[k] - args[j] = argument_vector[j] + h - f[0] = f1(args[0], args[1]) - f[1] = f2(args[0], args[1]) - jacobian[i][j] = (f[i] - function_vector[i])/h - return jacobian - - -def initialize_matrix(): - matrix = [[0 for _ in range(4)] for _ in range(4)] - for i in range(len(matrix)): - for j in range(len(matrix[i])): - if i == j: - matrix[i][j] = 1 - else: - matrix[i][j] = 0 - return matrix - - -def reverse_matrix(matrix, identity_matrix): - size = len(matrix) - reversed_matrix = [[0 for _ in range(size)] for _ in range(size)] - for i in range(size): - solution = roots(i, matrix, identity_matrix) - for j in range(len(solution)): - reversed_matrix[j][i] = solution[j] - return reversed_matrix - - -def roots(counter, matrix, identity_matrix): - size = len(matrix) - coefficients = [[0 for _ in range(size)] for _ in range(size)] - free_members = [0 for _ in range(size)] - argument_positions = [0 for _ in range(size)] - result_coefficients = [[0 for _ in range(size)] for _ in range(size)] - result_free_members = [0 for _ in range(size)] - free_members, coefficients, argument_positions = initialize_system( - free_members, identity_matrix, counter, argument_positions, coefficients, matrix) - result_free_members, free_members, coefficients, result_coefficients = direct_way( - result_free_members, free_members, coefficients, result_coefficients, argument_positions, size) - result = reverse_way(result_free_members, result_coefficients) - result, argument_positions = order_vector(result, argument_positions) - return result - - -def order_vector(result, argument_positions): - for i in range(len(result)): - if argument_positions != i: - arg = argument_positions[i] - value = result[i] - result[i] = result[arg] - result[arg] = value - argument_positions[i] = argument_positions[arg] - argument_positions[arg] = arg - return result, argument_positions - - -def direct_way(result_free_members, free_members, coefficients, result_coefficients, argument_positions, size): - for i in range(size): - coefficients, free_members, argument_positions, result_coefficients = optimize_matrix( - i, coefficients, free_members, argument_positions, result_coefficients, size) - result_free_members[i] = free_members[i] / coefficients[i][i] - for j in range(i + 1, size): - free_members[j] = free_members[j] - coefficients[j][i] * result_free_members[i] - for k in range(i + 1, size): - result_coefficients[i][k] = coefficients[i][k] / coefficients[i][i] - coefficients[j][k] = coefficients[j][k] - coefficients[j][i] * result_coefficients[i][k] - return result_free_members, free_members, coefficients, result_coefficients - - -def reverse_way(result_free_members, result_coefficients): - size = len(result_free_members) - solution = [0 for _ in range(size)] - for i in range(size -1, -1, -1): - sum = 0.0 - for j in range(i + 1, size): - sum += result_coefficients[i][j] * solution[j] - solution[i] = result_free_members[i] - sum - return solution - - -def initialize_system(free_members, identity_matrix, counter, argument_positions, coefficients, matrix): - size = len(matrix) - for i in range(size): - free_members[i] = identity_matrix[i][counter] - argument_positions[i] = i - for j in range(size): - coefficients[i][j] = matrix[i][j] - return free_members, coefficients, argument_positions - - -def optimize_matrix(r, coefficients, free_members, argument_positions, result_coefficients, size): - max_coefficient = coefficients[r][r] - max_row = r - max_col = r - for i in range(size): - for j in range(size): - if max_coefficient < abs(coefficients[i][j]): - max_coefficient = abs(coefficients[i][j]) - max_row = i - max_col = j - free_members = swap_array_values(free_members, r, max_row) - for l in range(size): - coefficients = swap_matrix_values_row(coefficients, r, max_row, l) - argument_positions = swap_argument_positions(argument_positions, r, max_col) - for m in range(size): - if m < r: - result_coefficients = swap_matrix_values_columns(result_coefficients, m, r, max_col) - else: - coefficients = swap_matrix_values_columns(coefficients, m, r, max_col) - return coefficients, free_members, argument_positions, result_coefficients - - -def swap_matrix_values_columns(matrix, r, fc, sc): - temp = matrix[r][fc] - matrix[r][fc] = matrix[r][sc] - matrix[r][sc] = temp - return matrix - - -def swap_argument_positions(argument_positions, r, max_col): - temp = argument_positions[r] - argument_positions[r] = argument_positions[max_col] - argument_positions[max_col] = temp - return argument_positions - - -def swap_array_values(free_members, fc, sc): - temp = free_members[fc] - free_members[fc] = free_members[sc] - free_members[sc] = temp - return free_members - - -def swap_matrix_values_row(matrix, fc, sc, col): - temp = matrix[fc][col] - matrix[fc][col] = matrix[sc][col] - matrix[sc][col] = temp - return matrix - - -if __name__ == '__main__': - newton_jakobi() diff --git a/numeric_lab4/rectangles.py b/numeric_lab4/rectangles.py new file mode 100644 index 0000000..d8763c1 --- /dev/null +++ b/numeric_lab4/rectangles.py @@ -0,0 +1,32 @@ +import math + + +def f(x): + return x ** 2 / math.sqrt(x ** 2 + 3) + + +def F(x): + return x / 2 * math.sqrt(x ** 2 + 3) + 3 / 2 * math.log(x + math.sqrt(x ** 2 + 3)) + + +def check(a, b): + print(abs(F(b) - F(a))) + + +def compute_right_rectangles(interactive=False): + integral = 0 + a = int(input("Enter lower bound: ")) if interactive else 1 + b = int(input("Enter upper bound: ")) if interactive else 2 + n = int(input("Enter number of divisions: ")) if interactive else 100 + h = (b - a) / n + x = a + for i in range(1, n): + integral += f(x) + x += h + integral *= h + print(integral) + check(a, b) + + +if __name__ == '__main__': + compute_right_rectangles() From 55291d9109dd5c60285a55bffd5148eb9edac99d Mon Sep 17 00:00:00 2001 From: unknown Date: Sun, 27 Dec 2020 12:39:59 +0200 Subject: [PATCH 4/5] The fifth laboratory from the subject numeric methods was added --- numeric_lab4/rectangles.py | 32 ------------------ numeric_lab5/euler-method.py | 63 ++++++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+), 32 deletions(-) delete mode 100644 numeric_lab4/rectangles.py create mode 100644 numeric_lab5/euler-method.py diff --git a/numeric_lab4/rectangles.py b/numeric_lab4/rectangles.py deleted file mode 100644 index d8763c1..0000000 --- a/numeric_lab4/rectangles.py +++ /dev/null @@ -1,32 +0,0 @@ -import math - - -def f(x): - return x ** 2 / math.sqrt(x ** 2 + 3) - - -def F(x): - return x / 2 * math.sqrt(x ** 2 + 3) + 3 / 2 * math.log(x + math.sqrt(x ** 2 + 3)) - - -def check(a, b): - print(abs(F(b) - F(a))) - - -def compute_right_rectangles(interactive=False): - integral = 0 - a = int(input("Enter lower bound: ")) if interactive else 1 - b = int(input("Enter upper bound: ")) if interactive else 2 - n = int(input("Enter number of divisions: ")) if interactive else 100 - h = (b - a) / n - x = a - for i in range(1, n): - integral += f(x) - x += h - integral *= h - print(integral) - check(a, b) - - -if __name__ == '__main__': - compute_right_rectangles() diff --git a/numeric_lab5/euler-method.py b/numeric_lab5/euler-method.py new file mode 100644 index 0000000..2f43cff --- /dev/null +++ b/numeric_lab5/euler-method.py @@ -0,0 +1,63 @@ +from math import sin, pi +import matplotlib.pylab as plt + +U_max = 100 +frequency = 50 +R1 = 5 +R2 = 4 +R3 = 7 +R4 = 2 +L1 = 0.01 +L2 = 0.02 +C1 = 300 * 10 ** -6 +h = 0.00001 + + +f = [lambda cur_time, value: (value[1]/C1), + lambda cur_time, value: (U_max * sin(2 * pi * frequency * cur_time) - value[0] - value[1]*R1 + value[2]*R2)/L1, + lambda cur_time, value: (value[1]*R1 - value[2]*R1 - value[2]*R2)/L2] + + +def output_voltage(value): + print(value[2] * R2) + return value[2] * R2 + + +def get_next_value(current_time, value, h): + next_value = value + for i in range(len(value)): + next_value[i] = value[i] + h * f[i](current_time, value) + return next_value + + +def get_results(current_time, end_time, value, h): + time_value = dict() + while current_time < end_time: + next_cur_time = current_time + h + next_value = get_next_value(current_time, value, h) + current_time = next_cur_time + value = next_value + time_value[current_time] = output_voltage(value) + return time_value + + +def main(): + start_time = 0 + end_time = 0.2 + init_values = [0, 0, 0] + + result = get_results(start_time, end_time, init_values, h) + + results_for_each_value = [] + values = [] + + for t, v in result.items(): + results_for_each_value.append(t) + values.append(v) + + plt.plot(results_for_each_value, values) + plt.show() + + +if __name__ == '__main__': + main() From 30418f71aa5ce9370f2c38278809e43613a0008b Mon Sep 17 00:00:00 2001 From: unknown Date: Fri, 1 Jan 2021 19:04:11 +0200 Subject: [PATCH 5/5] The complex work was added --- complex_lab/complex.py | 174 +++++++++++++++++++++++++++++++++++ numeric_lab5/euler-method.py | 63 ------------- 2 files changed, 174 insertions(+), 63 deletions(-) create mode 100644 complex_lab/complex.py delete mode 100644 numeric_lab5/euler-method.py diff --git a/complex_lab/complex.py b/complex_lab/complex.py new file mode 100644 index 0000000..1990547 --- /dev/null +++ b/complex_lab/complex.py @@ -0,0 +1,174 @@ +from math import ceil +import matplotlib.pylab as plt +import numpy as np + +C1 = 1 * 10 ** -3 +C2 = 2 * 10 ** -3 +L_min = 0.2 +L_max = 2 +i_min = 1 +i_max = 2 +R1 = 23 +R2 = 33 +R3 = 40 +half_period = 0.004 +period = 2 * half_period + +differential_equations = \ + [lambda time_point, value: ((input_voltage(time_point) - value[2])/C1), + lambda time_point, value: ((-value[1] * (R2 + R3))/inductance(value[1])), + lambda time_point, value: ((input_voltage(time_point) - value[2]) / C2)] + + +def draw_graph(x_arguments, y_values, title="", x_label="", y_label=""): + graph = plt.figure().gca() + graph.plot(x_arguments, y_values) + graph.set_title(title) + graph.set_xlabel(x_label) + graph.set_ylabel(y_label) + plt.show() + + +def input_voltage(time_point): + number_of_half_periods = ceil(time_point / half_period) + if number_of_half_periods % 2: + return 10 / half_period * (time_point - (number_of_half_periods - 1) * half_period) + return 0 + + +def output_voltage(value): + return value[2] + + +def inductance(current_value): + if abs(current_value) <= i_min: + return L_max + if abs(current_value) >= i_max: + return L_min + A = np.array( + [ + [1, i_min, i_min ** 2, i_min ** 3, L_max], + [1, i_max, i_max ** 2, i_max ** 3, L_min], + [0, 1, 2 * i_min, 3 * i_min ** 2, 0], + [0, 1, 2 * i_max, 3 * i_max ** 2, 0] + ]) + a = solve_lu(A) + return a[0] + a[1]*abs(current_value) + a[2]*current_value**2 + a[3]*abs(current_value**3) + + +def solve_lu(A): + n = len(A) + b = [0 for i in range(n)] + for i in range(0, n): + b[i] = A[i][n] + L = [[0 for i in range(n)] for i in range(n)] + for i in range(0, n): + L[i][i] = 1 + U = [[0 for i in range(0, n)] for i in range(n)] + for i in range(0, n): + for j in range(0, n): + U[i][j] = A[i][j] + n = len(U) + for i in range(0, n): + maxElem = abs(U[i][i]) + maxRow = i + for k in range(i + 1, n): + if abs(U[k][i]) > maxElem: + maxElem = abs(U[k][i]) + maxRow = k + for k in range(i, n): + tmp = U[maxRow][k] + U[maxRow][k] = U[i][k] + U[i][k] = tmp + for k in range(i + 1, n): + c = -U[k][i] / float(U[i][i]) + L[k][i] = c + for j in range(i, n): + U[k][j] += c * U[i][j] + for k in range(i + 1, n): + U[k][i] = 0 + n = len(L) + y = [0 for i in range(n)] + for i in range(0, n, 1): + y[i] = b[i] / float(L[i][i]) + for k in range(0, i, 1): + y[i] -= y[k] * L[i][k] + n = len(U) + x = [0 for i in range(n)] + for i in range(n - 1, -1, -1): + x[i] = y[i] / float(U[i][i]) + for k in range(i - 1, -1, -1): + U[i] -= x[i] * U[i][k] + return x + + +def get_next_value(time_point, value, step): + """Runge-Kutta""" + next_value = value + + for i in range(len(value)): + this_value = value[i] + coefficient1 = step * differential_equations[i](time_point, value) + value[i] = this_value + 1/3 * coefficient1 + coefficient2 = step * differential_equations[i](time_point + 1/3 * step, value) + value[i] = this_value - 1/3 * coefficient1 + coefficient2 + coefficient3 = step * differential_equations[i](time_point + 2/3 * step, value) + value[i] = this_value + coefficient1 - coefficient2 + coefficient3 + coefficient4 = step * differential_equations[i](time_point + step, value) + value[i] = this_value + + next_value[i] = value[i] + (coefficient1 + 3 * (coefficient2 + coefficient3) + coefficient4) / 8 + + return next_value + + +def get_results(time_point, time_interval, value, step): + time_value_pairs = dict() + time_value_pairs[time_point] = [value[0], value[1], value[2], input_voltage(time_point), output_voltage(value)] + while time_point < time_interval: + value = get_next_value(time_point, value, step) + time_point += step + time_value_pairs[time_point] = [value[0], value[1], value[2], input_voltage(time_point), output_voltage(value)] + return time_value_pairs + + +def main(): + time_point = 0 + value = [1, 1, 1] + time_interval = 5 * period + step = period / 100 + time_value_pairs = get_results(time_point, time_interval, value, step) + + time_points = [] + values_u_c1 = [] + values_u_c2 = [] + values_i_l2 = [] + values_u1 = [] + values_u2 = [] + values_of_inductance = [] + + i_interval = [] + i = 0 + while i <= i_max + 1: + i_interval.append(i) + values_of_inductance.append(inductance(i)) + i += step + + for t, v in time_value_pairs.items(): + time_points.append(t) + values_u_c1.append(v[0]) + values_u_c2.append(v[2]) + values_i_l2.append(v[1]) + values_u1.append(v[3]) + values_u2.append(v[4]) + + draw_graph(i_interval, values_of_inductance, "L2", "i, amp", "L, henry") + draw_graph(time_points, values_u1, "U1", "t, sec", "u, volt") + draw_graph(time_points, values_u_c1, "U_C1", "t, sec", "u, volt") + draw_graph(time_points, values_u_c2, "U_C2", "t, sec", "u, volt") + draw_graph(time_points, values_i_l2, "i_L2", "t, sec", "i, amp") + draw_graph(time_points, values_u2, "U2", "t, sec", "u, volt") + + +if __name__ == '__main__': + main() diff --git a/numeric_lab5/euler-method.py b/numeric_lab5/euler-method.py deleted file mode 100644 index 2f43cff..0000000 --- a/numeric_lab5/euler-method.py +++ /dev/null @@ -1,63 +0,0 @@ -from math import sin, pi -import matplotlib.pylab as plt - -U_max = 100 -frequency = 50 -R1 = 5 -R2 = 4 -R3 = 7 -R4 = 2 -L1 = 0.01 -L2 = 0.02 -C1 = 300 * 10 ** -6 -h = 0.00001 - - -f = [lambda cur_time, value: (value[1]/C1), - lambda cur_time, value: (U_max * sin(2 * pi * frequency * cur_time) - value[0] - value[1]*R1 + value[2]*R2)/L1, - lambda cur_time, value: (value[1]*R1 - value[2]*R1 - value[2]*R2)/L2] - - -def output_voltage(value): - print(value[2] * R2) - return value[2] * R2 - - -def get_next_value(current_time, value, h): - next_value = value - for i in range(len(value)): - next_value[i] = value[i] + h * f[i](current_time, value) - return next_value - - -def get_results(current_time, end_time, value, h): - time_value = dict() - while current_time < end_time: - next_cur_time = current_time + h - next_value = get_next_value(current_time, value, h) - current_time = next_cur_time - value = next_value - time_value[current_time] = output_voltage(value) - return time_value - - -def main(): - start_time = 0 - end_time = 0.2 - init_values = [0, 0, 0] - - result = get_results(start_time, end_time, init_values, h) - - results_for_each_value = [] - values = [] - - for t, v in result.items(): - results_for_each_value.append(t) - values.append(v) - - plt.plot(results_for_each_value, values) - plt.show() - - -if __name__ == '__main__': - main()