1 лр / lab1_2

import numpy as np
import matplotlib.pyplot as plt

def invert(data):
    return np.logical_not(data).astype(int)

def Wfun(data, r):
    data_bin = np.binary_repr(data)

    if r > len(data_bin):
        data_ = np.concatenate((np.zeros(r - len(data_bin)), np.array(list(map(int, data_bin)))))
    else:
        data_ = np.array(list(map(int, data_bin)))

    W = [data_[0]]
    for i in range(2, len(data_)): #правка с 1 -- 2
        if data_[i] == 1:
            W = np.concatenate((W, np.logical_not(W)))
        else:
            W = np.concatenate((W, W))

    W = np.where(W == 0, 1, -1)

    return W

def Bpfun(W, r):
    while r < len(W):
        for i in range(1, len(W), r * 2): #правка с 0 --1
            for j in range(i, i + r):
                if j + r < len(W):  # Добавлено условие для предотвращения выхода за пределы массива
                    x = W[j]
                    y = W[j + r]
                    W[j] = x + y
                    W[j + r] = x - y
        r = r * 2

    Wprev = np.copy(W)
    Wnext = np.zeros_like(W)

    for i in range(0, r - 1):
        step_wing = len(W) // (2 ** i)
        for j in range(len(W)):
            butterfly_size = step_wing // 2
            if step_wing == 0:  # Добавлена проверка на ноль
                cost = 0
            else:
                cost = j % step_wing
                if cost == 0:
                    cost = butterfly_size + 1
            if j + butterfly_size < len(W):  # Добавлено условие для предотвращения выхода за пределы массива
                if cost <= butterfly_size:
                    Wnext[j] = Wprev[j] + Wprev[j + butterfly_size]
                else:
                    Wnext[j] = Wprev[j - butterfly_size] - Wprev[j]

        Wprev = np.copy(Wnext)

    return Wprev



def Ishod_data(Bpfun_result):
    ish_data = []
    absBpfunres = np.abs(Bpfun_result)

    t = []

    for i in range(len(absBpfunres)):
        max_value = np.max(absBpfunres)
        if max_value != 0 and absBpfunres[i] / max_value > 0.7:
            t.append(i)

    print('Найденные числа:')
    for j in range(len(t)):
        if Bpfun_result[t[j] + 1] < 0:
            f = np.flip(np.binary_repr(abs(t[j])))
            f = [1] + list(map(int, f))
        else:
            f = np.flip(np.binary_repr(abs(t[j])))
            f = list(map(int, f))
        ish_data += [int(np.packbits(f))]

    return ish_data

data1 = 3
data2 = 121
r = 10


W1 = Wfun(data1, r)
W2 = Wfun(data2, r)

Wsum = W1 + W2

plt.figure(1)
plt.subplot(2, 1, 1)
plt.plot(W1)
plt.title('W1')

plt.subplot(2, 1, 2)
plt.plot(W2)
plt.title('W2')

plt.figure(2)
plt.plot(Wsum)
plt.title('Wsum')

BPU1 = Bpfun(W1, r)
plt.figure(3)
plt.subplot(2, 1, 1)
plt.plot(BPU1)
plt.title('BPU1')
IdataW1 = Ishod_data(Bpfun(W1, r))

BPU2 = Bpfun(W2, r)
plt.subplot(2, 1, 2)
plt.plot(BPU2)
plt.title('BPU2')
IdataW2 = Ishod_data(Bpfun(W2, r))

plt.figure(4)
plt.subplot(2, 1, 1)
BPU = Bpfun(Wsum, r)
plt.plot(BPU)
plt.title('BPU')
IdataWsum = Ishod_data(Bpfun(Wsum, r))

plt.subplot(2, 1, 2)
Shum = 11 - 2 * 11 * np.random.rand(len(Wsum))
Wshum = Wsum + Shum
IdataWshum = Ishod_data(Bpfun(Wshum, r))

fwhdWshum = Bpfun(Wshum, r)
plt.plot(fwhdWshum)
plt.title('fwhdWshum')

plt.show()