Implemented CRC initialised to with all ones for PDCCH.

Author: robmaunder

PDCCH_decoder.m

@@ -84,4 +84,4 @@
 info_bit_pattern = get_3GPP_info_bit_pattern(K, Q_N, rate_matching_pattern, mode);
 
 % Perform Distributed-CRC-Aided polar decoding.
-a_hat = DSCA_polar_decoder(f_tilde,crc_polynomial_pattern,RNTI,crc_interleaver_pattern,info_bit_pattern,rate_matching_pattern,mode,L,min_sum,P2);
+a_hat = DS1CA_polar_decoder(f_tilde,crc_polynomial_pattern,RNTI,crc_interleaver_pattern,info_bit_pattern,rate_matching_pattern,mode,L,min_sum,P2);

PDCCH_encoder.m

@@ -66,4 +66,4 @@
 info_bit_pattern = get_3GPP_info_bit_pattern(K, Q_N, rate_matching_pattern, mode);
 
 % Perform Distributed-CRC-Aided polar encoding.
-f = DSCA_polar_encoder(a,crc_polynomial_pattern, RNTI, crc_interleaver_pattern,info_bit_pattern,rate_matching_pattern);
+f = DS1CA_polar_encoder(a,crc_polynomial_pattern, RNTI, crc_interleaver_pattern,info_bit_pattern,rate_matching_pattern);

components/DSCA_polar_decoder.m components/DS1CA_polar_decoder.mcomponents/DSCA_polar_decoder.m renamed to components/DS1CA_polar_decoder.m

@@ -1,6 +1,6 @@
-function a_hat = DSCA_polar_decoder(e_tilde, crc_polynomial_pattern, crc_scrambling_pattern, crc_interleaver_pattern, info_bit_pattern, rate_matching_pattern, mode, L, min_sum, P2)
-% DSCA_POLAR_DECODER Distributed-and-Scrambled-CRC-Aided (DSCA) polar decoder.
-%   a_hat = DSCA_POLAR_DECODER(e_tilde, crc_polynomial_pattern, crc_interleaver_pattern, info_bit_pattern, rate_matching_pattern, mode, L, min_sum, P2) 
+function a_hat = DS1CA_polar_decoder(e_tilde, crc_polynomial_pattern, crc_scrambling_pattern, crc_interleaver_pattern, info_bit_pattern, rate_matching_pattern, mode, L, min_sum, P2)
+% DS1CA_POLAR_DECODER Distributed-Scrambled-and-1-initialised-CRC-Aided (DS1CA) polar decoder.
+%   a_hat = DS1CA_POLAR_DECODER(e_tilde, crc_polynomial_pattern, crc_interleaver_pattern, info_bit_pattern, rate_matching_pattern, mode, L, min_sum, P2) 
 %   decodes the encoded LLR sequence e_tilde, in order to obtain the
 %   recovered information bit sequence a_hat.
 %
@@ -66,7 +66,7 @@
 %   each having the value 0 or 1. However, in cases where the CRC check 
 %   fails, a_hat will be an empty vector.
 %
-%   See also DSCA_POLAR_ENCODER
+%   See also DS1CA_POLAR_ENCODER
 %
 % Copyright © 2017 Robert G. Maunder. This program is free software: you 
 % can redistribute it and/or modify it under the terms of the GNU General 
@@ -211,8 +211,13 @@
 
         % We use the interleaved CRC generator matrix to update the CRC 
         % check sums whenever an information or CRC bit adopts a value of
-        % 1.
-        crc_checksums = cat(3,crc_checksums,mod(crc_checksums+repmat(G_P3(i2,:)',[1 1 L_prime]),2));
+        % 1. We need to toggle the first P information bits to model a CRC 
+        % that is initialised with all ones.
+        if crc_interleaver_pattern(i2) <= P
+            crc_checksums = cat(3,mod(crc_checksums+repmat(G_P3(i2,:)',[1 1 L_prime]),2),crc_checksums);            
+        else
+            crc_checksums = cat(3,crc_checksums,mod(crc_checksums+repmat(G_P3(i2,:)',[1 1 L_prime]),2));
+        end
         % We need to keep track of whether any of the checks associated 
         % with the previous CRC bits have failed.
         crc_okay = cat(3,crc_okay,crc_okay);

components/DSCA_polar_encoder.m components/DS1CA_polar_encoder.mcomponents/DSCA_polar_encoder.m renamed to components/DS1CA_polar_encoder.m

@@ -1,6 +1,6 @@
-function e = DSCA_polar_encoder(a, crc_polynomial_pattern, crc_scrambling_pattern, crc_interleaver_pattern, info_bit_pattern, rate_matching_pattern)
-% DSCA_POLAR_ENCODER Distributed-and-Scrambled-CRC-Aided (DSCA) polar encoder.
-%   e = CA_POLAR_ENCODER(a, crc_polynomial_pattern, crc_interleaver_pattern, info_bit_pattern, rate_matching_pattern) 
+function e = DS1CA_polar_encoder(a, crc_polynomial_pattern, crc_scrambling_pattern, crc_interleaver_pattern, info_bit_pattern, rate_matching_pattern)
+% DS1CA_POLAR_ENCODER Distributed-Scrambled-and-1-initialised-CRC-Aided (DS1CA) polar encoder.
+%   e = DS1CA_POLAR_ENCODER(a, crc_polynomial_pattern, crc_interleaver_pattern, info_bit_pattern, rate_matching_pattern) 
 %   encodes the information bit sequence a, in order to obtain the encoded 
 %   bit sequence e.
 %
@@ -38,7 +38,7 @@
 %   e will be a binary row vector comprising E number of bits, each having
 %   the value 0 or 1.
 %
-%   See also DSCA_POLAR_DECODER
+%   See also DS1CA_POLAR_DECODER
 %
 % Copyright © 2017 Robert G. Maunder. This program is free software: you 
 % can redistribute it and/or modify it under the terms of the GNU General 
@@ -72,7 +72,16 @@
 
 % Generate the CRC bits.
 G_P = get_crc_generator_matrix(A,crc_polynomial_pattern);
-crc_bits = mod(a*G_P,2);
+a2 = a;
+a2((1:A)<=P) = ~a2((1:A)<=P); % Toggle the first P bits to model a CRC that is initialised with all ones
+crc_bits = mod(a2*G_P,2);
+crc_bits((A+1:A+P) <= P) = ~crc_bits((A+1:A+P) <= P);
+
+crc_bits2 = calculate_crc_ones(a,crc_polynomial_pattern);
+
+if ~isequal(crc_bits,crc_bits2)
+    error('Rob');
+end
 
 % Scramble the CRC bits.
 scrambled_crc_bits = xor(crc_bits,[zeros(1,P-length(crc_scrambling_pattern)),crc_scrambling_pattern]);

components/calculate_crc.m

@@ -4,5 +4,4 @@
 
 for bit_index = 1:length(bits)
     crc = xor(xor(crc(1),bits(bit_index))*crc_polynomial_pattern(2:end),[crc(2:end),0]);
-    
 end

components/calculate_crc_ones.m

@@ -0,0 +1,8 @@
+function crc = calculate_crc_ones(bits, crc_polynomial_pattern)
+
+crc = ones(1,length(crc_polynomial_pattern)-1);
+
+for bit_index = 1:length(bits)
+    crc = xor(xor(crc(1),bits(bit_index))*crc_polynomial_pattern(2:end),[crc(2:end),0]);
+    
+end

components/get_crc_generator_matrix_ones.m

@@ -0,0 +1,42 @@
+function G_P = get_crc_generator_matrix_ones(A, crc_polynomial_pattern)
+% GET_CRC_GENERATOR_MATRIX Obtain a Cyclic Redudancy Check (CRC) generator 
+% matrix.
+%   G_P = GET_CRC_GENERATOR_MATRIX(A, crc_polynomial_pattern) obtains the CRC
+%   generator matrix G.
+%
+%   A should be an integer scalar. It specifies the number of bits in the
+%   information bit sequence.
+%
+%   crc_polynomial_pattern should be a binary row vector comprising P+1
+%   number of bits, each having the value 0 or 1. These bits parameterise a
+%   Cyclic Redundancy Check (CRC) comprising P bits. Each bit provides the
+%   coefficient of the corresponding element in the CRC generator
+%   polynomial. From left to right, the bits provide the coefficients for
+%   the elements D^P, D^P-1, D^P-2, ..., D^2, D, 1.
+%
+%   G_P will be a K by P binary matrix. The CRC bits can be generated
+%   according to mod(a*G_P,2).
+%
+% Copyright © 2017 Robert G. Maunder. This program is free software: you 
+% can redistribute it and/or modify it under the terms of the GNU General 
+% Public License as published by the Free Software Foundation, either 
+% version 3 of the License, or (at your option) any later version. This 
+% program is distributed in the hope that it will be useful, but WITHOUT 
+% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
+% FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 
+% more details.
+
+
+P = length(crc_polynomial_pattern)-1;
+
+if P<1
+    error('crc_polynomial_pattern is invalid');
+end
+
+G_P = zeros(A,P);
+
+for k = 1:A    
+    G_P(k,:) = calculate_crc_ones(zeros(1,k), crc_polynomial_pattern);
+end
+
+

components/test_crc.m

@@ -7,16 +7,21 @@
     crc_generator_pattern(end) = 1;
 
 
-    A = randi([0,2000]);
+    A = randi([0,100]);
 
     [P,A]
 
     G_P = get_crc_generator_matrix(A, crc_generator_pattern);
 
     a = round(rand([1,A]));
 
-    crc1 = mod(a*G_P,2);
-    crc2 = calculate_crc(a,crc_generator_pattern);
+    a2 = a;
+    a2(1:A < P) = ~a2(1:A<P);
+    
+    crc1 = mod(a2*G_P,2);
+    crc1((A+1:A+P) < P) = ~crc1((A+1:A+P) < P);
+    
+    crc2 = calculate_crc_ones(a,crc_generator_pattern);
 
     if ~isequal(crc1,crc2)
         [crc1;crc2]

components/test_crc2.m

@@ -0,0 +1,36 @@
+
+
+
+while 1
+    
+    P = randi([2,20]);
+    
+    crc_generator_pattern = round(rand([1,P]));
+    crc_generator_pattern(1) = 1;
+    crc_generator_pattern(end) = 1;
+    
+    
+    A = randi([20,100]);
+    
+    [P,A]
+    
+         
+    crc_ones = calculate_crc_ones(zeros(1,A),crc_generator_pattern);
+    
+    diff = crc_ones;
+    
+    
+    for rep = 1:100
+        
+     a = round(rand([1,A]));
+    
+    crc_zeros = calculate_crc(a,crc_generator_pattern);
+    crc_ones = calculate_crc_ones(a,crc_generator_pattern);
+    
+    
+    if ~isequal(diff, xor(crc_zeros,crc_ones))
+        [crc1;crc2]
+        error('Rob');
+    end
+    end
+end

components/test_crc3.m

@@ -0,0 +1,32 @@
+A_max = 100;
+
+
+while 1
+    
+    P = randi([2,20]);
+    
+    crc_generator_pattern = round(rand([1,P]));
+    crc_generator_pattern(1) = 1;
+    crc_generator_pattern(end) = 1;
+
+    G_P2 = get_crc_generator_matrix_ones(A_max, crc_generator_pattern);
+    
+    
+    A = randi([20,A_max]);
+    
+    [P,A]
+    
+    G_P = get_crc_generator_matrix(A, crc_generator_pattern);
+    
+    a = round(rand([1,A]));
+        
+%    crc1 = xor(mod(a*G_P,2),calculate_crc_ones(zeros(1,A),crc_generator_pattern));
+
+    crc1 = xor(mod(a*G_P,2),G_P2(A,:));
+    crc2 = calculate_crc_ones(a,crc_generator_pattern);
+    
+    if ~isequal(crc1,crc2)
+        [crc1;crc2]
+        error('Rob');
+    end
+end