lab_1 in progress

Author: Emeteil

.github/workflows/ai-code-review.yml

@@ -0,0 +1,19 @@
+name: AI Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  ai-review:
+    runs-on: ubuntu-latest
+    steps:
+      - name: AI Code Review based on Opencode
+        uses: Emeteil/ai_code_reviewer@v1.0.1
+        with:
+          language: Russian
+          model: ""

.github/workflows/lint.yml

@@ -0,0 +1,26 @@
+name: Lint
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  flake8:
+    name: flake8 lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install flake8
+        run: |
+          python -m pip install --upgrade pip
+          pip install flake8
+
+      - name: Run flake8
+        run: flake8 .

justfile

@@ -0,0 +1,12 @@
+venv := ".venv"
+python := if os_family() == "windows" { venv / "Scripts" / "python.exe" } else { venv / "bin" / "python" }
+
+setup:
+    @test -e "{{python}}" || python -m venv {{venv}}
+    @"{{python}}" -m pip install -q -q -r requirements.txt flake8
+
+lint: setup
+    "{{python}}" -m flake8 .
+
+run folder file="main.py": setup
+    PYTHONPATH=. "{{python}}" "{{folder}}/{{file}}"

lab_1/main.py

@@ -1,24 +1,140 @@
-# 5 вариант
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from icecream import ic  # noqa: F401
 
-import matplotlib.pyplot as plt
-from scipy.fftpack import fftfreq, fft
 import numpy as np
-from numpy import cos, sin, pi
+import utils.debug  # noqa: F401
+from matplotlib.axes import Axes # noqa: F401
 
-f = 3
-y = lambda t: cos(2*pi*f*t + pi/3) + sin(4+pi*f*t)
+from utils.complex_numbers import to_polar, to_rect # noqa: F401
+from utils.harmonic import (
+    get_harmonic_oscillation,
+    get_period, # noqa: F401
+    get_phase_time_shift, # noqa: F401
+    get_phase_at, # noqa: F401
+)
+from utils.fourier import discrete_fourier_transform # noqa: F401
+from utils.plotting import show_multi_plot, show_plot, show_subplots # noqa: F401
+from utils.sampling import get_linspace
 
-x = np.linspace(0, 10, 1000)
 
-y_x = y(x)
+def task_1_2() -> None:
+    sampling_frequency = 1024
+    start = 0
+    stop = 1
+    t = get_linspace(start=start, stop=stop, fs=sampling_frequency)
+    
+    # <------------------------------------>
+    # 1) Необходимо сгенерировать и визуализировать непрерывный сигнал
+    frequency = 4
+    
+    ic(
+        frequency,
+        sampling_frequency,
+    )
+    
+    y_1 = get_harmonic_oscillation(1, frequency, np.pi/3, wave=np.cos)(t)
+    y_2 = get_harmonic_oscillation(1, 2*frequency, 0, wave=np.sin)(t)
+    y = y_1 + y_2  # 5 вариант
 
-fig, ax = plt.subplots()
-ax.plot(x, y_x)
-ax.set(xlabel='t', ylabel='y', title='y = cos(2*pi*f*t + pi/3) + sin(4+pi*f*t)')
+    show_plot(
+        t=t,
+        func_val=y,
+        title="cos(2*pi*f*t + pi/3) + sin(4*pi*f*t)",
+    )
+    # >------------------------------------<
+    
 
-plt.show()
+    # <------------------------------------>
+    # 2) Определить максимальную частоту в спектре данного сигнала.
+    max_freq = frequency * 2 
+    # >------------------------------------<
+    
+    
+    # <------------------------------------>
+    # 3) Определить минимальную необходимую частоту дискретизации
+    # полученного сигнала (теорема Котельникова)
+    min_freq_kotelnikov = max_freq * 2
+    
+    ic(
+        max_freq,
+        min_freq_kotelnikov,
+    )
+    # >------------------------------------<
+    
+    
+    # <------------------------------------>
+    # 4) Оцифровать сигнал с полученной частотой дискретизации, выбрав
+    # требуемое число отсчетов сигнала на длительности 1 секунда, сохранить
+    # полученные значения в массив, пока не озадачиваясь разрядностью АЦП,
+    # просто выбранные с частотой дискретизации значения с теми уровнями,
+    # которые имеет функция в полученных точках.
+    step = len(y) // int(min_freq_kotelnikov * (stop - start)) 
+    y_sampled = y[::step]
+    t_sampled = t[::step]
+    
+    ic(
+        y_sampled,
+        t_sampled,
+    )
+    # >------------------------------------<
+    
+    
+    # <------------------------------------>
+    # 5) Выполнить прямое дискретное преобразование Фурье для массива
+    # временных отсчетов сигнала и оценить ширину данного спектра. А также
+    # объем памяти, требуемый для хранения данного массива (тип переменных в
+    # массиве – на ваше усмотрение, float, int и пр.).
+    y_dft = discrete_fourier_transform(y_sampled)
+    N = len(y_dft)
+    freqs = np.arange(N) * min_freq_kotelnikov / N
+    amp = np.abs(y_dft) / N
+    
+    ic(
+        freqs,
+        amp,
+    )
 
-max_freq = f*2
+    threshold = 1e-6
+    half = N // 2 + 1  # без зеркальной части
+    significant = np.array([freqs[k] for k in range(half) if amp[k] > threshold])
+    spectrum_width = significant.max()
+   
+    ic(
+        spectrum_width
+    )
 
-min_freq_kotelnikov = max_freq * 2
+    def draw_signal(ax: Axes) -> None:
+        ax.plot(t, y)
+        ax.stem(t_sampled, y_sampled, linefmt="r-", markerfmt="ro", basefmt=" ")
 
+    def draw_full_spectrum(ax: Axes) -> None:
+        ax.stem(freqs, amp)
+
+    def draw_half_spectrum(ax: Axes) -> None:
+        ax.stem(freqs[:half], amp[:half])
+        ax.axhline(threshold, color="gray", linestyle="--", label="порог")
+        ax.axvline(spectrum_width, color="r", linestyle=":", label="ширина спектра")
+        ax.legend()
+
+    show_subplots(
+        draw_funcs=[draw_signal, draw_full_spectrum, draw_half_spectrum],
+        titles=[
+            "Сигнал и отсчеты",
+            "Амплитудный спектр, все N гармоник (зеркальная часть)",
+            "Амплитудный спектр без зеркальной части",
+        ],
+        figsize=(9, 10),
+    )
+    # >------------------------------------<
+                
+
+def main() -> None:
+    task_1_2()
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        pass

lab_1/ОСМС_Занятие 1.pdf

@@ -0,0 +1,4 @@
+icecream==2.2.0
+matplotlib>=3.10.9
+numpy>=2.1
+scipy>=1.14

requirements.txt

@@ -0,0 +1,13 @@
+import numpy as np
+
+
+def to_polar(z: complex) -> tuple[float, float]:
+    """to_polar(z) -> r, theta"""
+    # abs - теорема Пифагора, angle - арктангенс
+    return np.abs(z), np.angle(z)
+
+
+def to_rect(r: float, theta: float) -> complex:
+    """to_rect(r, theta) -> z"""
+    # просто формула Эйлера из тфкп
+    return r * (np.cos(theta) + 1j * np.sin(theta))

utils/complex_numbers.py

@@ -0,0 +1,11 @@
+import builtins
+
+try:
+    import icecream
+    from icecream import install
+
+    icecream.icecream.has_non_ascii_chars = lambda s: False
+
+    install()
+except ImportError:
+    builtins.ic = lambda *a: None if not a else (a[0] if len(a) == 1 else a)

utils/debug.py

@@ -0,0 +1,14 @@
+from typing import Callable
+import numpy as np
+
+
+def discrete_fourier_transform(x: np.ndarray) -> np.ndarray:
+    N = len(x)
+    X = []
+    for k in range(N):
+        s = 0
+        for n in range(N):
+            s += x[n] * np.exp(-2j * np.pi * k * n / N)
+        X.append(s)
+    
+    return np.array(X)

utils/fourier.py

@@ -0,0 +1,32 @@
+from typing import Callable
+import numpy as np
+
+
+def get_harmonic_oscillation(
+    a: float,
+    f: float,
+    phi: float,
+    wave: Callable[[np.ndarray], np.ndarray] = np.sin
+) -> Callable[[np.ndarray], np.ndarray]:
+    """y = a * wave(2 * pi * f * t + phi)"""
+    def y(t: np.ndarray) -> np.ndarray:
+        return a * wave(2 * np.pi * f * t + phi)
+
+    return y
+
+
+def get_period(f: float) -> float:
+    """T = 1/f"""
+    return 1 / f
+
+
+def get_phase_time_shift(phi: float, f: float) -> float:
+    """-phi / (2 * pi * f)"""
+    # угол делится на 2*pi, чтобы получить долю периода, затем умножается на период (делится на фазу)
+    return -phi / (2 * np.pi * f)
+
+
+def get_phase_at(f: float, t: np.ndarray, phi: float = 0) -> np.ndarray:
+    """(2 * pi * f * t) + phi"""
+    # время умножается на частоту и на 2*pi, чтобы получить фазу в радианах + начальная фаза
+    return 2 * np.pi * f * t + phi