Updated simulator: better code-writing for matlab-run.

Author: Alex

support/README.md README.mdsupport/README.md renamed to README.md

@@ -0,0 +1,25 @@
+timestamp = [num2str(start_time(1),'%04d') '_' num2str(start_time(2),'%02d') '_' num2str(start_time(3),'%02d') '_' num2str(start_time(4),'%02d') '_' num2str(start_time(5),'%02d') '_' num2str(start_time(6),'%2.0f')];
+result_path = './results/';
+addpath('support');
+fast_run = 1;           %1:run of optimal-matlab code, 0:run of hardware-code (suboptimal f/g)
+Fading_Channel = 0;     %0: AWGN, 1:Fading Channel
+Fading_Independent = 0; %if Fading_Channel = 1
+quasi = 0;              % quasi channel
+fading_channel = 'TU120';   %custom matlab channel
+fix_seed = 1;           %1:fix data, 0:random data
+code_rate = 1/4;
+if fix_seed
+    rng(sum(100*clock));
+else
+    rand('seed',123456);
+end
+%Simulation values
+min_fer_errors = 100;
+min_codewords = 100;
+NbitsPerSymbol = 1;
+constDims = 1;
+%EbNo
+EbNo_dB = -2:4;
+snrdb_values =EbNo_dB+10*log10(double(code_rate*NbitsPerSymbol*2/constDims));
+%Polar-Code values
+capacity = 0.5; %I(W), Channel's W Capacity

config.m

@@ -1,47 +1,45 @@
 clc;clear;
 start_time = clock;
-timestamp = [num2str(start_time(1),'%04d') '_' num2str(start_time(2),'%02d') '_' num2str(start_time(3),'%02d') '_' num2str(start_time(4),'%02d') '_' num2str(start_time(5),'%02d') '_' num2str(start_time(6),'%2.0f')];
-result_path = './results/';
-file = fopen([result_path 'polar_test_' timestamp '.txt'],'w');
-addpath('support');
-Fading_Channel = 0;     %0: AWGN, 1:Fading Channel
-Fading_Independent = 0; %if Fading_Channel = 1
-quasi = 0;              % quasi channel
-fading_channel = 'TU120';   %custom matlab channel
-fix_seed = 1;           %1:fix data, 0:random data
-if fix_seed
-    rng(sum(100*clock));
-else
-    rand('seed',123456);
-end
-for n = 6%[2,3,4,5,6,7,8,9] %N=2^n
+config;
+for n = [7,8,9,10] %N=2^n
 N = power(2,n);      %Code Length
-K = N/2;      %Code keyword length
-capacity = 0.5; %I(W), Channel's W Capacity
+K = N* code_rate;      %Code keyword length
+mat_file = [result_path 'polar_N' num2str(N) '_K' num2str(K) '_' timestamp '.mat'];
+bit_error_rate = zeros(1,length(snrdb_values));
+fer_error_rate = zeros(1,length(snrdb_values));
+codewords = zeros(1,length(snrdb_values));
+%Polar-code initializations
+Fn = fkronecker(N);
 frozen_bits = initialize_frozen_bits(N,K,capacity); %0=frozen, 1=not_frozen
-%%
-fprintf(file,'\n\n[%d,%d,%d,%d,%d,%d]\n',[0,2,4,6,8,10]);%[0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5]);
-fprintf(file,'N = %d\n[', N);
-SNRdb_values = 0:5;
-for SNRdb = SNRdb_values %[0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5]
+partial_sum_adders = partial_sums_initialize(N);   %!!!!! NOT bit_reversed array -- %outputs(z,i,l) -- l stage ,bit Ui is added,z is the number of g adder
+[sc_functions,sc_2nd_indxs] = sc_array_initialize(N);
+for i_index = 1:length(snrdb_values) %[0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5]
+%Initialize temporary variables
+codewords_tmp = 0;
 fer_errors = 0;
 bit_errors = 0;
-codewords = 0;
-while (fer_errors<100 || codewords<100)
-codewords = codewords + 1;
-inputs = randi([0,1],1,K);    %write random inputs
+snr = snrdb_values(i_index);
+while (fer_errors<min_fer_errors || codewords_tmp<min_codewords)
+codewords_tmp = codewords_tmp + 1;
+inputs = rand(1,K)>0.5;    %write random inputs
 %transform inputs
 inputs_to_encode = transform_inputs(inputs,frozen_bits,N);
 %encode
-encoded_inputs = encode(inputs_to_encode);      %Reversed Polar Encoding
+encoded_inputs = encode(inputs_to_encode,Fn);      %Reversed Polar Encoding
 %modulate
 modulated_inputs = modulate(encoded_inputs);%encoded_inputs);        %BPSK = 1-2*encoded_inputs(i)
 %noise
-noised_inputs = add_noise(modulated_inputs,Fading_Channel,Fading_Independent,fading_channel,SNRdb);
+noised_inputs = add_noise(modulated_inputs,constDims,Fading_Channel,Fading_Independent,fading_channel,snrdb_values(i_index));
 %demodulate
-llr = (2 * power(10,SNRdb/10))*noised_inputs;       %CARE NEGATIVE SIGN.2*yi/(s^2) = ln(Li), s^2 = 1/ 10^ (SNRdb/10)
+llr = (2 * power(10,snrdb_values(i_index)/10))*noised_inputs;       %CARE NEGATIVE SIGN.2*yi/(s^2) = ln(Li), s^2 = 1/ 10^ (SNRdb/10)
 %decode
-outputs = decode(llr,frozen_bits);
+if(fast_run)
+    %optimal version (optimal-calculations of f/g)
+    outputs = decode2(llr,frozen_bits);
+else
+    %hardware-version (suboptimal-calculations of f/g)
+    outputs = decode(llr,frozen_bits,partial_sum_adders,sc_functions,sc_2nd_indxs);
+end
 %or decode(llr,frozen_bits); for the other algorithm
 %choose A set (not frozen bits)
 %Calculate bit/frame errors
@@ -50,14 +48,13 @@
 bit_errors = bit_errors + temp_bit_errors;
 fer_errors = fer_errors + (temp_bit_errors>0);
 end
-bit_error_rate = bit_errors/(codewords*K);
-frame_error_rate = fer_errors/(codewords);
-fprintf(file,'SNRdb = %d\tber=%0.8f,fer=%0.8f\n',SNRdb,bit_error_rate,frame_error_rate);
-fprintf('SNRdb = %d\tber=%0.8f,fer=%0.8f\n',SNRdb,bit_error_rate,frame_error_rate);
+bit_error_rate(i_index) = bit_errors/(codewords_tmp*K);
+fer_error_rate(i_index) = fer_errors/(codewords_tmp);
+codewords(i_index) = codewords_tmp;
+save(mat_file,'snrdb_values','bit_error_rate','fer_error_rate','codewords','N','K');
+fprintf('SNRdb = %d\tber=%0.8f,fer=%0.8f\n',snrdb_values(i_index),bit_error_rate(i_index),fer_error_rate(i_index));
 end
-file = fopen([result_path 'results_N=' num2str(N) '_SNR=' num2str(SNRdb_values(1)) '-' num2str(SNRdb_values(end)) '.txt'],'w');
-fprintf(file,'0]\n');
+% file = fopen([result_path 'results_N=' num2str(N) '_SNR=' num2str(snrdb_values(1)) '-' num2str(snrdb_values(end)) '.txt'],'w');
+% fprintf(file,'0]\n');
 end
-%fprintf(file,'SNRmean = %2.5f]\n',SNRmean/20);
-fclose(file);
 

main.m

@@ -1,4 +1,4 @@
-function channel_out = add_noise(inputs,Fading_Channel,Fading_Independent,fading_channel,snr)
+function channel_out = add_noise(inputs,constDims,Fading_Channel,Fading_Independent,fading_channel,snr)
 %takes modulated inputs, adds AWGN/Fading noise with SNR in db.
 if Fading_Channel && ~Fading_Independent
     legacychannelsim(true);
@@ -40,10 +40,13 @@
     attenu = 1;
     phase = 0;
 end
-constDims = 2;
+
 noise_dev = sqrt(10^(-snr/10)/constDims);
-channel_out = noise_dev*complex(randn(1,length(inputs)),randn(1,length(inputs))) ...
-        + in_decoder_tmp;
+%BPSK
+channel_out = noise_dev*(randn(1,length(inputs))) + in_decoder_tmp;
+%QPSK    
+% channel_out = noise_dev*complex(randn(1,length(inputs)),randn(1,length(inputs))) ...
+%         + in_decoder_tmp;
 
 %old noise addition based on awgn
 % channel_out = awgn(inputs,snr,'measured');

support/Polar Codes Diploma Thesis.pdf

@@ -1,21 +1,18 @@
 function capacities = capacities( N, capacity)
 %Estimates the capacities of all channels
 %Outputs array with the capacities of the N channels
-capacities = zeros(1,N);
 bits = log2(N);
-    for i=1:1:N
-        capacities(i) = capacity;
-    end
-    for j=0:1:bits-1
-        step = power(2,j);
-        for i=1:2*step:power(2,bits)
-            for z=i:1:i+step-1
-                temp = capacities(z) * capacities(z);
-                capacities(z+step) = 2*capacities(z+step) - temp;
-                capacities(z)= temp;
-            end
+capacities = ones(1,N)*capacity;
+for j=0:1:bits-1
+    step = power(2,j);
+    for i=1:2*step:power(2,bits)
+        for z=i:1:i+step-1
+            temp = capacities(z) * capacities(z);
+            capacities(z+step) = 2*capacities(z+step) - temp;
+            capacities(z)= temp;
         end
     end
+end
 
 
 end

support/add_noise.m

@@ -1,24 +1,25 @@
-function outputs = decode(llr_inputs,frozen_bits)
+function outputs = decode(llr_inputs,frozen_bits,partial_sum_adders,sc_functions,sc_2nd_indxs)
 bits = length(llr_inputs);
 reverse_order = bitrevorder(1:1:bits); %same as 0:1:bits-1
-sc_array = sc_array_initialize(bits,llr_inputs);%--BIT_REVERSED ARRAY-- outputs(i,l,dimension) // dimension= 1 values -- 2 !! if 0 then f else g !!-- 3 2nd input
-partial_sum_adders = partial_sums_initialize(bits);   %!!!!! NOT bit_reversed array -- %outputs(z,i,l) -- l stage ,bit Ui is added,z is the number of g adder
+sc_array = zeros(bits,log2(bits)+1);
+sc_array(:,log2(bits)+1) = llr_inputs.';
 outputs = zeros(1,bits);        %NOT bit_reversed_array
-for bit=1:1:bits %Arikan 0:1:bits-1
+non_frozen_indxs = find(frozen_bits == 1);
+for bit=non_frozen_indxs %Arikan 0:1:bits-1
     for l= log2(bits):-1:1 %Arikan log2(bits)-1:-1:0 
         partial_sums_l = partial_sum_adders(:,:,l) * (transpose(outputs)); %NOT bit_reversed_array
         partial_sums_l = mod(partial_sums_l,2);     %mod 2
         z = 0;      %number of partial sum
         for i = 1:1:bits
-            if(sc_array(i,l,2) == 0)
-                sc_array(i,l,1) = f(sc_array(i+sc_array(i,l,3),l+1,1),sc_array(i,l+1,1));       %getting values from l+1 stage
+            if(sc_functions(i,l) == 0)
+                sc_array(i,l,1) = f(sc_array(i+sc_2nd_indxs(i,l),l+1,1),sc_array(i,l+1,1));       %getting values from l+1 stage
             else
                 z = z+1;    %the number of adder
-                sc_array(i,l,1) = g(sc_array(i+sc_array(i,l,3),l+1,1),sc_array(i,l+1,1),partial_sums_l(z));     %getting values from l+1 stage + partial_sum
+                sc_array(i,l,1) = g(sc_array(i+sc_2nd_indxs(i,l),l+1,1),sc_array(i,l+1,1),partial_sums_l(z));     %getting values from l+1 stage + partial_sum
             end
         end
     end
-    if(sc_array(reverse_order(bit),1,1)<0 && frozen_bits(bit)==1)       %if it's not frozen bit, update value
+    if(sc_array(reverse_order(bit),1,1)<0)       %if it's not frozen bit, update value
         outputs(bit)=1;
     end
 end

support/capacities.m

@@ -1,7 +1,6 @@
-function outputs = encode(inputs)
+function outputs = encode(inputs,Fn)
 %outputs = x where x= u * G , where G = B(N) * Fn
 %basic encoding scheme with kronecker power of Fn.
-Fn = fkronecker(length(inputs));
 outputs = mod(bitrevorder(inputs) * Fn,2); %Reversed outputs
 end
 

support/decode.m

@@ -2,11 +2,10 @@
     %inputs N codelength, K code keyword length, capacity of the channel
     %outputs a N-length array with 0,1. If 0 then the channel is frozen
     %if 1 not frozen.
+    %calculate capacities and reverse them (reverse-encode)
     capacity_array = bitrevorder(capacities(N, capacity));
-    [capacity_array,sortIndex] = sort(capacity_array(:));
+    [~,sortIndex] = sort(capacity_array(:));
+    %freeze N-K worst-channels and keep K best-channels
     frozen_bits = ones(1,N);
-    for i=1:1:N-K
-        frozen_bits(sortIndex(i)) = 0;
-    end
-        
+    frozen_bits(sortIndex(1:N-K)) = 0;
 end