def encode(self, data_bits): if len(data_bits) != 400: raise ValueError("WIRT only supports 400 bits data") # Polar coding data_polar = polar_encode(wirt.POLAR_SIZE, wirt.DATA_SIZE, data_bits) data_enc = repack_bits(data_polar, 1, 2) data_enc_rep = np.tile(data_enc, (1, wirt.NUM_REPETITIONS)).ravel() # QPSK modulate data_enc_mod = qpsk_modulate(data_enc_rep) # OFDM modulation (subcarrier mapping, pilot insertion, IFFT, cyclic prefix insert) IQ_data_clean = self.mod.modulate(data_enc_mod) IQ_data_power = IQ_data_clean.var() # Add preamble sequence # The ZC sequence is given the same variance as the IQ data in order to normalize the power zc_sequence_norm = self.zc_sequence * np.sqrt(IQ_data_power) IQ_data_preamp = np.hstack((zc_sequence_norm, IQ_data_clean)) # Upsampling, Polyphase IQ_data = upsample_poly(IQ_data_preamp, wirt.SAMP_PER_SYMBOL, self.upsamp_filter) # Normalize the power to mean 0 dBm signal_power = (IQ_data.conj() * IQ_data).mean().real IQ_data /= np.sqrt(signal_power) return IQ_data
def test_polar_compare_impl_runtime(): K = 400 N = 2048 num_runs = 10000 ### data = np.frombuffer(np.random.bytes(K // 8), dtype=np.uint8) data_bits = np.unpackbits(data) ### polar_data = polar_encode(N, K, data_bits) polar_data_repacked = packed_to_unpacked(np.packbits(polar_data)) polar_data_modulated = qpsk_modulate(polar_data_repacked) polar_channel_LLRs = qpsk_demodulate_soft(polar_data_modulated, 2).flatten() ### st = pc() for _ in range(num_runs): polar_decode_alternate(N, K, polar_channel_LLRs, use_f_approx=False) time_none = (pc() - st) / num_runs st = pc() for _ in range(num_runs): polar_decode_alternate(N, K, polar_channel_LLRs, use_f_approx=True) time_f = (pc() - st) / num_runs st = pc() for _ in range(num_runs): polar_decode_ssc(N, K, polar_channel_LLRs) time_ssc = (pc() - st) / num_runs print(f"Results from timing test, N={N}, K={K}, num_runs={num_runs}") print("None & {:.2f} \\\\".format(1000 * time_none)) print("$F$ approximation & {:.2f} \\\\".format(1000 * time_f)) print("SSC + $F$ approximation & {:.2f}".format(1000 * time_ssc))
data_orig = np.random.bytes(num_runs * num_databytes) data_orig_uint = np.frombuffer(data_orig, np.uint8).reshape(num_runs, num_databytes) IQ_data_full = np.empty( (num_runs, samp_per_symbol * (symbol_count + len(zc_sequence))), np.complex) for i in range(num_runs): bytes_idx = slice(i * num_databytes, (i + 1) * num_databytes) data = np.frombuffer(data_orig[bytes_idx], dtype=np.uint8) data_bits = np.unpackbits(data) # Encode with a simple (systematic) conv ECC from # data_enc = conv_encode(data, 3, 4, 5) # data_enc = np.concatenate(data_enc) data_polar = polar_encode(polar_size, num_databits, data_bits) data_enc = np.packbits(data_polar) # QPSK modulate data_enc_mod = qpsk_modulate(packed_to_unpacked(data_enc)) # OFDM modulate IQ_data_clean = mod.modulate(data_enc_mod) # Repeat the package to match the size of the transmission window IQ_data_clean = np.tile(IQ_data_clean, (1, num_ofdm_repeats)).ravel() # Upsampling, Polyphase IQ_data = np.zeros(len(IQ_data_clean) * samp_per_symbol, dtype=np.complex) for j in range(samp_per_symbol): IQ_data[j::samp_per_symbol] = np.convolve(IQ_data_clean,
def test_polar_compare_impl(filename='output/polar_compare_impl.npz'): print("Polar with and without approximation.") num_runs_max = 20000 num_frame_errors = 150 ESNOs = np.arange(-12, -9, 0.25) total_bits = 14400 K = 400 N = 2048 reps = total_bits // N run_types = ["None", "F approx", "SSC + F_approx"] results_BER = np.empty((len(run_types), len(ESNOs))) results_BLER = np.empty((len(run_types), len(ESNOs))) for i, esno in enumerate(ESNOs): print("ESNO", esno) for rt_i, _ in enumerate(run_types): total_errors = 0 total_frame_errors = 0 total_bits = 0 total_frames = 0 for _ in range(num_runs_max): ### data = np.frombuffer(np.random.bytes(K // 8), dtype=np.uint8) data_bits = np.unpackbits(data) ### polar_data = np.tile(polar_encode(N, K, data_bits), reps) polar_data_repacked = packed_to_unpacked( np.packbits(polar_data)) polar_data_modulated = qpsk_modulate(polar_data_repacked) ### polar_coded = channel_AWGN(polar_data_modulated, esno) ###### polar_reshaped = polar_coded.reshape((reps, -1)) polar_channel_LLRs = qpsk_demodulate_soft(polar_reshaped, esno) ##### mean_LLRs = polar_channel_LLRs.mean(axis=0).flatten() if rt_i == 0: polar_result = polar_decode_alternate(N, K, mean_LLRs, use_f_approx=False) elif rt_i == 1: polar_result = polar_decode_alternate(N, K, mean_LLRs, use_f_approx=True) elif rt_i == 2: polar_result = polar_decode_ssc(N, K, mean_LLRs) ###### errors = (polar_result != data_bits) total_errors += errors.sum() total_frame_errors += errors.any() total_bits += K total_frames += 1 if total_frame_errors >= num_frame_errors: break else: print("Timeout at {} dB".format(esno)) results_BER[rt_i, i] = total_errors / total_bits results_BLER[rt_i, i] = total_frame_errors / total_frames np.savez(filename, N=N, K=K, repeats=reps, ESNOs=ESNOs, results_BER=results_BER, results_BLER=results_BLER, legend=run_types, config={ 'num_runs_max': num_runs_max, 'num_frame_errors': num_frame_errors, 'total_bits': total_bits })
def test_polar_rate_vs_rep(filename='output/polar_rates_vs_rep.npz'): num_runs_max = 50000 num_frame_errors = 100 ESNOs = np.arange(-12, -6, 0.25) total_bits = 14400 K = 400 Ns = 2**(np.arange(9, 14)) repeats = (total_bits / Ns).astype(int) results_BER = np.empty((len(repeats), len(ESNOs))) results_BLER = np.empty((len(repeats), len(ESNOs))) for i, esno in enumerate(ESNOs): print("ESNO", esno) for n_rep in range(len(repeats)): total_errors = 0 total_frame_errors = 0 total_bits = 0 total_frames = 0 for _ in range(num_runs_max): ### data = np.frombuffer(np.random.bytes(K // 8), dtype=np.uint8) data_bits = np.unpackbits(data) ### polar_data = np.tile(polar_encode(Ns[n_rep], K, data_bits), repeats[n_rep]) polar_data_repacked = packed_to_unpacked( np.packbits(polar_data)) polar_data_modulated = qpsk_modulate(polar_data_repacked) ### polar_coded = channel_AWGN(polar_data_modulated, esno) ### polar_reshaped = polar_coded.reshape((repeats[n_rep], -1)) polar_channel_LLRs = np.mean(qpsk_demodulate_soft( polar_reshaped, esno), axis=0) polar_result = polar_decode_ssc(Ns[n_rep], K, polar_channel_LLRs.flatten()) ### errors = (polar_result != data_bits) total_errors += errors.sum() total_frame_errors += errors.any() total_bits += K total_frames += 1 if total_frame_errors >= num_frame_errors: break else: print("Timeout at {} dB".format(esno)) results_BER[n_rep, i] = total_errors / total_bits results_BLER[n_rep, i] = total_frame_errors / total_frames np.savez(filename, N=Ns, K=K, repeats=repeats, ESNOs=ESNOs, results_BER=results_BER, results_BLER=results_BLER, legend=[f"N: {Ns[i]}, Rep: {repeats[i]}" for i in range(len(Ns))], config={ 'num_runs_max': num_runs_max, 'num_frame_errors': num_frame_errors, 'total_bits': total_bits, })
def test_polar_soft_combine(filename='output/polar_soft_combine.npz'): print("Polar compare post- vs pre-combining.") num_runs_max = 50000 num_frame_errors = 100 ESNOs = np.arange(-12, -9, 0.25) total_bits = 14400 K = 400 Ns = np.array([2048, 2048, 4096, 4096]) repeats = (total_bits / Ns).astype(int) results_BER = np.empty((len(repeats), len(ESNOs))) results_BLER = np.empty((len(repeats), len(ESNOs))) for i, esno in enumerate(ESNOs): print("ESNO", esno) for n_rep in range(len(repeats)): total_errors = 0 total_frame_errors = 0 total_bits = 0 total_frames = 0 for _ in range(num_runs_max): ### data = np.frombuffer(np.random.bytes(K // 8), dtype=np.uint8) data_bits = np.unpackbits(data) ### polar_data = np.tile(polar_encode(Ns[n_rep], K, data_bits), repeats[n_rep]) polar_data_repacked = packed_to_unpacked( np.packbits(polar_data)) polar_data_modulated = qpsk_modulate(polar_data_repacked) ### polar_coded = channel_AWGN(polar_data_modulated, esno) ###### polar_reshaped = polar_coded.reshape((repeats[n_rep], -1)) polar_channel_LLRs = qpsk_demodulate_soft(polar_reshaped, esno) ##### if n_rep % 1 == 0: polar_result = polar_decode_ssc( Ns[n_rep], K, polar_channel_LLRs.mean(axis=0).flatten()) ###### else: polar_results_soft_all = np.empty((repeats[n_rep], K)) for j in range(len(polar_channel_LLRs)): polar_results_soft_all[j] = polar_decode_ssc( Ns[n_rep], K, polar_channel_LLRs[j], soft_output=True) polar_result = polar_results_soft_all.mean(axis=0) ###### errors = (polar_result != data_bits) total_errors += errors.sum() total_frame_errors += errors.any() total_bits += K total_frames += 1 if total_frame_errors >= num_frame_errors: break else: print("Timeout at {} dB".format(esno)) results_BER[n_rep, i] = total_errors / total_bits results_BLER[n_rep, i] = total_frame_errors / total_frames np.savez(filename, N=Ns, K=K, repeats=repeats, ESNOs=ESNOs, results_BER=results_BER, results_BLER=results_BLER, legend=[ "Hard combine", "Soft combine", "Hard combine", "Soft combine" ], config={ 'num_runs_max': num_runs_max, 'num_frame_errors': num_frame_errors, 'total_bits': total_bits })
def test_polar_combining(K=32, repetitions=2, plot=False): num_runs = 100 ESNOs = np.arange(-13, -2, 0.5) # First just repeating and combining soft LLRs # Then a rate 1/2 code, repeated a number of times # Then polar code with the lowest rate possible results_uncoded_BER = np.empty((num_runs, len(ESNOs))) results_uncoded_BLER = np.empty((num_runs, len(ESNOs))) results_rate_half_BER = np.empty((num_runs, len(ESNOs))) results_rate_half_BLER = np.empty((num_runs, len(ESNOs))) results_rate_min_BER = np.empty((num_runs, len(ESNOs))) results_rate_min_BLER = np.empty((num_runs, len(ESNOs))) for n_run in range(num_runs): if num_runs > 10 and n_run % (num_runs // 10) == 0: print(n_run) # Generate data data = np.frombuffer(np.random.bytes(K // 8), dtype=np.uint8) data_bits = np.unpackbits(data) # Match N uncoded_data = np.tile(data_bits, (2 * repetitions)) polar_rate_half = np.tile(polar_encode(2 * K, K, data_bits), repetitions) polar_rate_min = polar_encode(repetitions * 2 * K, K, data_bits) # Pack uncoded_repacked = packed_to_unpacked(np.packbits(uncoded_data)) polar_rate_half_repacked = packed_to_unpacked( np.packbits(polar_rate_half)) polar_rate_min_repacked = packed_to_unpacked( np.packbits(polar_rate_min)) # Modulate uncoded_modulated = qpsk_modulate(uncoded_repacked) polar_rate_half_modulated = qpsk_modulate(polar_rate_half_repacked) polar_rate_min_modulated = qpsk_modulate(polar_rate_min_repacked) for i, esno in enumerate(ESNOs): # print("{}: esno {}".format(i, esno)) uncoded_channel = channel_AWGN(uncoded_modulated, esno) uncoded_reshaped = uncoded_channel.reshape((-1, K // 2)) uncoded_channel_LLRs = np.mean(qpsk_demodulate_soft( uncoded_reshaped, esno), axis=0) uncoded_bits = np.unpackbits( unpacked_to_packed(qpsk_hard_decision(uncoded_channel_LLRs))) results_uncoded_BER[n_run, i] = (uncoded_bits != data_bits).mean() results_uncoded_BLER[n_run, i] = (uncoded_bits != data_bits).any() ### polar_rate_half_channel = channel_AWGN(polar_rate_half_modulated, esno) polar_rate_half_reshaped = polar_rate_half_channel.reshape((-1, K)) polar_rate_half_channel_LLRs = np.mean(qpsk_demodulate_soft( polar_rate_half_reshaped, esno), axis=0) polar_result_rate_half = polar_decode_ssc( 2 * K, K, polar_rate_half_channel_LLRs.flatten()) results_rate_half_BER[n_run, i] = (polar_result_rate_half != data_bits).mean() results_rate_half_BLER[n_run, i] = (polar_result_rate_half != data_bits).any() ### polar_rate_min_channel = channel_AWGN(polar_rate_min_modulated, esno) polar_rate_min_demod = qpsk_demodulate_soft( polar_rate_min_channel, esno).flatten() polar_result_rate_min = polar_decode_ssc(repetitions * 2 * K, K, polar_rate_min_demod) results_rate_min_BER[n_run, i] = (polar_result_rate_min != data_bits).mean() results_rate_min_BLER[n_run, i] = (polar_result_rate_min != data_bits).any() if plot: ### plt.figure("Polar BER test") plt.title( f"Comparison of different rate polar codes, QPSK, AWGN channel, K={K}" ) plt.plot(ESNOs, results_uncoded_BER.mean(axis=0), label=f'Repetition code R = 1 / {1/(2*repetitions)}') plt.plot( ESNOs, results_rate_half_BER.mean(axis=0), label= f'Polar code (SC decoder) R = 1 / {1/2}, repeated = {repetitions}') plt.plot(ESNOs, results_rate_min_BER.mean(axis=0), label=f'Polar code (SC decoder) R = 1 / {1/(2*repetitions)}') plt.ylabel("BER") plt.yscale('log') plt.legend() ### plt.figure("Polar BLER test") plt.title( f"Comparison of different rate polar codes, QPSK, AWGN channel, K={K}" ) plt.plot(ESNOs, results_uncoded_BLER.mean(axis=0), label=f'Repetition code R = 1 / {1/(2*repetitions)}') plt.plot( ESNOs, results_rate_half_BLER.mean(axis=0), label= f'Polar code (SC decoder) R = 1 / {1/2}, repeated = {repetitions}') plt.plot(ESNOs, results_rate_min_BLER.mean(axis=0), label=f'Polar code (SC decoder) R = 1 / {1/(2*repetitions)}') plt.xlabel("ESNO") plt.ylabel("BLER") plt.yscale('log') plt.legend() ### plt.show()
def test_polar_rates(filename='output/polar_various_rates.npz'): print("Polar compare performance at different rates") num_runs_max = 1000 num_frame_errors = 100 ESNOs = np.arange(-11, 3, 0.5) rates = 1 / np.array([2, 3, 5, 10, 16, 20.48]) N = 2**13 K = (N * rates).astype(int) results_BER = np.empty((len(rates), len(ESNOs))) results_BLER = np.empty((len(rates), len(ESNOs))) for i, esno in enumerate(ESNOs): print("ESNO", esno) for K_i, cur_K in enumerate(K): total_errors = 0 total_frame_errors = 0 total_bits = 0 total_frames = 0 for _ in range(num_runs_max): data_bits = np.random.binomial(1, 0.5, cur_K).astype(np.uint8) polar_data = polar_encode(N, cur_K, data_bits) polar_data_repacked = packed_to_unpacked( np.packbits(polar_data)) polar_data_modulated = qpsk_modulate(polar_data_repacked) polar_coded = channel_AWGN(polar_data_modulated, esno) polar_coded_demod_soft = qpsk_demodulate_soft( polar_coded, esno).flatten() polar_result = polar_decode_ssc(N, cur_K, polar_coded_demod_soft) ###### errors = (polar_result != data_bits) total_errors += errors.sum() total_frame_errors += errors.any() total_bits += cur_K total_frames += 1 if total_frame_errors >= num_frame_errors: break else: print("Timeout at {} dB".format(esno)) results_BER[K_i, i] = total_errors / total_bits results_BLER[K_i, i] = total_frame_errors / total_frames np.savez(filename, N=N, K=K, ESNOs=ESNOs, results_BER=results_BER, results_BLER=results_BLER, legend=[f"Rate: {r}" for r in rates], config={ 'num_runs_max': num_runs_max, 'num_frame_errors': num_frame_errors, 'total_bits': total_bits, })
def test_BER(filename='output/BER_compare.npz', enable_conv=False): num_runs_max = 20000 num_frame_errors = 150 ESNOs = np.arange(-1, 10, 0.25) N = 2**13 K = N // 2 types = [ "Uncoded", "Repetition code (Hard)", "Repetition code (Soft)", "Polar code" ] if enable_conv: conv_params = (3, 7, 5) types += "Convolutional code" N_types = len(types) results_BER = np.empty((N_types, len(ESNOs))) results_BLER = np.empty((N_types, len(ESNOs))) if enable_conv: conv_params = (3, 7, 5) for i, esno in enumerate(ESNOs): print("ESNO", esno) # A counter for the total number of frame errors, so we can stop when some of the # schemes have reached their limit. total_frame_errors = np.zeros(N_types, np.int) total_bit_errors = np.zeros(N_types, np.int) total_frames = np.zeros(N_types, np.int) total_bits = np.zeros(N_types, np.int) for _ in range(num_runs_max): data = np.frombuffer(np.random.bytes(K // 8), dtype=np.uint8) data_unpacked = packed_to_unpacked(data) data_bits = np.unpackbits(data) ### if total_frame_errors[0] < num_frame_errors: data_modulated = qpsk_modulate(data_unpacked) uncoded = channel_AWGN(data_modulated, esno) uncoded_bits = np.unpackbits( unpacked_to_packed(qpsk_demodulate(uncoded))) total_frame_errors[0] += (uncoded_bits != data_bits).any() total_bit_errors[0] += np.count_nonzero( uncoded_bits != data_bits) total_frames[0] += 1 total_bits[0] += K ### if (total_frame_errors[1] < num_frame_errors) and ( total_frame_errors[2] < num_frame_errors): rep_modulated = np.tile(data_modulated, (1, 2)).ravel() rep_coded = channel_AWGN(rep_modulated, esno) rep_coded_reshaped = rep_coded.reshape((-1, len(uncoded))) rep_coded_hard = np.array([1, 2], np.uint8) @ (np.stack( (rep_coded_reshaped.real < 0, rep_coded_reshaped.imag < 0)).sum(axis=1) >= 1) rep_coded_hard_bits = np.unpackbits( unpacked_to_packed(rep_coded_hard)) rep_coded_LLRs = np.roll(qpsk_demodulate_soft( rep_coded_reshaped, esno).mean(axis=0), 1, axis=1) rep_coded_soft_bits = np.unpackbits( unpacked_to_packed(qpsk_hard_decision(rep_coded_LLRs))) total_frame_errors[1] += (rep_coded_hard_bits != data_bits).any() total_bit_errors[1] += np.count_nonzero( rep_coded_hard_bits != data_bits) total_frame_errors[2] += (rep_coded_soft_bits != data_bits).any() total_bit_errors[2] += np.count_nonzero( rep_coded_soft_bits != data_bits) total_frames[1:3] += 1 total_bits[1:3] += K ### if total_frame_errors[3] < num_frame_errors: polar_data = polar_encode(N, K, data_bits) polar_data_repacked = packed_to_unpacked( np.packbits(polar_data)) polar_data_modulated = qpsk_modulate(polar_data_repacked) polar_coded = channel_AWGN(polar_data_modulated, esno) polar_coded_demod_soft = qpsk_demodulate_soft( polar_coded, esno).flatten() polar_result = polar_decode_ssc(N, K, polar_coded_demod_soft) total_frame_errors[3] += (polar_result != data_bits).any() total_bit_errors[3] += np.count_nonzero( polar_result != data_bits) total_frames[3] += 1 total_bits[3] += K ### if enable_conv and total_frame_errors[4] < num_frame_errors: conv_data = conv_encode(data, *conv_params) conv_data_modulated = qpsk_modulate( packed_to_unpacked(conv_data)) conv_coded = channel_AWGN(conv_data_modulated, esno) conv_coded_demod = np.frombuffer(unpacked_to_packed( qpsk_demodulate(conv_coded)), dtype=np.uint8) conv_decoded = conv_decode(conv_coded_demod[::2], conv_coded_demod[1::2], *conv_params) total_frame_errors[4] += (np.unpackbits(conv_decoded) != data_bits).any() total_bit_errors[4] += np.count_nonzero( np.unpackbits(conv_decoded) != data_bits) total_frames[4] += 1 total_bits[4] += K results_BER[:, i] = total_bit_errors / total_bits results_BLER[:, i] = total_frame_errors / total_frames qfunc = lambda x: 0.5 * erfc(x / np.sqrt(2)) expected_uncoded_BER = qfunc(np.sqrt(10**(ESNOs / 10))) np.savez(filename, N=N, K=K, ESNOs=ESNOs, results_BER=results_BER, results_BLER=results_BLER, expected_BER_uncoded=expected_uncoded_BER, legend=types, config={ 'num_runs_max': num_runs_max, 'num_frame_errors': num_frame_errors, })
def test_polar_limit(filename='output/polar_limit_rate05_nossc.npz'): num_runs_max = 20000 num_frame_errors = 100 ESNOs = np.arange(-1, 5, 0.25) SEED = 456 N = 8192 K = 4096 np.random.seed(SEED) results_BER = np.empty((len(ESNOs))) results_BLER = np.empty((len(ESNOs))) results_frame_errors = np.empty((len(ESNOs))) for i, esno in enumerate(ESNOs): print("ESNO", esno) total_errors = 0 total_frame_errors = 0 total_bits = 0 total_frames = 0 for _ in range(num_runs_max): ### data = np.frombuffer(np.random.bytes(K // 8), dtype=np.uint8) data_bits = np.unpackbits(data) ### polar_data = polar_encode(N, K, data_bits) polar_data_repacked = packed_to_unpacked(np.packbits(polar_data)) polar_data_modulated = qpsk_modulate(polar_data_repacked) ### polar_coded = channel_AWGN(polar_data_modulated, esno) ### polar_coded_demod_soft = qpsk_demodulate_soft(polar_coded, esno).flatten() # polar_result = polar_decode_ssc(N, K, polar_coded_demod_soft) polar_result = polar_decode_alternate(N, K, polar_coded_demod_soft, use_f_approx=False) ### errors = (polar_result != data_bits) total_errors += errors.sum() total_frame_errors += errors.any() total_frames += 1 total_bits += len(data_bits) if total_frame_errors >= num_frame_errors: break else: print("Timeout at {} dB".format(esno)) results_BER[i] = total_errors / total_bits results_BLER[i] = total_frame_errors / total_frames results_frame_errors[i] = total_frame_errors #% Save file config = { "seed": SEED, "num_runs": num_runs_max, "ESNOs": ESNOs, "Time": datetime.now(), 'num_runs_max': num_runs_max, 'num_frame_errors_max': num_frame_errors } np.savez(filename, N=N, K=K, ESNOs=ESNOs, results_BER=results_BER, results_BLER=results_BLER, frame_errors=results_frame_errors, config=config)
for i in range(K): u_hat[i] = B[A[i]] return u_hat # Configuration N = 16 K = 3 # Input data u = np.array([1, 0, 1]) # u = np.random.binomial(1, 0.5, K) # Encode x = polar_encode(N, K, u) # Channel L0 = np.zeros(x.shape) # Probability that received bit is zero L0[x == 0] = 0.9 L0[x == 1] = 0.1 LR0 = L0 / (1 - L0 ) # Likeliky ratio = (prob. bit is zero) / (prob. bit is one) LLR = np.log(LR0) #u = np.array([1,0,0]) #x = np.array([1, 1, 0, 0, 1, 1, 0, 0], dtype=np.uint8) #LLR = np.array([-2.19722458, -2.19722458, -2.19722458, -2.19722458, # 2.19722458, 2.19722458, 2.19722458, 2.19722458, # -2.19722458, -2.19722458, -2.19722458, -2.19722458, # 2.19722458, 2.19722458, 2.19722458, 2.19722458])