Скорость

Ребятки, привет! Как и обещала, переходим от красивой теории к настоящей практике. Сегодня мы не будем подключать никакие умные библиотеки — вместо этого напишем свой собственный класс для дуальных чисел на чистом Python с нуля. Сначала проверим его на простенькой школьной функции, а потом сделаем то, ради чего все затевалось: натравим его на целую программу с циклом и условиями, чтобы найти производную прямо от куска кода!

Кто-то из олдскульных программистов наверняка помнит шаблоны (templates) и перегрузку операторов в старичке Borland C++. Так вот, здесь под капотом работает абсолютно та же магия! В Python мы просто берем обычный тип данных и переопределяем для него привычные плюсики, минусики и умножение через специальные методы вроде __add__ и __mul__. Для самой программы ничего не меняется: она думает, что работает с обычными числами, но на самом деле внутри бегает наш хитрый объект.

Давайте освежим в памяти главный секрет из моей прошлой заметки. Дуальное число выглядит как a + b * eps, где eps^2 = 0. Оно состоит из двух половинок: в первой части (a) живет само значение, а во второй (b) — скорость его изменения, то есть та самая производная.
Когда мы закидываем такое число в программу, при каждом умножении срабатывает правило (a + b*eps) * (c + d*eps) = a*c + (a*d + b*c)*eps. Обратите внимание на вторую половинку: a*d + b*c — это же в чистом виде школьная формула производной произведения! Получается, что пока компьютер просто считает ответ, нужная нам производная вычисляется сама собой «прицепом».

В коде, который я приведу чуть ниже, мы сначала устроим нашему классу тест-драйв на классике из учебника: f(x) = x^2 + 3*x + 5. В уме мы легко прикинем, что ее производная равна 2*x + 3. Если подставить x = 4, то значение функции будет 33, а производная — 11. Чтобы запустить механизм, мы передаем в функцию не просто четверку, а дуальное число Dual(4.0, 1.0). Единичка во второй части нужна потому, что скорость изменения самой переменной x по отношению к самой себе равна единице (dx/dx = 1).

Наш класс проглотит это число и в секунду выдаст 33.0 + 11.0*eps — попадание сто из ста!

Но самое вкусное начинается во второй части скрипта. Там мы берем уже не красивую формулу, а настоящий кусок кода mini_program с циклом for, ветвлением if-else и синусом внутри. Выводить производную для такой конструкции вручную на листочке — то еще удовольствие, можно и мозг сломать. А вот нашему классу вообще без разницы: он просто шагает по строчкам кода, протаскивает касательные через каждую операцию и на выходе выдает абсолютно точную производную всей программы целиком. Никаких приближений и гаданий — чистая алгебра!

Сам текст программы я приведу прямо ниже. Обязательно скопируйте его, запустите у себя и покрутите числа — ощущение, когда пара десятков строк кода  начинает считать производные от алгоритмов, ни с чем не сравнимое!

Стефания
https://github.com/ST3PH-X

*Кто не хочет париться - сможете забрать файл с кодом в моем ТГК.
**Текст программы и результат:


import math


class Dual:

  def __init__(self, val, der=0.0):
    # val - само значение числа
    # der - скорость изменения (та самая производная при eps)
    self.val = val
    self.der = der

  def __repr__(self):
    return f"{self.val} + {self.der}*eps"

  def _to_dual(self, other):
    # Если складываем или умножаем с обычным числом (например, 5),
    # превращаем его в дуальное с нулевой производной: 5 + 0*eps
    return other if isinstance(other, Dual) else Dual(other, 0.0)

  def __add__(self, other):
    other = self._to_dual(other)
    return Dual(self.val + other.val, self.der + other.der)

  def __radd__(self, other):
    return self + other

  def __sub__(self, other):
    other = self._to_dual(other)
    return Dual(self.val - other.val, self.der - other.der)

  def __mul__(self, other):
    other = self._to_dual(other)
    # Помним правило eps^2 = 0, поэтому оставляем только (u'v + uv')
    new_val = self.val * other.val
    new_der = self.der * other.val + self.val * other.der
    return Dual(new_val, new_der)

  def __rmul__(self, other):
    return self * other

  def __pow__(self, power):
    # Возведение в степень: (x^n)' = n * x^(n-1) * x'
    new_val = self.val**power
    new_der = power * (self.val ** (power - 1)) * self.der
    return Dual(new_val, new_der)


# Добавим пару функций вроде синуса, чтобы было интереснее
def dual_sin(x):
  x = x if isinstance(x, Dual) else Dual(x, 0.0)
  return Dual(math.sin(x.val), math.cos(x.val) * x.der)


# --- ПРИМЕР 1: Классика из учебника ---
# Возьмем f(x) = x^2 + 3x + 5.
# В школе мы бы посчитали производную в уме: f'(x) = 2x + 3.
# Проверим в точке x = 4 (должно выйти значение 33 и производная 11).


def classic_func(x):
  return x**2 + 3 * x + 5


# Задаем x = 4, а производную ставим 1.0, потому что dx/dx = 1
x = Dual(4.0, 1.0)
res1 = classic_func(x)

print("--- Классическая функция ---")
print("Результат:", res1)
print(f"Значение: {res1.val}, Производная: {res1.der}\n")


# --- ПРИМЕР 2: Целая программа с циклом и ветвлением ---
# А теперь представьте, что это кусок физического симулятора.
# Руками выводить производную здесь уже лень, но Python справится сам.


def mini_program(x):
  acc = x
  for step in range(3):
    if acc.val > 10:
      acc = acc * 2 - 1
    else:
      acc = acc**2 + dual_sin(x)
  return acc


res2 = mini_program(Dual(2.0, 1.0))

print("--- Программа с циклом и условием ---")
print("Результат:", res2)
print(f"Значение: {res2.val:.4f}, Производная: {res2.der:.4f}")
 


--- Классическая функция ---
Результат: 33.0 + 11.0*eps
Значение: 33.0, Производная: 11.0

--- Программа с циклом и условием ---
Результат: 49.020997303725885 + 69.54451078074649*eps
Значение: 49.0210, Производная: 69.5445


Рецензии