Борисенко Даниїл

ПІ-20-1
Алгоритм та структури даних
Лабораторна робота №1
Тема: Розв’язання нелінійних та трансцендентних рівнянь.
Мета роботи – знайти приблизне значення дійсних коренів
алгебраїчних та трансцендентних рівнянь чисельними
методами.
Дано: a = 0,3; b=1.2; Eпсилон = 0.002;
Функція F(x) = x**2 - 2*x**4 - 2*x**5 + 4
Код:
# -*- coding:1251 -*-
from cmath import sin
from math import cos
import math

a = 0.4;
b = 1.6;
e = 0.007;
def f(x):
return x**2 - 2*x**4 - 2*x**5 + 4
y1 = f(a);
y2 = f(b);
if y1 * y2 >= 0:
print ("Корнів нема")
else:
n=1
x = (a+b)/2
y3 = f(x)
while (abs(y3) > e):
x = (a+b)/2
y3 = f(x);
if y1 * y3 < 0:
b=x
else:
a=x
n += 1
print ("x = %15.10f" % (x))
print ("y = %15.10f" % (y3))

if __name__ == '__main__':
print ("Готово!")

Результат:
============ RESTART: C:\Users\Asus\Desktop\Даниил Борисенко\test.py ===========
x = 1.0562500000
y = -0.0031905977
Готово!
>>>
 Лабораторна робота №2
Інтеграл Трапеція
Завдання: Знайти площадь Трапеції
Дано: a = 3, b = 4, n = 2
Функція: F(x) = x/(x**4+4)
Текст за допомогою Python
Код:
# -*- coding:cp1251 -*-
import math
def f(x):
return x / (x**4 + 4)

def sympson(a, b, n, function):

h = (b - a) / (2 * n)

tmp_sum = function(a) + function(b)

for step in range(1, 2 * n):

if step % 2 != 0:
tmp_sum += 4 * function(a + step * h)
else:
tmp_sum += 2 * function(a + step * h)

return tmp_sum * h / 3

def trapezian(a, b, n, function):

h = (b - a) / (n)

return (function(a) + function(b) +

sum(function(a + step * h) for step in range(1, n))) * h

print("Відповідь по Симпсону:",(sympson(3,4, 2, f)))

print("Відповідь по Трапеції:",(trapezian(3,4,2, f)))

Результат:
Відповідь по Симпсону: 0.02357935654905403
Відповідь по Трапеції: 0.03669839288500546

Лабораторна робота № 3
 Апроксимація. Метод мінімальних квадратів
Завдання: Знайти такі коефіцієнти a,b, щоб мінімізувати
функціонал або знайти наближену функцію.
Дано: а = 1, b = 3, h = 0.3 y1 = 5 y2 = 3
Функція: f(y)= 1/x
Код:
#!/usr/bin/python
# -*- coding: utf-8 -*
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams['font.family'] = 'fantasy'
def mnkGP(x,y): # функция которую можно использзовать в програме
n=len(x) # количество элементов в списках
s=sum(y) # сумма значений y
s1=sum([1/x[i] for i in range(0,n)]) # сумма 1/x
s2=sum([(1/x[i])**2 for i in range(0,n)]) # сумма (1/x)**2
s3=sum([y[i]/x[i] for i in range(0,n)]) # сумма y/x
a= round((s*s2-s1*s3)/(n*s2-s1**2),3) # коэфициент а с тремя дробными цифрами
b=round((n*s3-s1*s)/(n*s2-s1**2),3)# коэфициент b с тремя дробными цифрами
s4=[a+b/x[i] for i in range(0,n)] # список значений гиперболической функции
so=round(sum([abs(y[i] -s4[i]) for i in range(0,n)])/(n*sum(y))*100,3) # средняя
ошибка аппроксимации
plt.title('Аппроксимация гиперболой Y='+str(a)+'+'+str(b)+'/x\n Средняя
ошибка--'+str(so)+'%',size=14)
plt.xlabel('Координата X', size=14)
plt.ylabel('Координата Y', size=14)
plt.plot(x, y, color='r', linestyle=' ', marker='o', label='Data(x,y)')
plt.plot(x, s4, color='g', linewidth=2, label='Data(x,f(x)=a+b/x')
plt.legend(loc='best')
plt.grid(True)
plt.show()
x=[10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86]
y=[0.1, 0.0714, 0.0556, 0.0455, 0.0385, 0.0333, 0.0294, 0.0263, 0.0238, 0.0217,
0.02, 0.0185, 0.0172, 0.0161, 0.0152, 0.0143, 0.0135, 0.0128, 0.0122, 0.0116] # данные для
проверки по функции y=1/x
mnkGP(x,y)

if __name__ == '__main__':
riso4ka = '='*63
print(riso4ka)
print("exzamens_for_ASD_for_is_six_C.py")
print("Готово, создатель")
print(riso4ka)

Результат:
 Лабораторна робота №4
Інтерполяція. Метод Лагранжа
Завдання: Написати програму для обчислення значень інтерполяційного багаточлена
Лагранжа.
Дано: x = 0.54
x_1 = [0.4, 0.5, 0.6, 0.7, 0.8]
y_1 = [-0.9163, -0.6931, -0.5108, -0.3567, -0.2231]
n= 5
Код:
import math

# ====================================================== == лагранжевая
интерполяция ==================================================
===================
def lagrange(x_, y, a):
"""
Получить лагранжеву интерполяцию
: param x_: список значений x
: param y: список значений y
: param a: число для интерполяции
: return: вернуть результат интерполяции
"""
ans = 0.0
for i in range(len(y)):
t_ = y[i]
for j in range(len(y)):
if i != j:
t_ *= (a - x_[j]) / (x_[i] - x_[j])
ans += t_
return ans

# ====================================================== == Ньютоновская
интерполяция =================================================
===================
def table(x_, y):
"""
Получить таблицу интерполяции Ньютона
: param x_: значение списка x
: param y: значение списка y
: return: вернуть таблицу интерполяции
"""
quotient = [[0] * len(x_) for _ in range(len(x_))]
for n_ in range(len(x_)):
quotient[n_][0] = y[n_]
 for i in range(1, len(x_)):
for j in range(i, len(x_)):
# j-i определяет диагональные элементы
quotient[j][i] = (quotient[j][i - 1] - quotient[j - 1][i - 1]) / (x_[j] - x_[j - i])
return quotient

def get_corner(result):
"""
Получить диагональные элементы через таблицу интерполяции
: param result: результат таблицы интерполяции
: return: диагональный элемент
"""
link = []
for i in range(len(result)):
link.append(result[i][i])
return link

if __name__ == '__main__':
x = 0.54
x_1 = [0.4, 0.5, 0.6, 0.7, 0.8]
y_1 = [-0.9163, -0.6931, -0.5108, -0.3567, -0.2231]
middle = table(x_1, y_1)
n = get_corner(middle)
lagrange = lagrange(x_1, y_1, 0.54)
print("Истинное значение: {}".format(math.log(0.54, math.e)))
print("Лагранжева интерполяция: {}".format(lagrange))
Результат:
Истинное значение: -0.616186139423817
Лагранжева интерполяция: -0.6160951999999998

Лабораторна робота №5
Інтерполяція
Мета інтерполяції — знаходження значення
таблично заданої функції у тих точках усередині
даного інтервалу, де не задана.
Дано: x = [5, 10, 20 ,40 , 80, 160, 350]
y = [0.1, 5, 10, 20, 40, 80, 160]
Код:
import numpy as np
from scipy import interpolate
ro = 12
xi = 9.17

Table_11_6_x = [5, 10, 20 ,40 , 80, 160, 350]

Table_11_6_y = [0.1, 5, 10, 20, 40, 80, 160]

st1 = [0.95, 0.92, 0.88, 0.83, 0.76, 0.67, 0.56]

st2 = [0.89, 0.87, 0.84, 0.8, 0.73, 0.65, 0.54]
st3 = [0.85, 0.84, 0.81, 0.77, 0.71, 0.64, 0.53]
st4 = [0.8, 0.78, 0.76, 0.73, 0.68, 0.61, 0.51]
st5 = [0.72, 0.72, 0.7, 0.67, 0.63, 0.57, 0.48]
st6 = [0.63, 0.63, 0.61, 0.59, 0.56, 0.51, 0.44]
st7 = [0.53, 0.53, 0.52, 0.5, 0.47, 0.44, 0.38]

Table_11_6 = np. array([st1, st2, st3, st4, st5, st6, st7])

f = interpolate.interpn((Table_11_6_x, Table_11_6_y), Table_11_6, (ro, xi),

method = 'splinef2d')
print("Функція інтерполяції:",f)
Результат: Функція інтерполяції: 0.834993965293296

Лабораторна робота №6
Диференціальная рівняння
Завдання: Знайти x та y в диференціальному
рівнянні за допомогою формула Ейлера
Дано: n = 5, h = 0.03, x = 2, y = -5
Код:
# n - кількість, h - шаг, (x, y) - начальная точка
def Euler(n = 5, h = 0.03, x = 2, y = -5):
for i in range(n):
y += h * function(x, y)
x += h
return x, y # решение

def function(x, y):

 return 3 * x**2 + 8 * x * y # функция первой производной

print(Euler())

Результат:
(x = 2.149999999999999, y = -32.329606718999884)