diff --git a/TEMA7/Figure_1.png b/TEMA7/Figure_1.png new file mode 100644 index 0000000..77e3024 Binary files /dev/null and b/TEMA7/Figure_1.png differ diff --git a/TEMA7/Figure_2.png b/TEMA7/Figure_2.png new file mode 100644 index 0000000..1242f73 Binary files /dev/null and b/TEMA7/Figure_2.png differ diff --git a/TEMA7/report.md b/TEMA7/report.md new file mode 100644 index 0000000..c632c39 --- /dev/null +++ b/TEMA7/report.md @@ -0,0 +1,943 @@ +\# Отчет по теме 7 + + + +Мамакин Ярослав, А-02-23 + + + +\## 1 Начало работы + + + +Запустил среду IDLE, установил рабочую папку. + + + +\## 2 Создание пользовательской функции + + + +\## 2.1 Функция без аргументов + + + +```py + +>>> def uspeh(): + +... """Подтверждение успеха операции""" + +... print('Выполнено успешно!') + +... + +>>> uspeh() + +Выполнено успешно! + +>>> type(uspeh) + + + +>>> dir() + +\['\_\_annotations\_\_', '\_\_builtins\_\_', '\_\_doc\_\_', '\_\_loader\_\_', '\_\_name\_\_', '\_\_package\_\_', '\_\_spec\_\_', 'os', 'uspeh'] + +>>> help(uspeh) + +Help on function uspeh in module \_\_main\_\_: + + + +uspeh() + +  Подтверждение успеха операции + +``` + + + +\## 2.2 Функция с аргументами + + + +```py +>>> def sravnenie(a,b): + +... """Сравнение a и b""" + +... if a>b: + +... print(a,' больше ',b) + +... elif a>> n,m=16,5;sravnenie(n,m) + +16 больше 5 + +>>> n,m='16','5';sravnenie(n,m) + +16 меньше 5 +``` + + + +\## 2.3 Функция с return + + + +```py + +>>> def logistfun(b,a): + +... """Вычисление логистической функции""" + +... import math + +... return a/(1+math.exp(-b)) + +... + +... + +>>> v,w=1,0.7;z=logistfun(w,v) + +>>> z + +0.6681877721681662 +``` + + + +\## 2.4 Сложение для разных типов аргументов + + + +```py +>>> def slozh(a1,a2,a3,a4): + +... """ Сложение значений четырех аргументов""" + +... return a1+a2+a3+a4 + +... + +>>> slozh(1,2,3,4) + +10 + +>>> slozh('1','2','3','4') + +'1234' + +>>> b1=\[1,2];b2=\[-1,-2];b3=\[0,2];b4=\[-1,-1] + +>>> q=slozh(b1,b2,b3,b4) + +>>> q + +\[1, 2, -1, -2, 0, 2, -1, -1] + +>>> b1=(1,2);b2=(-1,-2);b3=(0,2);b4=(-1,-1) + +>>> slozh(b1,b2,b3,b4) + +(1, 2, -1, -2, 0, 2, -1, -1) + +>>> b1={'a':1};b2={'b':2};b3={'c':3};b4={'d':4} + +>>> slozh(b1,b2,b3,b4) + +Traceback (most recent call last): + +  File "", line 1, in + +  slozh(b1,b2,b3,b4) + +  File "", line 3, in slozh + +  return a1+a2+a3+a4 + +TypeError: unsupported operand type(s) for +: 'dict' and 'dict' + +>>> b1={'a',1};b2={'b',2};b3={'c',3};b4={'d',4} + +>>> slozh(b1,b2,b3,b4) + +Traceback (most recent call last): + +  File "", line 1, in + +  slozh(b1,b2,b3,b4) + +  File "", line 3, in slozh + +  return a1+a2+a3+a4 + +TypeError: unsupported operand type(s) for +: 'set' and 'set' +``` + + + +\## 2.5 Модель устройства + + + +```py +>>> def inerz(x,T,ypred): + +... """ Модель устройства с памятью: + +... x- текущее значение вх.сигнала, + +... T -постоянная времени, + +... ypred - предыдущее значение выхода устройства""" + +... y=(x+T\*ypred)/(T+1) + +... return y + +... + +>>> sps=\[0]+\[1]\*100 + +>>> spsy=\[] + +>>> TT=20 + +>>> yy=0 + +>>> for xx in sps: + +... yy=inerz(xx,TT,yy) + +... spsy.append(yy) + +... + +>>> import matplotlib.pyplot as plt + +>>> plt.plot(spsy) + +\[] + +>>> plt.title('Сигнал на выходе устройства') + +Text(0.5, 1.0, 'Сигнал на выходе устройства') +``` + +!\[График](Figure\_1.png) + + + +\## 3 Функции как объекты + + + +\## 3.1 Список атрибутов + + + +```py + +>>> dir(inerz) + +\['\_\_annotations\_\_', '\_\_builtins\_\_', '\_\_call\_\_', '\_\_class\_\_', '\_\_closure\_\_', '\_\_code\_\_', '\_\_defaults\_\_', '\_\_delattr\_\_', '\_\_dict\_\_', '\_\_dir\_\_', '\_\_doc\_\_', '\_\_eq\_\_', '\_\_format\_\_', '\_\_ge\_\_', '\_\_get\_\_', '\_\_getattribute\_\_', '\_\_getstate\_\_', '\_\_globals\_\_', '\_\_gt\_\_', '\_\_hash\_\_', '\_\_init\_\_', '\_\_init\_subclass\_\_', '\_\_kwdefaults\_\_', '\_\_le\_\_', '\_\_lt\_\_', '\_\_module\_\_', '\_\_name\_\_', '\_\_ne\_\_', '\_\_new\_\_', '\_\_qualname\_\_', '\_\_reduce\_\_', '\_\_reduce\_ex\_\_', '\_\_repr\_\_', '\_\_setattr\_\_', '\_\_sizeof\_\_', '\_\_str\_\_', '\_\_subclasshook\_\_', '\_\_type\_params\_\_'] + +>>> inerz.\_\_doc\_\_ + +'Модель устройства с памятью:\\nx- текущее значение вх.сигнала,\\n T -постоянная времени,\\n ypred - предыдущее значение выхода устройства' + +>>> help(inerz) + +Help on function inerz in module \_\_main\_\_: + + + +inerz(x, T, ypred) + +  Модель устройства с памятью: + +  x- текущее значение вх.сигнала, + +  T -постоянная времени, + +  ypred - предыдущее значение выхода устройства + +``` + + + +\## 3.2 Сохранение ссылки на объект-функцию в другой переменной + + + +```py +>>> fnkt = sravnenie + +>>> v=16 + +>>> fnkt(v,23) + +16 меньше 23 +``` + + + +\## 3.3 Возможность альтернативного определения функции в программе + + + +```py +>>> typ\_fun=8 + +>>> if typ\_fun==1: + +... def func(): + +... print('Функция 1') + +... else: + +... def func(): + +... print('Функция 2') + +... + +>>> func() + +Функция 2 +``` + + + +\## 4 Аргументы функции + + + +\## 4.1 Использование функции в качестве аргумента другой функции + + + +```py + +>>> def fun\_arg(fff,a,b,c): + +... """fff-имя функции, используемой + +... в качестве аргумента функции fun\_arg""" + +... return a+fff(c,b) + +... + +>>> zz=fun\_arg(logistfun,-3,1,0.7) + +>>> zz + +-2.3318122278318336 + +``` + + + +\## 4.2 Обязательные и необязательные аргументы + + + +```py +>>> def logistfun(a,b=1): #Аргумент b – необязательный; значение по умолчанию=1 + +... """Вычисление логистической функции""" + +... import math + +... return b/(1+math.exp(-a)) + +... + +>>> logistfun(0.7) + +0.6681877721681662 + +>>> logistfun(0.7,2) + +1.3363755443363323 +``` + + + +\## 4.3 Обращение к функции с произвольным (непозиционным) расположением аргументов + + + +```py +logistfun(b=0.5,a=0.8) + +0.34498724056380625 +``` + + + +\## 4.4 Значения аргументов функции, содержащиеся в списке или кортеже + + + +```py +>>> b1=\[1,2];b2=\[-1,-2];b3=\[0,2];b4=\[-1,-1] + +>>> b1234=\[b1,b2,b3,b4] + +>>> qq=slozh(\*b1234) + +>>> qq + +\[1, 2, -1, -2, 0, 2, -1, -1] +``` + + + +\## 4.5 Значения аргументов функции, содержащиеся в словаре + + + +```py +>>> dic4={"a1":1,"a2":2,"a3":3,"a4":4} + +>>> qqq=slozh(\*\*dic4) + +>>> qqq + +10 +``` + + + +\## 4.6 Смешанные ссылки + + + +```py +>>> e1=(-1,6);dd2={'a3':3,'a4':9} + +>>> qqqq=slozh(\*e1,\*\*dd2) + +>>> qqqq + +17 +``` + + + +\## 4.7 Переменное число аргументов у функции + + + +```py +>>> def func4(\*kort7): + +... """Произвольное число аргументов в составе кортежа""" + +... smm=0 + +... for elt in kort7: + +... smm+=elt + +... return smm + +... + +>>> func4(-1,2) + +1 + +>>> func4(-1,2,0,3,6) + +10 +``` + + + +\## 4.8 Комбинация аргументов + + + +```py +def func4(a,b=7,\*kort7): #Аргументы: a-позиционный, b- по умолчанию + кортеж + +  """Кортеж - сборка аргументов - должен быть последним!""" + +  smm=0 + +  for elt in kort7: + +  smm+=elt + +  return a\*smm+b + + + +func4(-1,2,0,3,6) + +-7 +``` + + + +\## 4.9 Изменение значений объектов, используемых в качестве аргументов функции + + + +```py +>>> a=90 + +>>> def func3(b): + +... b=5\*b+67 + +... + +>>> func3(a) + +>>> a + +90 + +>>> sps1=\[1,2,3,4] + +>>> def func2(sps): + +... sps\[1]=99 + +... + +>>> func2(sps1) + +>>> print(sps1) + +\[1, 99, 3, 4] + +>>> kort=(1,2,3,4) + +>>> func2(kort) + +Traceback (most recent call last): + +  File "", line 1, in + +  func2(kort) + +  File "", line 2, in func2 + +  sps\[1]=99 + +TypeError: 'tuple' object does not support item assignment +``` + + + +\## 5 Специальные типы пользовательских функций + + + +\## 5.1 Анонимные функции + + + +```py + +>>> import math + +>>> anfun1=lambda: 1.5+math.log10(17.23) + +>>> anfun1() + +2.7362852774480286 + +>>> anfun2=lambda a,b : a+math.log10(b) + +>>> anfun2(17,234) + +19.369215857410143 + +>>> anfun3=lambda a,b=234: a+math.log10(b) + +>>> anfun3(100) + +102.36921585741014 + +``` + + + +\## 5.2 Функции-генераторы + + + +```py +>>> def func5(diap,shag): + +... """ Итератор, возвращающий значения + +... из диапазона от 1 до diap с шагом shag""" + +... for j in range(1,diap+1,shag): + +... yield j + +... + +>>> for mm in func5(7,3): + +... print(mm) + +... + +1 + +4 + +7 + +>>> alp=func5(7,3) + +>>> print(alp.\_\_next\_\_()) + +1 + +>>> print(alp.\_\_next\_\_()) + +4 + +>>> print(alp.\_\_next\_\_()) + +7 +``` + + + +\## 6 Локализация объектов в функциях + + + +\## 6.1 Примеры локализации + + + +```py + +>>> glb = 10 + +>>> def func7(arg): + +... loc1=15 + +... glb=8 + +... return loc1\*arg + +... + +>>> res=func7(glb) + +>>> glb + +10 + +>>> def func8(arg): + +... loc1=15 + +... print(glb) + +... glb=8 + +... return loc1\*arg + +... + +>>> res=func8(glb) + +Traceback (most recent call last): + +  File "", line 1, in + +  res=func8(glb) + +  File "", line 3, in func8 + +  print(glb) + +UnboundLocalError: cannot access local variable 'glb' where it is not associated with a value + +\# Переменная glb не объявлена внутри функции + +>>> glb=11 + +>>> def func7(arg): + +... loc1=15 + +... global glb + +... print(glb) + +... glb=8 + +... return loc1\*arg + +... + +>>> res=func7(glb) + +11 + +>>> glb + +8 + +``` + + + +\## 6.2 Выявление локализации объекта с помощью функций locals() и globals() из builtins + + + +```py +>>> globals().keys() + +dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) + +>>> locals().keys() + +dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) + +>>> # Текущая область - глобальная + +>>> def func8(arg): + +... loc1=15 + +... glb=8 + +... print(globals().keys()) #Перечень глобальных объектов «изнутри» функции + +... print(locals().keys()) #Перечень локальных объектов «изнутри» функции + +... return loc1\*arg + +... + +>>> hh = func8(glb) + +dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8']) + +dict\_keys(\['arg', 'loc1', 'glb']) + +>>> # Во втором списке - локальные объекты, использующиеся при работе функции func8 + +>>> 'glb' in globals().keys() + +True +``` + + + +\## 6.3 Локализация объектов при использовании вложенных функций + + + +```py +>>> def func9(arg2,arg3): + +... def func9\_1(arg1): + +... loc1=15 + +... glb1=8 + +... print('glob\_func9\_1:',globals().keys()) + +... print('locl\_func9\_1:',locals().keys()) + +... return loc1\*arg1 + +... loc1=5 + +... glb=func9\_1(loc1) + +... print('loc\_func9:',locals().keys()) + +... print('glob\_func9:',globals().keys()) + +... return arg2+arg3\*glb + +... + +>>> kk=func9(10,1) + +glob\_func9\_1: dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) + +locl\_func9\_1: dict\_keys(\['arg1', 'loc1', 'glb1']) + +loc\_func9: dict\_keys(\['arg2', 'arg3', 'func9\_1', 'loc1', 'glb']) + +glob\_func9: dict\_keys(\['\_\_name\_\_', '\_\_doc\_\_', '\_\_package\_\_', '\_\_loader\_\_', '\_\_spec\_\_', '\_\_annotations\_\_', '\_\_builtins\_\_', 'os', 'uspeh', 'sravnenie', 'n', 'm', 'logistfun', 'v', 'w', 'z', 'slozh', 'b1', 'b2', 'b3', 'b4', 'q', 'inerz', 'sps', 'spsy', 'TT', 'yy', 'xx', 'plt', 'fnkt', 'typ\_fun', 'func', 'fun\_arg', 'zz', 'b1234', 'qq', 'dic4', 'qqq', 'e1', 'dd2', 'qqqq', 'func4', 'a', 'func3', 'sps1', 'func2', 'kort', 'anfun1', 'math', 'anfun2', 'anfun3', 'func5', 'mm', 'alp', 'glb', 'func7', 'res', 'func8', 'hh', 'func9']) + +>>> # Списки глобальных объектов совпадают, локальные объекты доступны только внутри соответствующих функций +``` + + + +\## 6.4 Пример моделирования системы + + + +```py + +>>> import math + +>>> znach=input('k1,T,k2,Xm,A,F,N=').split(',') + +k1,T,k2,Xm,A,F,N=2,10,3,1,5,0.025,30 + +>>> k1=float(znach\[0]) + +>>> T=float(znach\[1]) + +>>> k2=float(znach\[2]) + +>>> Xm=float(znach\[3]) + +>>> A=float(znach\[4]) + +>>> F=float(znach\[5]) + +>>> N=int(znach\[6]) + +>>> vhod=\[] + +>>> for i in range(N): + +... vhod.append(A\*math.sin((2\*i\*math.pi)\*F)) + +... + +>>> vhod + +\[0.0, 0.7821723252011543, 1.545084971874737, 2.2699524986977337, 2.938926261462366, 3.5355339059327378, 4.045084971874737, 4.455032620941839, 4.755282581475767, 4.938441702975689, 5.0, 4.938441702975689, 4.755282581475768, 4.4550326209418385, 4.045084971874737, 3.5355339059327378, 2.9389262614623664, 2.2699524986977324, 1.5450849718747375, 0.7821723252011549, 6.123233995736766e-16, -0.7821723252011559, -1.5450849718747364, -2.2699524986977333, -2.938926261462365, -3.5355339059327386, -4.04508497187474, -4.455032620941839, -4.755282581475767, -4.938441702975688] + +>>> def realdvig(xtt,kk1,TT,yti1,ytin1): + +... #Модель реального двигателя + +... yp=kk1\*xtt #усилитель + +... yti1=yp+yti1 #Интегратор + +... ytin1=(yti1+TT\*ytin1)/(TT+1) + +... return \[yti1,ytin1] + +... + +>>> def tahogen(xtt,kk2,yti2): + +... #Модель тахогенератора + +... yp=kk2\*xtt #усилитель + +... yti2=yp+yti2 #интегратор + +... return yti2 + +... + +... + +>>> def nechus(xtt,gran): + +... #зона нечувствит + +... if xtt(-gran): + +... ytt=0 + +... elif xtt>=gran: + +... ytt=xtt-gran + +... elif xtt<=(-gran): + +... ytt=xtt+gran + +... return ytt + +... + +>>> yi1=0;yin1=0;yi2=0 + +>>> vyhod=\[] + +>>> for xt in vhod: + +... xt1=xt-yi2 #отрицательная обратная связь + +... \[yi1,yin1]=realdvig(xt1,k1,T,yi1,yin1) + +... yi2=tahogen(yin1,k2,yi2) + +... yt=nechus(yin1,Xm) + +... vyhod.append(yt) + +... + +... + +>>> print('y=',vyhod) + +y= \[0, 0, 0, 0, 0, 0, 0, -1.299465163446989, -1.3579959054305797, 0, 3.7144096317728987, 7.811411673609909, 6.5646766889828605, -1.7207792337901524, -18.81372872718616, -31.38046599103643, -22.278866622819873, 17.097152611947436, 77.81058529582174, 112.97718138176809, 62.60779574768801, -98.35894773519156, -309.62984734263415, -395.51094806311954, -151.2442551724449, 474.0906424325323, 1190.4363664389593, 1337.7521059074418, 237.48484712636358, -2125.064719245332] + +>>> import matplotlib.pyplot as plt + +>>> plt.plot(vyhod) + +\[] + +``` + +!\[График2](Figure\_2.png) + + + + + + + + + + + + + + + + + + + diff --git a/TEMA7/task.md b/TEMA7/task.md new file mode 100644 index 0000000..5a91dcf --- /dev/null +++ b/TEMA7/task.md @@ -0,0 +1,114 @@ +\# Общее контрольное задание по теме 7 + + + +Мамакин Ярослав, А-02-23 + + + +\## Задание + + + +• Разработайте и проверьте функцию, реализующую для момента времени t расчет выхода y(t) для устройства задержки: на вход поступает сигнал, а на выходе повторяется этот сигнал с за-держкой на заданное время Т. + +• Разработайте и проверьте функцию, реализующую расчет гистограммы по выборке случайной величины с каким-то распределением. Гистограмма при выводе на экран представляется в виде таблицы: границы интервала, число элементов выборки в интервале. Аргументы функции: вы-борка, число интервалов разбиения диапазона изменения случайной величины. Возвращаемый результат функции: список с числами элементов выборки в интервалах разбиения. + +• Разработайте и проверьте анонимную функцию, вычисляющую значение оценки отклика Y ли-нейной регрессии при значении переменной Х + +Y=b1+b2\*X + +и имеющую аргументы b1, b2 и X. + + + +\## Решение + + + +```py + +>>> def zaderz(vhod, T): + +... """Функция задержки + +... Входной сигнал - vhod + +... Время задержки - T""" + +... return \[0] \* T + vhod + +... + +>>> x = \[1, 2, 4, 8, 16] + +>>> T = 5 + +>>> zaderz(x, T) + +\[0, 0, 0, 0, 0, 1, 2, 4, 8, 16] + + + + + +>>> def histogram(x, n\_bins): + +... low\_end = min(x) + +... high\_end = max(x) + +... bin\_w = (high\_end - low\_end) / n\_bins + +... bins = \[] + +... for i in range(n\_bins): + +... lower = low\_end + i \* bin\_w + +... upper = low\_end + (i + 1) \* bin\_w + +... bins.append(len(list(filter(lambda j: lower <= j and j < upper, x)))) + +... if i == n\_bins - 1: + +... bins\[i] += 1 + +... print(f"Интервал №{i + 1}: Нижняя граница: {lower} Верхняя граница: {upper} Число элементов: {bins\[i]}") + +... return bins + +... + +>>> x = \[random.uniform(5, 10) for i in range(100)] + +>>> n\_elem = histogram(x, 5) + +Интервал №1: Нижняя граница: 5.008028779046062 Верхняя граница: 5.9894754634094 Число элементов: 16 + +Интервал №2: Нижняя граница: 5.9894754634094 Верхняя граница: 6.97092214777274 Число элементов: 21 + +Интервал №3: Нижняя граница: 6.97092214777274 Верхняя граница: 7.952368832136078 Число элементов: 19 + +Интервал №4: Нижняя граница: 7.952368832136078 Верхняя граница: 8.933815516499417 Число элементов: 20 + +Интервал №5: Нижняя граница: 8.933815516499417 Верхняя граница: 9.915262200862756 Число элементов: 24 + +>>> print(n\_elem) + +\[16, 21, 19, 20, 24] + + + + + +>>> regression = lambda x, b1, b2: b1 + b2 \* x + +>>> regression(4, 8, 0.5) + +10.0 + + + +``` +