lab2

import math
import numpy as np
from matplotlib import pyplot as plt
import random
#условия по варианту
#Температура если константой. Это 10 по цельсию (+273)
T_defolt=283
#Высота базовой станции (Пусть будет 30метров?)
h_b_s=30
#коэффициент теплового шума приемника
k_n=4
#Частота
f_0=900
#Пощность сигнала
p_t_x=40
#радиус По методе в метрах, но прошлую ж по км делала. Но если чисто 2, то
там слишком больше скорости получаются
r=2
#Число слотов(УВЕЛИЧИТЬ ДО В ПЯТОЙ)
#Увеличить не вариант – он десять минут уж считает для двух АБ и даже до
половины не дошел
#Будет до сотни.
n_slot=10**2
#Число ресурсных блоков - строк
n_r_v=25
#Полоса пропускания канала
delta_f=180
S=0
#длительность слота
time_slot=0.5
#Функция принимает на вход число абонентов
#расчитывает скорость для каждой части матрицы\распределяет абонентов
def return_C(N):
 #Случайным образом распределяем абонентов на разном R
 #Чтобы распределялись не кучками, применяем равномерное случаное
распределение
 mass_r=np.random.uniform(0, r, N).tolist()
 #определяем значение высоты (метры)
 mass_h_t_p=(np.random.uniform(0, 1, N)*h_b_s).tolist()
 #определяем расстояние (декартовое, изначальные координаыт 0,h_b_s
километры)
 mass_d=[]
 x=[]
 y=[]
 for i in range(len(mass_r)):
 mass_d.append(math.sqrt((mass_r[i]-0)**2+(mass_h_t_p[i]*10**(-3)-
h_b_s*10**(-3))**2))
 #чисто для графика ищем угл
 #angle=2*math.pi*random.random()
 #x.append(mass_d[i] * math.cos(angle))
 #y.append(mass_d[i] * math.sin(angle))
 #строим график кружочка с точками
 #fig, ax = plt.subplots()
 #ax.add_patch(plt.Circle((0,0), r, fill=False))
 #plt.scatter(x,y)
 #plt.title('Распределение абонентов вокруг базовой станции')
 #plt.xlabel('x')
 #plt.ylabel('y')
8
 #plt.show()
 #считаем скорость
 '''
 так заполнение
 t=[[[1,2,],
 [4,5,]]
 ,[[6,7],
 [8,9]]]
 print(t[1][1][1])
 len(t)- сколько масивов
 len(t[i]) - строк в массиве
 len(t[][])- сколько в строке
 '''
 mass_all_c=[]
 for i in range(N):
 #расчитываем основное l для абонента
 a_h=(1.1*math.log10(f_0)-0.7)*mass_h_t_p[i]-(1.56*math.log10(f_0)-
0.8)
 L=10**((46.3+33.9*math.log10(f_0)-13.82*math.log10(h_b_s)-a_h+(44.9-
6.55*math.log10(mass_h_t_p[i]))*math.log10(mass_d[i])+S)/10)
 mass_c=[]
 mass_une_c=[]
 #Для каждой из 25
 for j in range(n_r_v):
 #ДЛя каждого из 10 000 столбцов
 #расчитываем основное плюс случайное
 #мощность сигнала
 p_r_x=p_t_x/(L*abs(np.random.normal(0, 1,n_slot))) #РЫБА Тут по
идее надо не умножать, а прибавлять, но если это делать то числа одинаковые
выходят
 #Мощность теплового шума
 k=1.38*10**(-23)
 T=T_defolt
 p_n=delta_f*T*k*k_n
 #Отнешение сигнал шум
 snr=p_r_x/p_n
 #Пропускная способность сигнала
 #Числа разные, пусть и отличаются минимально(
 #разу тут переводим в Кбайт
 mass_c.append((delta_f*np.log2(1+snr))*128)
 mass_all_c.append(mass_c)
 return(mass_all_c)
#Функция расчитает какой объем инфы поступает
#Чтоб проще было, я подразумеваю, что в этом массиве данные которые
#пришли на ПРОШЛЫЙ шаге для отправки на ЭТОМ шаге
def return_p_v(N,liamda):
 number_data_packets=[]
 #генерируем сколько каждому пришло d Кбайтах
 for i in range(N):
 number_data_packets.append(np.random.poisson(liamda,size=n_slot))
 return (number_data_packets)
#Функци считает методом сглаживания среднию скорость с которой аб скачивал
#В первом(и втором) столбце распределение будет случайнм
#Во втором по случайным реально будет посчитать V
#В третем уже начнется полный просчет
#Тут С это чисто значение скоростей на ПРОШЛЫЙ стобец для всех АБ вид -
[[Вспе для АБ_1],[]]
#Второе – информация о том как в прошлом столбце распределилась между АБ
слоты
#У меня в виде списка, где 0 - первый занял, 1 второй и т.д.
9
#Третье просто последний массив со средними скоростями(для первого столбца
там все 0)
def return_r(C,etap,b_last_mass,r_last_mass):
 #Вытаскиваем столбцы каждого из АБ
 C_past=[]
 for i in range(len(C)):
 C_une=[]
 #Идем по строкам для АБ
 for j in range(n_r_v):
 C_une.append(C[i][j][etap])
 C_past.append(C_une)
 #второе в значении это число слотов по которым расчитваем
 #для второго там 1
 if etap!=1:
 beta=1/2
 else:
 beta=1/1
 #Для каждого абонента находим скорость
 r_new_mass=[]
 for i in range(len(C)):
 V_maybe=0
 #Считаем сколько МОГЛО быть отправлено АБ по тому как занято на
ПРОШЛОМ ВСЕГО
 for j in range(len(b_last_mass)):
 if b_last_mass[j]==i+1:
 V_maybe=C_past[i][j]*time_slot+V_maybe
 t=(1-beta)*r_last_mass[i]+beta*(V_maybe/time_slot)
 r_new_mass.append(t)
 return(r_new_mass)
#Данный алгоритм выравнивает среднюю скорость закачки
def equal_blind(C,P_value):
 P_value=np.array(P_value).tolist()
 b_last=[]
 r_last=[]
 #Это будет повторятся для всех столбцов
 for i in range(n_slot):
 prior=[]
 #Это для прошлого списка того кто что занял
 #ВНИМАНИЕ тут 0 это ничто а первый 1
 #это для прошлых средних скоростей
 #Если это перый слот, то случайно распределеяем места, а скорости АБ
будут 0
 if i==0:
 #Тут надо так распределить, чтоб все учавстовали. Буду тупо по
очереди
 #1 это первый, помни
 while len(b_last)<n_r_v:
 for k in range(len(C)):
 b_last.append(k+1)
 while len(b_last)>n_r_v:
 b_last.pop()
 for k in range(len(C)):
 r_last.append(0)
 #Перетаскиваем из буфера все в следующий
 P_value[k][i+1]=P_value[k][i+1]+P_value[k][i]
 P_value[k][i]=0

 #Если второй, то считать по формуле
 else:
 #Получить нужно назад среднюю скорость
 #Вроде получается, но чет значение высокое, поэтому РЫБА
 r_new=return_r(C,i,b_last,r_last)
10
 b_last=[]
 r_last=r_new
 #По формуле определяем у кого какой приоритет
 for j in range(len(C)):
 prior.append(1/r_new[j])
 #идем по каждой строке
 for j in range(n_r_v):
 if max(prior)==0:
 b_last.append(0)
break
 #Находим кто из абонентов первый
 max_index=prior.index(max(prior))
 #Чистим буфер пока он не станет пустым(если?)
 #указываем кто в этой строке
 P_value[max_index][i]=P_value[max_index][i]-
C[max_index][j][i]*time_slot
 if P_value[max_index][i]<=0:
 P_value[max_index][i]=0
prior[max_index]=0
 b_last.append(max_index+1)
 for k in range(len(C)):
 #Перетаскиваем из буфера все в следующий
 if i!=n_slot-1:
 P_value[k][i+1]=P_value[k][i+1]+P_value[k][i]
P_value[k][i]=0
 D=np.mean(P_value)
 if D<0:
 t=1
 return(D)
#Алгоритм MT «отдает» ресурсный блок тому пользователю, у которого
максимальна пропускная канала связи
def maximum_throughput(C,P_value):
 P_value=np.array(P_value).tolist()
 D_all=[]
 r=np.array(P_value)
 r_2=P_value[1]
 #Просто проходимся по массиву С и ищем маскимумы
 for i in range(n_slot):
 b_une=[]
 for j in range(n_r_v):
 max_C_old=-1
 # АБ с max скоростью в этом слоте и на который есть инфа в
буфере
 for k in range(len(C)):
 if (max_C_old<C[k][j][i])and(P_value[k][i]>0):
 max_index=k
max_C_old=C[k][j][i]
 #если уже все АБ получили все что надо то надо к новому слоту
переходить
 if max_C_old==-1:
 break
 #знаем АБ с макисмальной скоростью тут. работаем с его буфером
 #Если не первый слот, то нужно прибавить что осталось со старых
 if i!=0:

P_value[max_index][i]=P_value[max_index][i]+P_value[max_index][i-1]
 P_value[max_index][i]=abs(P_value[max_index][i])
 if max_C_old*time_slot>P_value[max_index][i]:
 P_value[max_index][i]=0
 else:
 P_value[max_index][i]=P_value[max_index][i]-
max_C_old*time_slot
11
 #Нужно пополнить буфер для тех кто дальше, если не освободились
 if i!=n_slot-1:
 for j in range(len(P_value)):
 P_value[j][i+1]=P_value[j][i]+P_value[j][i+1]
 P_value[j][i]=0
 #После всего нужно вернуть среднее число в буфере по последним строкам
 D=np.mean(P_value)
 if D<0:
 t=1
 return(D)
# выравнивание ресурсов, отдаваемых пользователям
#В осноном код будет из первого алгоритма, так что коментарии могут врать
def proportional_fair(C,P_value):
 b_last=[]
 r_last=[]
 P_value=np.array(P_value).tolist()
 #Это будет повторятся для всех столбцов
 for i in range(n_slot):
 prior_all=[]
 #Это для прошлого списка того кто что занял
 #ВНИМАНИЕ тут 0 это ничто а первый 1
 #это для прошлых средних скоростей
 #Если это перый слот, то случайно распределеяем места, а скорости АБ
будут 0
 if i==0:
 #Тут надо так распределить, чтоб все учавстовали. Буду тупо по
очереди
 #1 это первый, помни
 while len(b_last)<n_r_v:
 for k in range(len(C)):
 b_last.append(k+1)
 while len(b_last)>n_r_v:
 b_last.pop()
 for k in range(len(C)):
 r_last.append(0)
 #Перетаскиваем из буфера все в следующий
 P_value[k][i+1]=P_value[k][i+1]+P_value[k][i]
 P_value[k][i]=0

 #Если второй, то считать по формуле
 else:
 #Получить нужно назад среднюю скорость
 #Вроде получается, но чет значение высокое, поэтому РЫБА
 r_new=return_r(C,i,b_last,r_last)
 b_last=[]
 r_last=r_new
 #Вот тут уже прям третий третий
 #По формуле определяем у кого какой приоритет
 #Считаем сколько будет на Каждую строку
 for j in range(len(C)):
 prior_une=[]
 for k in range(n_r_v):
 prior_une.append(C[j][k][i]/r_new[j])
 prior_all.append(prior_une)
 #идем по каждой строке
 for j in range(n_r_v):
 #Смотрим у кого приоритет в этой строке
 max_value=-1
 for k in range(len(prior_all)):
 if prior_all[k][j]>max_value:
 max_index=k
12
 max_value=prior_all[k][j]
 if max_value==0:
 b_last.append(0)
break
 #Чистим буфер пока он не станет пустым(если?)
 #указываем кто в этой строке
 P_value[max_index][i]=P_value[max_index][i]-
C[max_index][j][i]*time_slot
 if P_value[max_index][i]<=0:
 P_value[max_index][i]=0
#Забираем весь приоритет у получившего все АБ
for k in range(n_r_v):
 prior_all[max_index][k]=0
 b_last.append(max_index+1)
 for k in range(len(C)):
 #Перетаскиваем из буфера все в следующий
 if i ==n_slot-2:
 t=1
 if i!=n_slot-1:
 P_value[k][i+1]=P_value[k][i+1]+P_value[k][i]
P_value[k][i]=0
 if i==n_slot-1:
 break
 D=np.mean(P_value)
 if D>0:
 t=1
 return D
#главная функция для вызова остальных для работы по программе
def main(N=[2,4,8,16],liamda_min=5*10**4,liamds_max=5*10**6,etap=5*10**4):
 #По итогу должно получится для трех алгаритмов
 #наборы из среднего в буфере для каждого значения числа абонентов
 D_mean_e_q_all=[]
 D_mean_m_t_all=[]
 D_mean_p_f_all=[]
 #Наборы пополняются для каждого числа абонентов
 for i in range(len(N)):
 D_mean_e_q=[]
 D_mean_m_t=[]
 D_m_t=[]
 D_mean_p_f=[]
 x=[]
 #дальше все дложно быть для каждой из частот
 for j in range(liamda_min,liamds_max,etap):
 x.append(j)
 D_m_t=[]
 D_e_q=[]
 D_p_f=[]
 #получаем обем инфы, которая в приходит к КОНЦУ каждой
столбца(слота)
 #Короче отмена. Будет это та инфа, которая пришла ранее на
выполнение на этом слоте
 #Так по логичнее и нет последнего не пойми за чем существующего
 #Вообще, тут получаем слолько в кбайт получили
 #Но С у нас в Мбит, поэтому переводятся в кбайты в основной
функции
 #Дальше идут в работу каждый из алгаритмов
 for k in range(10):
 C=return_C(N[i])
 P_value=return_p_v(N[i],j)
 #самый понятный алгорим
 D_m_t.append(maximum_throughput(C,P_value))
 #Второй
13
 D_e_q.append(equal_blind(C,P_value))
 #Третий
 D_p_f.append(proportional_fair(C,P_value))
 D_mean_m_t.append(np.mean(D_m_t))
 D_mean_e_q.append(np.mean(D_e_q))
 D_mean_p_f.append(np.mean(D_p_f))
 print('Готово для ',N[i])
 D_mean_m_t_all.append(D_mean_m_t)
 D_mean_e_q_all.append(D_mean_e_q)
 D_mean_p_f_all.append(D_mean_p_f)
 legend=[]
 for i in range(len(D_mean_p_f_all)):
 plt.plot(x,D_mean_p_f_all[i])
 legend.append('Proportional Fair'+repr(N[i]))
 plt.plot(x,D_mean_e_q_all[i])
 legend.append('Equal Blind'+repr(N[i]))
 plt.plot(x,D_mean_m_t_all[i])
 legend.append('Maximum Throughput '+repr(N[i]))
 plt.legend(legend)
 plt.xlabel('Средн. суммарный объём данных в буфере (Кбайт)')
 plt.ylabel('Интенсивность входного потока')
 plt.title('Зависимость ср. суммарного объема данных в буфере от
интенсивности')
 plt.show()
 return 0
main()