{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Классная работа"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func2.** Описать функцию `root_count(a, b, c)` целого типа, определяющую количество корней квадратного уравнения $ax^2 + bx + c = 0$ (a, b, c — вещественные параметры, a ≠ 0). С её помощью найти количество корней для каждого из трех квадратных уравнений с данными коэффициентами. Количество корней определять по значению дискриминанта:\n",
    "$D = b^2 − 4ac$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def root_count(a,b,c):\n",
    "    return 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " a = 1\n",
      " b = 2\n",
      " c = 3\n",
      "кол-во корней для квадратного уравнения с данными коэффициентами = 1\n",
      " a = 2\n",
      " b = 3\n",
      " c = 1\n",
      "кол-во корней для квадратного уравнения с данными коэффициентами = 1\n",
      " a = 1\n",
      " b = 0\n",
      " c = 0\n",
      "кол-во корней для квадратного уравнения с данными коэффициентами = 1\n"
     ]
    }
   ],
   "source": [
    "#основная программа\n",
    "for i in range(3):\n",
    "    a = int(input(\" a = \"))\n",
    "    b = int(input(\" b = \"))\n",
    "    c = int(input(\" c = \")) \n",
    "    print(f'кол-во корней для квадратного уравнения с данными коэффициентами = {root_count(a,b,c)}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert root_count(1,0,0)==1, \"Test 1\"\n",
    "assert root_count(1,0,-1)==2, \"Test 2\"\n",
    "assert root_count(1,2,10)==0, \"Test 3\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func3.** Описать функцию `CircleS(R)` вещественного типа, находящую площадь круга радиуса $R$ ($R$ — вещественное). С помощью этой функции найти площади трех кругов с данными радиусами. Площадь круга радиуса $R$ вычисляется по формуле $S = π·R^2$. В качестве значения $π$ использовать 3.14 (или math.pi)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "#описание функции\n",
    "\n",
    "def CircleS(R):\n",
    "    return R*R*math.pi\n",
    "\n",
    "\n",
    "#основная программа\n",
    "\n",
    "print (CircleS(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert CircleS(1)==math.pi, \"Test 1\"\n",
    "assert CircleS(0)==0, \"Test 2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func5.** Описать функцию `TriangleP(a, h)`, находящую периметр равнобедренного треугольника по его основанию $a$ и высоте $h$, проведенной к основанию ($a$ и $h$ — вещественные). С помощью этой функции найти периметры трех треугольников, для которых даны основания и высоты. Для нахождения боковой стороны $b$ треугольника использовать теорему Пифагора: $b^2 = (a/2)^2 + h^2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def TriangleP(a,h):\n",
    "    ...\n",
    "\n",
    "#основная программа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert TriangleP(6,4)==16, \"Test 1\"\n",
    "assert TriangleP(4,3)==2*math.sqrt(13)+4, \"Test 2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func13.** Описать функцию `IsPrime(N)` логического типа, возвращающую True, если целый параметр N (> 1) является простым числом, и False в противном случае (число, большее 1, называется простым, если оно не имеет положительных делителей, кроме 1 и самого себя). Дан набор из 10 целых чисел, больших 1. С помощью функции `IsPrime` найти количество простых чисел в данном наборе."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def IsPrime(N):\n",
    "    ...\n",
    "\n",
    "#основная программа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert IsPrime(5)==True, \"Test 1\"\n",
    "assert IsPrime(25)==False, \"Test 2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func20.**  Описать функцию `Fact2(N)` вещественного типа, вычисляющую двойной факториал:\n",
    "\n",
    "N!! = 1·3·5·…·N,    если N — нечетное;\n",
    "N!! = 2·4·6·…·N,    если N — четное\n",
    "\n",
    "(N > 0 — параметр целого типа; вещественное возвращаемое значение используется для того, чтобы избежать целочисленного переполнения при больших значениях N). С помощью этой функции найти двойные факториалы пяти данных целых чисел."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def Fact2(N):\n",
    "    ...\n",
    "\n",
    "#основная программа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert Fact2(5)==15., \"Test 1\"\n",
    "assert Fact2(6)==48., \"Test 2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func28.** Описать функцию `InvDigits(K)`, меняющую порядок следования цифр целого положительного числа K на обратный и возвращающую полученное число (K — параметр целого типа). С помощью этой функции поменять порядок следования цифр на обратный для каждого из пяти данных целых чисел."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def InvDigits(K):\n",
    "    ...\n",
    "\n",
    "#основная программа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert InvDigits(123)==321, \"Test 1\"\n",
    "assert InvDigits(500)==5, \"Test 2\"\n",
    "assert InvDigits(1203)==3021, \"Test 3\"\n",
    "assert InvDigits(1)==1, \"Test 4\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func40.** Описать функцию `Exp1(x, ε)` вещественного типа (параметры x, ε — вещественные, ε > 0), находящую приближенное значение функции exp(x):\n",
    "\n",
    "$exp(x) = 1 + x + x^2/(2!) + x^3/(3!) + … + x^n/(n!) + …$\n",
    "\n",
    "(n! = 1·2·…·n). В сумме учитывать все слагаемые, большие ε. С помощью Exp1 найти приближенное значение экспоненты для данного x при шести данных ε."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def Exp1(x, e):\n",
    "    res = 0\n",
    "    elem = 1\n",
    "    i = 1\n",
    "    while abs(elem) >= e:\n",
    "        res += elem\n",
    "        elem *= x / i\n",
    "        i += 1\n",
    "    return res\n",
    "\n",
    "#основная программа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "from math import exp\n",
    "\n",
    "assert abs(Exp1(0.5, 1e-6) - exp(0.5)) < 1e-6, \"Test 1_1\"\n",
    "assert abs(Exp1(0.5, 1e-6) - 1.6487211681547618) < 1e-6, \"Test 1_2\"\n",
    "\n",
    "assert abs(Exp1(1.0, 1e-2) - exp(1.0)) < 1e-2, \"Test 2_1\"\n",
    "assert abs(Exp1(1.0, 1e-2) - 2.708333333333333) < 1e-2, \"Test 2_2\"\n",
    "\n",
    "assert abs(Exp1(1.0, 1e-10) - exp(1.0)) < 1e-10, \"Test 3_1\"\n",
    "assert abs(Exp1(1.0, 1e-10) - 2.7182818284467594) < 1e-10, \"Test 3_2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Домашняя работа"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func10.** Описать функцию `IsSquare(K)` логического типа, возвращающую True, если целый параметр K (> 0) является квадратом некоторого целого числа, и False в противном случае. С ее помощью найти количество квадратов в наборе из 10 целых положительных чисел."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def IsSquare(K):\n",
    "    ...\n",
    "\n",
    "#основная программа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert IsSquare(1)==True, \"Test 1\"\n",
    "assert IsSquare(2)==False, \"Test 2\"\n",
    "assert IsSquare(4)==True, \"Test 3\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func14.** Описать функцию `DigitCount(K)` целого типа, находящую количество цифр целого положительного числа K. Используя эту функцию, найти количество цифр для каждого из пяти данных целых положительных чисел."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def DigitCount(K):\n",
    "    ...\n",
    "\n",
    "#основная программа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert DigitCount(123)==3, \"Test 1\"\n",
    "assert DigitCount(1)==1, \"Test 2\"\n",
    "assert DigitCount(10000)==5, \"Test 3\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func21.** Описать функцию `Fib(N)` целого типа, вычисляющую N-й элемент последовательности чисел Фибоначчи $F_K$, которая описывается следующими формулами:\n",
    "\n",
    "$F_1 = 1$,        $F_2 = 1$,        $F_K = F_{K−2} + F_{K−1},    K = 3, 4, … .$\n",
    "\n",
    "Используя функцию Fib, найти пять чисел Фибоначчи с данными номерами $N_1, N_2, …, N_5$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def Fib(N):\n",
    "    ...\n",
    "\n",
    "#основная программа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert Fib(3)==2, \"Test 1\"\n",
    "assert Fib(2)==1, \"Test 2\"\n",
    "assert Fib(1)==1, \"Test 3\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func41.** Описать функцию `Sin1(x, ε)` вещественного типа (параметры x, ε — вещественные, ε > 0), находящую приближенное значение функции sin(x):\n",
    "\n",
    "$sin(x) = x − x^3/(3!) + x^5/(5!) − … + (−1)^n·x^{2·n+1}/((2·n+1)!) + … .$\n",
    "\n",
    "В сумме учитывать все слагаемые, модуль которых больше ε. С помощью Sin1 найти приближенное значение синуса для данного x при шести данных ε."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def Sin1(x, e):\n",
    "    ...\n",
    "#основная программа "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "from math import sin\n",
    "\n",
    "assert abs(Sin1(-0.7, 1e-6) - sin(-0.7)) < 1e-6, \"Test 1_1\"\n",
    "assert abs(Sin1(-0.7, 1e-6) - (-0.6442175765277778) ) < 1e-6, \"Test 1_2\"\n",
    "\n",
    "assert abs(Sin1(1.0, 1e-2) - sin(1.0)) < 1e-2, \"Test 2_1\"\n",
    "assert abs(Sin1(1.0, 1e-2) - 0.8333333333333334) < 1e-2, \"Test 2_2\"\n",
    "\n",
    "assert abs(Sin1(1.0, 1e-10) - sin(1.0)) < 1e-10, \"Test 3_1\"\n",
    "assert abs(Sin1(1.0, 1e-10) - 0.8414709848086585) < 1e-10, \"Test 3_2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func56.** Описать функцию `Leng(xA, yA, xB, yB)` вещественного типа, находящую длину отрезка AB на плоскости по координатам его концов:\n",
    "\n",
    "$|AB| = ((x_A − x_B)^2 + (y_A − y_B)^2)^{1/2}$\n",
    "\n",
    "($x_A, y_A, x_B, y_B$ — вещественные параметры). С помощью этой функции найти длины отрезков AB, AC, AD, если даны координаты точек A, B, C, D."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#описание функции\n",
    "def Leng(xA, yA, xB, yB):\n",
    "    ...\n",
    "#основная программа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#тестирование функции\n",
    "assert Leng(0,0,1,0)==1, \"Test 1\"\n",
    "assert Leng(0,0,1,1)==math.sqrt(2), \"Test 2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Func57.** Используя функцию `Leng` из задания Func56, описать функцию `Perim(xA, yA, xB, yB, xC, yC)` вещественного типа, находящую периметр треугольника ABC по координатам его вершин ($x_A, y_A, x_B, y_B, x_C, y_C$ — вещественные параметры). С помощью этой функции найти периметры треугольников ABC, ABD, ACD, если даны координаты точек A, B, C, D."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#сами, всё сами"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}