@e04/ft8ts 0.0.1

package/src/util/fft.ts

@@ -0,0 +1,108 @@
+/**
+ * Radix-2 Cooley-Tukey FFT for FT8 decoding.
+ * Supports real-to-complex, complex-to-complex, and inverse transforms.
+ */
+
+export function fftComplex(re: Float64Array, im: Float64Array, inverse: boolean): void {
+	const n = re.length;
+	if (n <= 1) return;
+
+	// Bit-reversal permutation
+	let j = 0;
+	for (let i = 0; i < n; i++) {
+		if (j > i) {
+			let tmp = re[i]!;
+			re[i] = re[j]!;
+			re[j] = tmp;
+			tmp = im[i]!;
+			im[i] = im[j]!;
+			im[j] = tmp;
+		}
+		let m = n >> 1;
+		while (m >= 1 && j >= m) {
+			j -= m;
+			m >>= 1;
+		}
+		j += m;
+	}
+
+	const sign = inverse ? 1 : -1;
+
+	for (let size = 2; size <= n; size <<= 1) {
+		const halfsize = size >> 1;
+		const step = (sign * Math.PI) / halfsize;
+		const wRe = Math.cos(step);
+		const wIm = Math.sin(step);
+
+		for (let i = 0; i < n; i += size) {
+			let curRe = 1;
+			let curIm = 0;
+			for (let k = 0; k < halfsize; k++) {
+				const evenIdx = i + k;
+				const oddIdx = i + k + halfsize;
+				const tRe = curRe * re[oddIdx]! - curIm * im[oddIdx]!;
+				const tIm = curRe * im[oddIdx]! + curIm * re[oddIdx]!;
+				re[oddIdx] = re[evenIdx]! - tRe;
+				im[oddIdx] = im[evenIdx]! - tIm;
+				re[evenIdx] = re[evenIdx]! + tRe;
+				im[evenIdx] = im[evenIdx]! + tIm;
+				const newCurRe = curRe * wRe - curIm * wIm;
+				curIm = curRe * wIm + curIm * wRe;
+				curRe = newCurRe;
+			}
+		}
+	}
+
+	if (inverse) {
+		for (let i = 0; i < n; i++) {
+			re[i]! /= n;
+			im[i]! /= n;
+		}
+	}
+}
+
+/**
+ * Real-to-complex FFT. Input: n real values. Output: n/2+1 complex values
+ * stored in re[0..n/2] and im[0..n/2].
+ */
+export function fftReal(input: Float64Array, outRe: Float64Array, outIm: Float64Array): void {
+	const n = input.length;
+	const half = n >> 1;
+
+	const re = new Float64Array(half);
+	const im = new Float64Array(half);
+	for (let i = 0; i < half; i++) {
+		re[i] = input[i * 2]!;
+		im[i] = input[i * 2 + 1]!;
+	}
+	fftComplex(re, im, false);
+
+	outRe[0] = re[0]! + im[0]!;
+	outIm[0] = 0;
+	outRe[half] = re[0]! - im[0]!;
+	outIm[half] = 0;
+
+	for (let k = 1; k < half; k++) {
+		const nk = half - k;
+		const eRe = 0.5 * (re[k]! + re[nk]!);
+		const eIm = 0.5 * (im[k]! - im[nk]!);
+		const angle = (-2 * Math.PI * k) / n;
+		const twRe = Math.cos(angle);
+		const twIm = Math.sin(angle);
+		const oRe = 0.5 * (im[k]! + im[nk]!);
+		const oIm = -0.5 * (re[k]! - re[nk]!);
+		const toRe = twRe * oRe - twIm * oIm;
+		const toIm = twRe * oIm + twIm * oRe;
+		outRe[k] = eRe + toRe;
+		outIm[k] = eIm + toIm;
+		outRe[n - k] = eRe - toRe;
+		outIm[n - k] = -(eIm - toIm);
+	}
+}
+
+/** Next power of 2 >= n */
+export function nextPow2(n: number): number {
+	let v = 1;
+	while (v < n) v <<= 1;
+	return v;
+}

package/src/util/ldpc_tables.ts

@@ -0,0 +1,91 @@
+/**
+ * LDPC (174,91) parity check matrix data from ldpc_174_91_c_parity.f90
+ *
+ * Mn[j] = list of 3 check-node indices (1-based) for bit j  (j=0..173)
+ * Nm[i] = list of variable-node indices (1-based) for check i (i=0..82), padded with 0
+ * nrw[i] = row weight for check i
+ * ncw = 3  (column weight – every bit participates in exactly 3 checks)
+ */
+
+// Mn: 174 rows, each with 3 check-node indices (1-based, from Fortran)
+const MnFlat = [
+	16, 45, 73, 25, 51, 62, 33, 58, 78, 1, 44, 45, 2, 7, 61, 3, 6, 54, 4, 35, 48, 5, 13, 21, 8, 56,
+	79, 9, 64, 69, 10, 19, 66, 11, 36, 60, 12, 37, 58, 14, 32, 43, 15, 63, 80, 17, 28, 77, 18, 74, 83,
+	22, 53, 81, 23, 30, 34, 24, 31, 40, 26, 41, 76, 27, 57, 70, 29, 49, 65, 3, 38, 78, 5, 39, 82, 46,
+	50, 73, 51, 52, 74, 55, 71, 72, 44, 67, 72, 43, 68, 78, 1, 32, 59, 2, 6, 71, 4, 16, 54, 7, 65, 67,
+	8, 30, 42, 9, 22, 31, 10, 18, 76, 11, 23, 82, 12, 28, 61, 13, 52, 79, 14, 50, 51, 15, 81, 83, 17,
+	29, 60, 19, 33, 64, 20, 26, 73, 21, 34, 40, 24, 27, 77, 25, 55, 58, 35, 53, 66, 36, 48, 68, 37,
+	46, 75, 38, 45, 47, 39, 57, 69, 41, 56, 62, 20, 49, 53, 46, 52, 63, 45, 70, 75, 27, 35, 80, 1, 15,
+	30, 2, 68, 80, 3, 36, 51, 4, 28, 51, 5, 31, 56, 6, 20, 37, 7, 40, 82, 8, 60, 69, 9, 10, 49, 11,
+	44, 57, 12, 39, 59, 13, 24, 55, 14, 21, 65, 16, 71, 78, 17, 30, 76, 18, 25, 80, 19, 61, 83, 22,
+	38, 77, 23, 41, 50, 7, 26, 58, 29, 32, 81, 33, 40, 73, 18, 34, 48, 13, 42, 64, 5, 26, 43, 47, 69,
+	72, 54, 55, 70, 45, 62, 68, 10, 63, 67, 14, 66, 72, 22, 60, 74, 35, 39, 79, 1, 46, 64, 1, 24, 66,
+	2, 5, 70, 3, 31, 65, 4, 49, 58, 1, 4, 5, 6, 60, 67, 7, 32, 75, 8, 48, 82, 9, 35, 41, 10, 39, 62,
+	11, 14, 61, 12, 71, 74, 13, 23, 78, 11, 35, 55, 15, 16, 79, 7, 9, 16, 17, 54, 63, 18, 50, 57, 19,
+	30, 47, 20, 64, 80, 21, 28, 69, 22, 25, 43, 13, 22, 37, 2, 47, 51, 23, 54, 74, 26, 34, 72, 27, 36,
+	37, 21, 36, 63, 29, 40, 44, 19, 26, 57, 3, 46, 82, 14, 15, 58, 33, 52, 53, 30, 43, 52, 6, 9, 52,
+	27, 33, 65, 25, 69, 73, 38, 55, 83, 20, 39, 77, 18, 29, 56, 32, 48, 71, 42, 51, 59, 28, 44, 79,
+	34, 60, 62, 31, 45, 61, 46, 68, 77, 6, 24, 76, 8, 10, 78, 40, 41, 70, 17, 50, 53, 42, 66, 68, 4,
+	22, 72, 36, 64, 81, 13, 29, 47, 2, 8, 81, 56, 67, 73, 5, 38, 50, 12, 38, 64, 59, 72, 80, 3, 26,
+	79, 45, 76, 81, 1, 65, 74, 7, 18, 77, 11, 56, 59, 14, 39, 54, 16, 37, 66, 10, 28, 55, 15, 60, 70,
+	17, 25, 82, 20, 30, 31, 12, 67, 68, 23, 75, 80, 27, 32, 62, 24, 69, 75, 19, 21, 71, 34, 53, 61,
+	35, 46, 47, 33, 59, 76, 40, 43, 83, 41, 42, 63, 49, 75, 83, 20, 44, 48, 42, 49, 57,
+];
+
+// Nm: 83 rows, each with up to 7 variable-node indices (1-based, 0-padded)
+const NmFlat = [
+	4, 31, 59, 91, 92, 96, 153, 5, 32, 60, 93, 115, 146, 0, 6, 24, 61, 94, 122, 151, 0, 7, 33, 62, 95,
+	96, 143, 0, 8, 25, 63, 83, 93, 96, 148, 6, 32, 64, 97, 126, 138, 0, 5, 34, 65, 78, 98, 107, 154,
+	9, 35, 66, 99, 139, 146, 0, 10, 36, 67, 100, 107, 126, 0, 11, 37, 67, 87, 101, 139, 158, 12, 38,
+	68, 102, 105, 155, 0, 13, 39, 69, 103, 149, 162, 0, 8, 40, 70, 82, 104, 114, 145, 14, 41, 71, 88,
+	102, 123, 156, 15, 42, 59, 106, 123, 159, 0, 1, 33, 72, 106, 107, 157, 0, 16, 43, 73, 108, 141,
+	160, 0, 17, 37, 74, 81, 109, 131, 154, 11, 44, 75, 110, 121, 166, 0, 45, 55, 64, 111, 130, 161,
+	173, 8, 46, 71, 112, 119, 166, 0, 18, 36, 76, 89, 113, 114, 143, 19, 38, 77, 104, 116, 163, 0, 20,
+	47, 70, 92, 138, 165, 0, 2, 48, 74, 113, 128, 160, 0, 21, 45, 78, 83, 117, 121, 151, 22, 47, 58,
+	118, 127, 164, 0, 16, 39, 62, 112, 134, 158, 0, 23, 43, 79, 120, 131, 145, 0, 19, 35, 59, 73, 110,
+	125, 161, 20, 36, 63, 94, 136, 161, 0, 14, 31, 79, 98, 132, 164, 0, 3, 44, 80, 124, 127, 169, 0,
+	19, 46, 81, 117, 135, 167, 0, 7, 49, 58, 90, 100, 105, 168, 12, 50, 61, 118, 119, 144, 0, 13, 51,
+	64, 114, 118, 157, 0, 24, 52, 76, 129, 148, 149, 0, 25, 53, 69, 90, 101, 130, 156, 20, 46, 65, 80,
+	120, 140, 170, 21, 54, 77, 100, 140, 171, 0, 35, 82, 133, 142, 171, 174, 0, 14, 30, 83, 113, 125,
+	170, 0, 4, 29, 68, 120, 134, 173, 0, 1, 4, 52, 57, 86, 136, 152, 26, 51, 56, 91, 122, 137, 168,
+	52, 84, 110, 115, 145, 168, 0, 7, 50, 81, 99, 132, 173, 0, 23, 55, 67, 95, 172, 174, 0, 26, 41,
+	77, 109, 141, 148, 0, 2, 27, 41, 61, 62, 115, 133, 27, 40, 56, 124, 125, 126, 0, 18, 49, 55, 124,
+	141, 167, 0, 6, 33, 85, 108, 116, 156, 0, 28, 48, 70, 85, 105, 129, 158, 9, 54, 63, 131, 147, 155,
+	0, 22, 53, 68, 109, 121, 174, 0, 3, 13, 48, 78, 95, 123, 0, 31, 69, 133, 150, 155, 169, 0, 12, 43,
+	66, 89, 97, 135, 159, 5, 39, 75, 102, 136, 167, 0, 2, 54, 86, 101, 135, 164, 0, 15, 56, 87, 108,
+	119, 171, 0, 10, 44, 82, 91, 111, 144, 149, 23, 34, 71, 94, 127, 153, 0, 11, 49, 88, 92, 142, 157,
+	0, 29, 34, 87, 97, 147, 162, 0, 30, 50, 60, 86, 137, 142, 162, 10, 53, 66, 84, 112, 128, 165, 22,
+	57, 85, 93, 140, 159, 0, 28, 32, 72, 103, 132, 166, 0, 28, 29, 84, 88, 117, 143, 150, 1, 26, 45,
+	80, 128, 147, 0, 17, 27, 89, 103, 116, 153, 0, 51, 57, 98, 163, 165, 172, 0, 21, 37, 73, 138, 152,
+	169, 0, 16, 47, 76, 130, 137, 154, 0, 3, 24, 30, 72, 104, 139, 0, 9, 40, 90, 106, 134, 151, 0, 15,
+	58, 60, 74, 111, 150, 163, 18, 42, 79, 144, 146, 152, 0, 25, 38, 65, 99, 122, 160, 0, 17, 42, 75,
+	129, 170, 172, 0,
+];
+
+const nrwData = [
+	7, 6, 6, 6, 7, 6, 7, 6, 6, 7, 6, 6, 7, 7, 6, 6, 6, 7, 6, 7, 6, 7, 6, 6, 6, 7, 6, 6, 6, 7, 6, 6, 6,
+	6, 7, 6, 6, 6, 7, 7, 6, 6, 6, 6, 7, 7, 6, 6, 6, 6, 7, 6, 6, 6, 7, 6, 6, 6, 6, 7, 6, 6, 6, 7, 6, 6,
+	6, 7, 7, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6,
+];
+
+export const ncw = 3;
+
+/** Mn[j] = check indices (0-based) for bit j (0..173). Each entry has exactly 3 elements. */
+export const Mn: number[][] = [];
+for (let j = 0; j < 174; j++) {
+	Mn.push([MnFlat[j * 3]! - 1, MnFlat[j * 3 + 1]! - 1, MnFlat[j * 3 + 2]! - 1]);
+}
+
+/** Nm[i] = bit indices (0-based) for check i (0..82). Variable length (nrw[i] elements). */
+export const Nm: number[][] = [];
+/** nrw[i] = row weight for check i */
+export const nrw: number[] = nrwData.slice();
+
+for (let i = 0; i < 83; i++) {
+	const row: number[] = [];
+	for (let k = 0; k < 7; k++) {
+		const v = NmFlat[i * 7 + k]!;
+		if (v !== 0) row.push(v - 1);
+	}
+	Nm.push(row);
+}