---

# ============================================================
# ЗАДАНИЕ 14. БИБЛИОТЕКА SymPy
# ============================================================

import sympy as sp                  # Подключаем SymPy для символьной математики
import numpy as np                  # Подключаем NumPy для создания числовых массивов
import matplotlib.pyplot as plt     # Подключаем Matplotlib для построения графика


# ============================================================
# 1. ВЫЧИСЛЕНИЕ ПРЕДЕЛОВ
# ============================================================

print("\n--- Задание 1. Пределы ---")

x = sp.symbols('x', real=True)      # Создаём вещественную символьную переменную x
n = sp.symbols('n', integer=True, positive=True)
# Создаём переменную n, которая является положительным целым числом

# а) Предел корня степени x из cos(sqrt(x)) при x -> 0 справа
expr_a = sp.cos(sp.sqrt(x))**(1/x)
# sqrt(x) — квадратный корень из x
# cos(...) — косинус выражения
# **(1/x) — возведение в степень 1/x, то есть корень степени x

limit_a = sp.limit(expr_a, x, 0, dir='+')
# limit() вычисляет предел
# x — переменная, стремящаяся к нулю
# dir='+' означает приближение справа, поскольку sqrt(x) требует x >= 0

print("а) Предел =", limit_a)
# Выводим результат: exp(-1/2), то есть 1/sqrt(e)

# б) Предел cos^n(x/sqrt(n)) при n -> бесконечности
expr_b = sp.cos(x / sp.sqrt(n))**n
# x/sqrt(n) — аргумент косинуса
# **n — возведение косинуса в степень n

limit_b = sp.limit(expr_b, n, sp.oo)
# sp.oo обозначает бесконечность
# Вычисляем предел при n -> бесконечности

print("б) Предел =", limit_b)
# Для постоянного x результат: exp(-x**2/2)

# в) Предел tan(x) при x -> pi/2 справа
expr_c = sp.tan(x)
# tan(x) — тангенс x

limit_c = sp.limit(expr_c, x, sp.pi/2, dir='+')
# sp.pi — число пи
# dir='+' означает приближение к pi/2 справа

print("в) Предел =", limit_c)
# Выводим результат: -oo, то есть минус бесконечность


# ============================================================
# 2. ПРОИЗВОДНАЯ ФУНКЦИИ
# f(x) = x^2 * sin(3x) * e^x
# ============================================================

print("\n--- Задание 2. Производная ---")

f = x**2 * sp.sin(3*x) * sp.exp(x)
# x**2 — квадрат x
# sin(3*x) — синус утроенного аргумента
# exp(x) — экспонента e^x
# Умножаем три выражения, чтобы получить исходную функцию

f_derivative = sp.diff(f, x)
# diff(f, x) вычисляет производную функции f по переменной x

f_simplified = sp.simplify(f_derivative)
# simplify() упрощает полученное математическое выражение

print("Производная f'(x) =")
sp.pprint(f_simplified)
# pprint() выводит формулу в удобном математическом виде

value_derivative = f_simplified.subs(x, sp.pi/4)
# subs(x, pi/4) подставляет вместо x значение pi/4

value_derivative = sp.simplify(value_derivative)
# Упрощаем результат после подстановки

print("Производная в точке pi/4 =")
sp.pprint(value_derivative)
# Выводим точное значение производной в заданной точке


# ============================================================
# 3. НЕОПРЕДЕЛЁННЫЙ И ОПРЕДЕЛЁННЫЙ ИНТЕГРАЛЫ
# Integral x / sqrt(x^2 + 1) dx
# ============================================================

print("\n--- Задание 3. Интегралы ---")

integrand = x / sp.sqrt(x**2 + 1)
# Создаём подынтегральное выражение
# sqrt(x**2 + 1) — квадратный корень из x^2 + 1

indefinite_integral = sp.integrate(integrand, x)
# integrate(выражение, x) вычисляет неопределённый интеграл
# Постоянная интегрирования C автоматически не добавляется

print("Неопределённый интеграл =")
sp.pprint(indefinite_integral)
# Выводим первообразную: sqrt(x^2 + 1)

definite_integral = sp.integrate(integrand, (x, 0, 2))
# Вычисляем определённый интеграл от 0 до 2
# Кортеж (x, 0, 2) задаёт переменную и границы интегрирования

print("Определённый интеграл от 0 до 2 =")
sp.pprint(definite_integral)
# Результат: sqrt(5) - 1


# ============================================================
# 4. НЕЯВНО ЗАДАННАЯ ФУНКЦИЯ
# x^3 + y^3 = 6xy
# ============================================================

print("\n--- Задание 4. Неявная функция ---")

y = sp.symbols('y', real=True)
# Создаём отдельную символьную переменную y

implicit_equation = sp.Eq(x**3 + y**3, 6*x*y)
# Eq(left, right) задаёт уравнение левой и правой частей

print("Исходное уравнение:")
sp.pprint(implicit_equation)
# Выводим исходное уравнение

implicit_derivative = sp.idiff(
    x**3 + y**3 - 6*x*y, y, x
)
# idiff() вычисляет производную y по x для неявно заданной функции
# Первым аргументом передаём уравнение, перенесённое в левую часть
# Второй аргумент y — зависимая переменная
# Третий аргумент x — переменная дифференцирования

implicit_derivative = sp.simplify(implicit_derivative)
# Упрощаем выражение производной

print("Производная dy/dx =")
sp.pprint(implicit_derivative)
# Выводим результат: (2*y - x^2)/(y^2 - 2*x)


# ============================================================
# 5. ПРОИЗВОДНАЯ КУСОЧНО ЗАДАННОЙ ФУНКЦИИ
# f(x) = x^2, если x < 0
# f(x) = sin(x), если x >= 0
# ============================================================

print("\n--- Задание 5. Кусочная функция ---")

piecewise_f = sp.Piecewise(
    (x**2, x < 0),
    (sp.sin(x), x >= 0)
)
# Piecewise() создаёт функцию, заданную несколькими условиями
# (x**2, x < 0) — при x < 0 функция равна x^2
# (sin(x), x >= 0) — при x >= 0 функция равна sin(x)

print("Исходная функция:")
sp.pprint(piecewise_f)
# Выводим кусочно заданную функцию

piecewise_derivative = sp.diff(piecewise_f, x)
# diff() дифференцирует обе ветви кусочной функции

print("Производная по ветвям:")
sp.pprint(piecewise_derivative)
# Для x < 0 производная равна 2*x
# Для x >= 0 формальная производная соответствующей ветви равна cos(x)

left_derivative = sp.limit(
    sp.diff(x**2, x), x, 0, dir='-'
)
# Находим предел производной левой ветви при x -> 0 слева

right_derivative = sp.limit(
    sp.diff(sp.sin(x), x), x, 0, dir='+'
)
# Находим предел производной правой ветви при x -> 0 справа

print("Левая производная в точке 0 =", left_derivative)
# Выводим левую производную: 0

print("Правая производная в точке 0 =", right_derivative)
# Выводим правую производную: 1

print("Функция дифференцируема в 0?",
      sp.simplify(left_derivative - right_derivative) == 0)
# Сравниваем односторонние производные
# Если они равны, производная существует
# Здесь ответ False, поскольку 0 не равно 1


# ============================================================
# 6. ДВОЙНОЙ ИНТЕГРАЛ ПО ОБЛАСТИ
# D = {(x,y): 0 <= x <= 1, x^2 <= y <= x}
# Integral integral (x + y) dx dy
# ============================================================

print("\n--- Задание 6. Двойной интеграл ---")

# Создаём область на графике: нижняя граница y = x^2,
# верхняя граница y = x, а x изменяется от 0 до 1

x_plot = np.linspace(0, 1, 200)
# Создаём 200 числовых точек от 0 до 1 для построения границ

plt.figure(figsize=(7, 5))
# Создаём окно для рисунка области интегрирования

plt.plot(x_plot, x_plot**2, label='y = x^2')
# Рисуем нижнюю границу области

plt.plot(x_plot, x_plot, label='y = x')
# Рисуем верхнюю границу области

plt.fill_between(x_plot, x_plot**2, x_plot, alpha=0.3)
# Закрашиваем область между кривыми
# alpha задаёт прозрачность заливки

plt.xlabel('x')
# Подписываем горизонтальную ось

plt.ylabel('y')
# Подписываем вертикальную ось

plt.title('Область интегрирования D')
# Добавляем заголовок рисунка

plt.grid(True)
# Включаем сетку

plt.legend()
# Показываем легенду с границами

plt.show()
# Отображаем область интегрирования

double_integral = sp.integrate(
    x + y, (y, x**2, x), (x, 0, 1)
)
# Вычисляем двойной интеграл в виде повторного интеграла
# x + y — подынтегральная функция
# (y, x**2, x) — сначала интегрируем по y от x^2 до x
# (x, 0, 1) — затем интегрируем по x от 0 до 1

print("Значение двойного интеграла =")
sp.pprint(double_integral)
# Выводим точный результат: 3/20


# ============================================================
# 7. УПРОЩЕНИЕ ДРОБИ
# ((x^2 - 4)(x + 3)) / (x^2 + x - 6)
# ============================================================

print("\n--- Задание 7. Упрощение дроби ---")

rational_expr = ((x**2 - 4)*(x + 3)) / (x**2 + x - 6)
# Создаём исходную рациональную дробь

rational_simplified = sp.factor(rational_expr)
# factor() раскладывает числитель и знаменатель на множители
# Общие множители сокращаются, результат равен x + 2

print("Упрощённая дробь =")
sp.pprint(rational_simplified)
# Выводим сокращённое выражение

print("Ограничения: x не равно 2 и -3")
# Исходный знаменатель равен нулю при x = 2 и x = -3
# Эти значения исключаются из области определения исходной дроби


# ============================================================
# 8. ТРИГОНОМЕТРИЧЕСКОЕ УПРОЩЕНИЕ С TRIGSIMP
# sin^2(x) + cos^2(x) + tan^2(x) - sec^2(x)
# ============================================================

print("\n--- Задание 8. Тригонометрическое упрощение ---")

trig_expr = (
    sp.sin(x)**2
    + sp.cos(x)**2
    + sp.tan(x)**2
    - sp.sec(x)**2
)
# sin(x)**2 — квадрат синуса
# cos(x)**2 — квадрат косинуса
# tan(x)**2 — квадрат тангенса
# sec(x)**2 — квадрат секанса, где sec(x) = 1/cos(x)

trig_simplified = sp.trigsimp(trig_expr)
# trigsimp() использует тригонометрические тождества
# sin(x)^2 + cos(x)^2 = 1
# tan(x)^2 + 1 = sec(x)^2

print("Упрощённое выражение =")
sp.pprint(trig_simplified)
# Выводим результат: 0


# ============================================================
# 9. УПРОЩЕНИЕ ЛОГАРИФМОВ С LOGCOMBINE
# 3*ln(x) - ln(y)/2 + 2*ln(z)
# ============================================================

print("\n--- Задание 9. Логарифмы ---")

# Создаём положительные переменные, чтобы правила логарифмов
# применялись без неоднозначностей для действительных чисел
xl, yl, zl = sp.symbols('xl yl zl', positive=True)

log_expr = 3*sp.log(xl) - sp.log(yl)/2 + 2*sp.log(zl)
# log() обозначает натуральный логарифм
# Коэффициенты 3, -1/2 и 2 стоят перед соответствующими логарифмами

log_simplified = sp.logcombine(log_expr)
# logcombine() объединяет сумму и разность логарифмов в один логарифм
# Результат: ln(xl^3 * zl^2 / sqrt(yl))

print("Объединённый логарифм =")
sp.pprint(log_simplified)
# Выводим упрощённое логарифмическое выражение

values = {xl: 2, yl: 4, zl: 3}
# Создаём словарь подстановки конкретных значений x=2, y=4, z=3
# В коде переменные называются xl, yl, zl, чтобы не путать их с другими пунктами

original_value = log_expr.subs(values)
# Подставляем числа в исходное выражение

simplified_value = log_simplified.subs(values)
# Подставляем те же числа в упрощённое выражение

print("Исходное выражение при x=2, y=4, z=3 =",
      sp.N(original_value, 10))
# N() вычисляет численное приближение с 10 значащими цифрами

print("Упрощённое выражение при x=2, y=4, z=3 =",
      sp.N(simplified_value, 10))
# Выводим численное значение после упрощения

print("Значения совпадают?",
      sp.simplify(original_value - simplified_value) == 0)
# Проверяем равенство символически, а не только по округлённым числам


# ============================================================
# 10. СРАВНЕНИЕ SIMPLIFY И TRIGSIMP
# sin(2x)/(2 sin(x)) + (cos(2x) - cos^2(x))/sin^2(x)
# ============================================================

print("\n--- Задание 10. Сравнение simplify и trigsimp ---")

expr_10 = (
    sp.sin(2*x) / (2*sp.sin(x))
    + (sp.cos(2*x) - sp.cos(x)**2) / sp.sin(x)**2
)
# Создаём исходное выражение из задания
# sin(2*x) — синус двойного угла
# cos(2*x) — косинус двойного угла
# sin(x)**2 и cos(x)**2 — квадраты синуса и косинуса

result_simplify = sp.simplify(expr_10)
# simplify() пытается упростить выражение общими алгебраическими методами

result_trigsimp = sp.trigsimp(expr_10)
# trigsimp() пытается упростить выражение с помощью тригонометрических тождеств

print("Результат simplify() =")
sp.pprint(result_simplify)
# Выводим результат первого способа

print("Результат trigsimp() =")
sp.pprint(result_trigsimp)
# Выводим результат второго способа

print("Разность результатов после упрощения =")
sp.pprint(sp.trigsimp(result_simplify - result_trigsimp))
# Проверяем, равны ли результаты двух методов
# Если разность равна 0, результаты совпадают

print("Ожидаемое упрощённое выражение: cos(x) - 1")
# По формулам двойного угла исходное выражение упрощается до cos(x) - 1
# Исходное выражение определено только там, где sin(x) не равен 0