non-table driven interleaver b

octave/gp_interleaver.m

@@ -7,18 +7,31 @@
 
 1;
 
+% return 1 if prime
+function ret = is_prime(x)
+  for i=2:x-1
+    if mod(x,i) == 0
+      ret = 0;
+      return;
+    end
+  end
+  ret = 1;
+end
+
+function x = next_prime(x)
+  x++;
+  while is_prime(x) == 0
+    x++;
+  end
+end
+
 % Choose b for Golden Prime Interleaver.  b is chosen to be the
 % closest integer, which is relatively prime to N, to the Golden
 % section of N.
 
 function b = choose_interleaver_b(Nbits)
-
+  b = floor(Nbits/1.62);
-  p = primes(Nbits);
+  b = next_prime(b);
-  i = 1;
-  while(p(i) < Nbits/1.62)
-    i++;
-  end
-  b = p(i);
   assert(gcd(b,Nbits) == 1, "b and Nbits must be co-prime");
 end
 
@@ -36,7 +49,7 @@ endfunction
 
 function frame = gp_deinterleave(interleaved_frame)
   Nbits = length(interleaved_frame);
-  b = choose_interleaver_b(Nbits);
+  b = choose_interleaver_b(Nbits); 
   frame = zeros(1,Nbits);
   for i=1:Nbits
     j = mod((b*(i-1)), Nbits);

src/gp_interleaver.c

@@ -31,45 +31,32 @@
 #include "gp_interleaver.h"
 
 #include <assert.h>
+#include <math.h>
 #include <stdio.h>
 
 /*
   Choose b for Golden Prime Interleaver.  b is chosen to be the
   closest integer, which is relatively prime to N, to the Golden
   section of N.
-
-  Implemented with a LUT in C for convenience, Octave version
-  has a more complete implementation.  If you find you need some more
-  numbers head back to the Octave choose_interleaver_b() function.
 */
 
-static const int b_table[] = {
+int is_prime(int x) {
-    48,   31,  /* datac14: HRA_56_56, 40 data bits used          */
+  for (int i = 2; i < x; i++) {
-    56,   37,  /* 700E:   HRA_56_56                              */
+    if ((x % i) == 0) return 0;
-    106,  67,  /* 2020B:  (112,56) partial protection            */
+  }
-    112,  71,  /* 700D:   HRA_112_112                            */
+  return 1;
-    128,  83,  /* datac0: H_128_256_5                            */
+}
-    192,  127, /* datac13: H_256_512_4, 128 data bits used       */
+
-    210,  131, /* 2020:   HRAb_396_504 with 312 data bits used   */
+int next_prime(int x) {
-    736,  457, /* datac4: H_1024_2048_4f, 448 data bits used     */
+  x++;
-    1024, 641, /* datac3: H_1024_2048_4f                         */
+  while (is_prime(x) == 0) x++;
-    1290, 797, /* datac2: H2064_516_sparse                       */
+  return x;
-    4096, 2531 /* datac1: H_4096_8192_3d                         */
+}
-};
 
 int choose_interleaver_b(int Nbits) {
-  int i;
+  int b = floor(Nbits / 1.62);
-  for (i = 0; i < sizeof(b_table) / sizeof(int); i += 2) {
+  b = next_prime(b);
-    if (b_table[i] == Nbits) {
+  return b;
-      return b_table[i + 1];
-    }
-  }
-
-  /* if we get to here it means a Nbits we don't have in our table so choke */
-
-  fprintf(stderr, "gp_interleaver: Nbits: %d, b not found!\n", Nbits);
-  assert(0);
-  return -1;
 }
 
 void gp_interleave_comp(COMP interleaved_frame[], COMP frame[], int Nbits) {