initial upload

Author: Christian Häger

DensE/DE_base.m

@@ -0,0 +1,126 @@
+classdef DE_base < handle
+  properties
+    channel   % DE_channel
+    scheme    % DE_scheme
+    precision % for threshold computation
+  end
+  
+  properties(Access = private)
+    max_iterations
+    target_error_rate
+  end
+  
+  methods
+    function obj = DE_base(p_channel, p_scheme, p_max_iterations, p_target_error_rate)
+      obj.channel = p_channel;
+      obj.scheme = p_scheme;
+      obj.max_iterations = p_max_iterations;
+      obj.target_error_rate = p_target_error_rate;
+      obj.precision = p_channel.default_precision; % default precision from the channel
+      disp(['threshold is determined with precision: obj.precision = ' num2str(obj.precision)]);
+      
+      % passing functionalities to the ensemble object
+      obj.scheme.set_max_iterations(obj.max_iterations);
+      obj.scheme.set_target_error_rate(p_target_error_rate);
+      obj.scheme.set_channel(p_channel);
+    end
+    
+    function threshold = find_threshold(obj)
+      % Find the approximate treshold via bisection method (binary search)
+      
+      % initial search range
+      channel_param_lb = obj.channel.channel_param_lb;
+      channel_param_ub = obj.channel.channel_param_ub;
+      higher_is_better  = obj.channel.higher_is_better; 
+      
+      if(channel_param_lb >= channel_param_ub)
+        error('Lower bound has to be strictly lower than upper bound');
+      end
+     
+      if(higher_is_better)
+        % higher ChannelParameter is better (e.g., SNR)
+        while(1)
+          channel_param_test = channel_param_lb+(channel_param_ub-channel_param_lb)/2;
+          success = obj.scheme.density_evolution(channel_param_test);
+
+          if(success)
+            channel_param_ub = channel_param_test;
+          else
+            channel_param_lb = channel_param_test;
+          end
+
+          if(channel_param_ub - channel_param_lb < obj.precision)
+            threshold = ceil(channel_param_ub/obj.precision)*obj.precision; 
+            if(obj.scheme.density_evolution(threshold-obj.precision))
+              threshold = threshold - obj.precision; 
+            end
+            break;
+          end
+        end % while
+      else
+        % lower ChannelParameter is better (e.g., erasure prob.)
+        while(1)
+          channel_param_test = channel_param_lb+(channel_param_ub-channel_param_lb)/2;
+          success = obj.scheme.density_evolution(channel_param_test);
+
+          if(success)
+            channel_param_lb = channel_param_test;
+          else
+            channel_param_ub = channel_param_test;
+          end
+
+          if(channel_param_ub - channel_param_lb < obj.precision)
+            threshold = floor(channel_param_lb/obj.precision)*obj.precision; 
+            if(obj.scheme.density_evolution(threshold+obj.precision))
+              threshold = threshold + obj.precision; 
+            end
+            break;
+          end
+        end % while
+      end
+    end % find_threshold
+    
+    function pe = get_final_error_rate(obj, channel_parameter_range)
+      
+      pe = zeros(size(channel_parameter_range));
+      
+      for i = 1:length(pe)
+        obj.scheme.density_evolution(channel_parameter_range(i));
+        pe(i) = obj.scheme.get_finalErrProb();
+      end
+    end
+    
+    function iter = required_iterations(obj, channel_parameter_range)
+      % Compute the required number of iterations to achieve the target
+      % error rate
+      
+      iter = zeros(size(channel_parameter_range));
+      
+      for i = 1:length(iter)
+        % do bisection search
+        iter_lb = 1;
+        iter_ub = obj.max_iterations; 
+
+        while(1)
+          iter_test = round(iter_lb + (iter_ub-iter_lb)/2);
+          
+          obj.scheme.set_max_iterations(iter_test);
+          obj.scheme.density_evolution(channel_parameter_range(i));
+          pe = obj.scheme.get_finalErrProb();
+          
+          if(pe > obj.target_error_rate)
+            iter_lb = iter_test;
+          else
+            iter_ub = iter_test;
+          end
+          
+          if(iter_ub - iter_lb <= 1)
+            iter(i) = iter_ub;
+            break;
+          end
+        end
+      end
+      
+    end
+  end
+end

DensE/DE_channel.m

@@ -0,0 +1,12 @@
+classdef DE_channel < handle
+  properties
+    channel_param_lb
+    channel_param_ub
+    higher_is_better 
+    default_precision 
+  end
+  
+  methods
+    %
+  end
+end

DensE/DE_channel_gpc_bec.m

@@ -0,0 +1,15 @@
+classdef DE_channel_gpc_bec < DE_channel
+  % high-rate binary erasure channel (BEC) for analyzing 
+  % deterministic generalized product codes
+  % parametrized by c, where p = c/n is the erasure-correcting capability
+  % and n is the component code length
+  
+  methods
+    function obj = DE_channel_gpc_bec()
+      obj.channel_param_lb = 1;
+      obj.channel_param_ub = 100; 
+      obj.higher_is_better = 0;  
+      obj.default_precision = 0.01;
+    end
+  end
+end

DensE/DE_det_gpc.m

@@ -0,0 +1,23 @@
+classdef DE_det_gpc < handle
+  properties
+    L % number of positions
+    eta % position connectivity matrix
+    gamma % relative number of component codes at the positions
+    tau % error-correcting capabilities 
+    
+    % derived parameters
+    Lp % number of bit positions
+    BitPosInd % 
+  end
+  
+  methods
+    function obj = DE_det_gpc()
+      %
+    end
+    
+    function set_derived_parameters(obj)
+      obj.Lp = sum(sum(tril(obj.eta)));
+      obj.BitPosInd = find(tril(obj.eta));
+    end 
+  end
+end

DensE/DE_half_product_code.m

@@ -0,0 +1,12 @@
+classdef DE_half_product_code < DE_det_gpc
+  methods
+    function obj = DE_half_product_code(t)
+      % t : erasure-correcting capability of the component codes
+      
+      obj.eta = 1;
+      obj.L = 1;
+      obj.gamma = 1;
+      obj.tau{1} = [t; 1];
+    end
+  end
+end

DensE/DE_product_code.m

@@ -0,0 +1,39 @@
+classdef DE_product_code < DE_det_gpc
+  methods
+    function obj = DE_product_code(t)
+      % t : erasure-correcting capability of the component codes;
+      %     can also be a length-2 vector to specify row/column codes
+      %     separately
+      
+      obj.eta = [0 1; 1 0];
+      obj.L = 2;
+      obj.gamma = [1 1];
+      
+      if(length(t) == 1)
+        obj.tau{1} = [t; 1];
+        obj.tau{2} = [t; 1];
+      elseif(length(t) == 2)
+        obj.tau{1} = [t(1); 1];
+        obj.tau{2} = [t(2); 1];
+      else
+        error('DE_product_code: length of input argument should be 1 or 2')
+      end
+    end
+    
+    function schedule = get_rowcolumn_schedule(obj, max_iterations)
+      % max_iter : maximum number of decoding iterations; 
+      %    1 iterations corresponds to 2 half-iterations (row+column
+      %    decoding)
+      
+      schedule = cell(2*max_iterations, 2); % first col: active
+      
+      for i = 1:max_iterations
+        schedule{2*i-1, 1} = 1;
+        schedule{2*i-1, 2} = 2;
+        schedule{2*i, 1} = 2;
+        schedule{2*i, 2} = 1;
+      end
+    end
+  end
+end
+

DensE/DE_scheme.m

@@ -0,0 +1,35 @@
+classdef DE_scheme < handle
+  properties 
+    channel
+    
+    % copied / initialized by DE_base
+    max_iterations    % maximum number of iterations
+    target_error_rate % target error probability
+    
+    % information about the last density evolution that was run
+    errProb_avg % vector of length maxIter+1 
+    errProb     % matrix (maxIter+1) rows, columns depends on VN types
+    nIter       % number of iterations until target error probability was reached
+  end
+  
+  methods 
+    function set_max_iterations(obj, p_max_iterations)
+      obj.max_iterations = p_max_iterations;
+      obj.errProb_avg = zeros(p_max_iterations+1, 1);
+    end
+    
+    function set_target_error_rate(obj, p_target_error_rate)
+      obj.target_error_rate = p_target_error_rate;
+    end
+    
+    function set_channel(obj, p_channel)
+      obj.channel = p_channel;
+    end
+    
+    function tmp = get_finalErrProb(obj)
+      % nIter = 0 -> uncoded 
+      % nIter = 1 -> after one iteration
+      tmp = mean(obj.errProb_avg(obj.nIter+1, :));
+    end
+  end
+end