From 2841e6c50982d559831a21cccddd74a69e2798f0 Mon Sep 17 00:00:00 2001
From: drowe67 <david@rowetel.com>
Date: Fri, 5 Apr 2024 05:06:39 +1030
Subject: [PATCH] non-table driven interleaver b

---
 octave/gp_interleaver.m | 29 ++++++++++++++++++--------
 src/gp_interleaver.c    | 45 +++++++++++++++--------------------------
 2 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/octave/gp_interleaver.m b/octave/gp_interleaver.m
index 1ee0ee38..c97af0f1 100644
--- a/octave/gp_interleaver.m
+++ 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)
-
-  p = primes(Nbits);
-  i = 1;
-  while(p(i) < Nbits/1.62)
-    i++;
-  end
-  b = p(i);
+  b = floor(Nbits/1.62);
+  b = next_prime(b);
   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);
diff --git a/src/gp_interleaver.c b/src/gp_interleaver.c
index 6710b0c3..70b8ad07 100644
--- a/src/gp_interleaver.c
+++ b/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[] = {
-    48,   31,  /* datac14: HRA_56_56, 40 data bits used          */
-    56,   37,  /* 700E:   HRA_56_56                              */
-    106,  67,  /* 2020B:  (112,56) partial protection            */
-    112,  71,  /* 700D:   HRA_112_112                            */
-    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   */
-    736,  457, /* datac4: H_1024_2048_4f, 448 data bits used     */
-    1024, 641, /* datac3: H_1024_2048_4f                         */
-    1290, 797, /* datac2: H2064_516_sparse                       */
-    4096, 2531 /* datac1: H_4096_8192_3d                         */
-};
+int is_prime(int x) {
+  for (int i = 2; i < x; i++) {
+    if ((x % i) == 0) return 0;
+  }
+  return 1;
+}
+
+int next_prime(int x) {
+  x++;
+  while (is_prime(x) == 0) x++;
+  return x;
+}
 
 int choose_interleaver_b(int Nbits) {
-  int i;
-  for (i = 0; i < sizeof(b_table) / sizeof(int); i += 2) {
-    if (b_table[i] == Nbits) {
-      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;
+  int b = floor(Nbits / 1.62);
+  b = next_prime(b);
+  return b;
 }
 
 void gp_interleave_comp(COMP interleaved_frame[], COMP frame[], int Nbits) {