@e04/ft8ts 0.0.9 → 0.0.10

package/src/util/constants.ts

@@ -3,9 +3,7 @@
 export const SAMPLE_RATE = 12_000;
 
 /** LDPC(174,91) code (shared by FT8 and FT4). */
-export const KK = 91;
 export const N_LDPC = 174;
-export const M_LDPC = N_LDPC - KK; // 83
 
 export const gHex = [
 	"8329ce11bf31eaf509f27fc",
@@ -93,8 +91,6 @@ export const gHex = [
 	"608cc857594bfbb55d69600",
 ];
 
-export const CRC_POLY = 0x2757;
-
 export const FTALPH = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-./?";
 
 export const A1 = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

package/src/util/decode174_91.ts

@@ -3,10 +3,13 @@
  * Port of bpdecode174_91.f90 and decode174_91.f90.
  */
 
-import { gHex, KK, M_LDPC, N_LDPC } from "./constants.js";
+import { gHex, N_LDPC } from "./constants.js";
 import { checkCRC14 } from "./crc.js";
 import { Mn, Nm, ncw, nrw } from "./ldpc_tables.js";
 
+const KK = 91;
+const M_LDPC = N_LDPC - KK; // 83
+
 export interface DecodeResult {
 	message91: number[];
 	cw: number[];
@@ -183,39 +186,48 @@ function osdDecode174_91(
 	const K = KK;
 
 	const gen = getGenerator();
+	const absllr = new Float64Array(N);
+	for (let i = 0; i < N; i++) absllr[i] = Math.abs(llr[i]!);
 
 	// Sort by reliability (descending)
-	const indices = Array.from({ length: N }, (_, i) => i);
-	indices.sort((a, b) => Math.abs(llr[b]!) - Math.abs(llr[a]!));
+	const indices = new Array<number>(N);
+	for (let i = 0; i < N; i++) indices[i] = i;
+	indices.sort((a, b) => absllr[b]! - absllr[a]!);
 
 	// Reorder generator matrix columns
 	const genmrb = new Uint8Array(K * N);
-	for (let i = 0; i < N; i++) {
-		for (let k = 0; k < K; k++) {
-			genmrb[k * N + i] = gen[k * N + indices[i]!]!;
+	for (let k = 0; k < K; k++) {
+		const row = k * N;
+		for (let i = 0; i < N; i++) {
+			genmrb[row + i] = gen[row + indices[i]!]!;
 		}
 	}
 
 	// Gaussian elimination to get systematic form on the K most-reliable bits
+	const maxPivotCol = Math.min(K + 20, N);
 	for (let id = 0; id < K; id++) {
 		let found = false;
-		for (let icol = id; icol < Math.min(K + 20, N); icol++) {
-			if (genmrb[id * N + icol] === 1) {
+		const idRow = id * N;
+		for (let icol = id; icol < maxPivotCol; icol++) {
+			if (genmrb[idRow + icol] === 1) {
 				if (icol !== id) {
 					// Swap columns
 					for (let k = 0; k < K; k++) {
-						const tmp = genmrb[k * N + id]!;
-						genmrb[k * N + id] = genmrb[k * N + icol]!;
-						genmrb[k * N + icol] = tmp;
+						const row = k * N;
+						const tmp = genmrb[row + id]!;
+						genmrb[row + id] = genmrb[row + icol]!;
+						genmrb[row + icol] = tmp;
 					}
 					const tmp = indices[id]!;
 					indices[id] = indices[icol]!;
 					indices[icol] = tmp;
 				}
 				for (let ii = 0; ii < K; ii++) {
-					if (ii !== id && genmrb[ii * N + id] === 1) {
+					if (ii === id) continue;
+					const iiRow = ii * N;
+					if (genmrb[iiRow + id] === 1) {
 						for (let c = 0; c < N; c++) {
-							genmrb[ii * N + c]! ^= genmrb[id * N + c]!;
+							genmrb[iiRow + c]! ^= genmrb[idRow + c]!;
 						}
 					}
 				}
@@ -229,87 +241,82 @@ function osdDecode174_91(
 	// Hard decisions on reordered received word
 	const hdec = new Int8Array(N);
 	for (let i = 0; i < N; i++) {
-		hdec[i] = llr[indices[i]!]! >= 0 ? 1 : 0;
+		const idx = indices[i]!;
+		hdec[i] = llr[idx]! >= 0 ? 1 : 0;
 	}
 	const absrx = new Float64Array(N);
 	for (let i = 0; i < N; i++) {
-		absrx[i] = Math.abs(llr[indices[i]!]!);
+		absrx[i] = absllr[indices[i]!]!;
 	}
 
-	// Transpose of reordered gen matrix
-	const g2 = new Uint8Array(N * K);
+	// Encode hard decision on MRB (c0): xor selected rows of genmrb.
+	const c0 = new Int8Array(N);
 	for (let i = 0; i < K; i++) {
+		if (hdec[i] !== 1) continue;
+		const row = i * N;
 		for (let j = 0; j < N; j++) {
-			g2[j * K + i] = genmrb[i * N + j]!;
-		}
-	}
-
-	function mrbencode(me: Int8Array): Int8Array {
-		const codeword = new Int8Array(N);
-		for (let i = 0; i < K; i++) {
-			if (me[i] === 1) {
-				for (let j = 0; j < N; j++) {
-					codeword[j]! ^= g2[j * K + i]!;
-				}
-			}
+			c0[j]! ^= genmrb[row + j]!;
 		}
-		return codeword;
 	}
 
-	const m0 = hdec.slice(0, K);
-	const c0 = mrbencode(m0);
-	const bestCw = new Int8Array(c0);
 	let dmin = 0;
 	for (let i = 0; i < N; i++) {
 		const x = c0[i]! ^ hdec[i]!;
 		dmin += x * absrx[i]!;
 	}
+	let bestFlip1 = -1;
+	let bestFlip2 = -1;
 
 	// Order-1: flip single bits in the info portion
 	for (let i1 = K - 1; i1 >= 0; i1--) {
 		if (apmask[indices[i1]!] === 1) continue;
-		const me = new Int8Array(m0);
-		me[i1]! ^= 1;
-		const ce = mrbencode(me);
-		let _nh = 0;
+		const row1 = i1 * N;
 		let dd = 0;
 		for (let j = 0; j < N; j++) {
-			const x = ce[j]! ^ hdec[j]!;
-			_nh += x;
+			const x = c0[j]! ^ genmrb[row1 + j]! ^ hdec[j]!;
 			dd += x * absrx[j]!;
 		}
 		if (dd < dmin) {
 			dmin = dd;
-			bestCw.set(ce);
+			bestFlip1 = i1;
+			bestFlip2 = -1;
 		}
 	}
 
 	// Order-2: flip pairs of least-reliable info bits (limited search)
 	if (norder >= 2) {
-		const ntry = Math.min(40, K);
-		for (let i1 = K - 1; i1 >= K - ntry; i1--) {
+		const ntry = Math.min(64, K);
+		const iMin = Math.max(0, K - ntry);
+		for (let i1 = K - 1; i1 >= iMin; i1--) {
 			if (apmask[indices[i1]!] === 1) continue;
-			for (let i2 = i1 - 1; i2 >= K - ntry; i2--) {
+			const row1 = i1 * N;
+			for (let i2 = i1 - 1; i2 >= iMin; i2--) {
 				if (apmask[indices[i2]!] === 1) continue;
-				const me = new Int8Array(m0);
-				me[i1]! ^= 1;
-				me[i2]! ^= 1;
-				const ce = mrbencode(me);
-				let _nh = 0;
+				const row2 = i2 * N;
 				let dd = 0;
 				for (let j = 0; j < N; j++) {
-					const x = ce[j]! ^ hdec[j]!;
-					_nh += x;
+					const x = c0[j]! ^ genmrb[row1 + j]! ^ genmrb[row2 + j]! ^ hdec[j]!;
 					dd += x * absrx[j]!;
 				}
 				if (dd < dmin) {
 					dmin = dd;
-					bestCw.set(ce);
+					bestFlip1 = i1;
+					bestFlip2 = i2;
 				}
 			}
 		}
 	}
 
+	const bestCw = new Int8Array(c0);
+	if (bestFlip1 >= 0) {
+		const row1 = bestFlip1 * N;
+		for (let j = 0; j < N; j++) bestCw[j]! ^= genmrb[row1 + j]!;
+		if (bestFlip2 >= 0) {
+			const row2 = bestFlip2 * N;
+			for (let j = 0; j < N; j++) bestCw[j]! ^= genmrb[row2 + j]!;
+		}
+	}
+
 	// Reorder codeword back to original order
 	const finalCw = new Int8Array(N);
 	for (let i = 0; i < N; i++) {
@@ -321,13 +328,12 @@ function osdDecode174_91(
 
 	// Compute dmin in original order
 	let dminOrig = 0;
-	const hdecOrig = new Int8Array(N);
-	for (let i = 0; i < N; i++) hdecOrig[i] = llr[i]! >= 0 ? 1 : 0;
 	let nhe = 0;
 	for (let i = 0; i < N; i++) {
-		const x = finalCw[i]! ^ hdecOrig[i]!;
+		const hard = llr[i]! >= 0 ? 1 : 0;
+		const x = finalCw[i]! ^ hard;
 		nhe += x;
-		dminOrig += x * Math.abs(llr[i]!);
+		dminOrig += x * absllr[i]!;
 	}
 
 	return {

package/src/util/fft.ts

@@ -3,6 +3,23 @@
  * Supports real-to-complex, complex-to-complex, and inverse transforms.
  */
 
+interface Radix2Plan {
+	bitReversed: Uint32Array;
+}
+
+interface BluesteinPlan {
+	m: number;
+	chirpRe: Float64Array;
+	chirpIm: Float64Array;
+	bFftRe: Float64Array;
+	bFftIm: Float64Array;
+	aRe: Float64Array;
+	aIm: Float64Array;
+}
+
+const RADIX2_PLAN_CACHE = new Map<number, Radix2Plan>();
+const BLUESTEIN_PLAN_CACHE = new Map<string, BluesteinPlan>();
+
 export function fftComplex(re: Float64Array, im: Float64Array, inverse: boolean): void {
 	const n = re.length;
 	if (n <= 1) return;
@@ -12,9 +29,11 @@ export function fftComplex(re: Float64Array, im: Float64Array, inverse: boolean)
 		return;
 	}
 
+	const { bitReversed } = getRadix2Plan(n);
+
 	// Bit-reversal permutation
-	let j = 0;
 	for (let i = 0; i < n; i++) {
+		const j = bitReversed[i]!;
 		if (j > i) {
 			let tmp = re[i]!;
 			re[i] = re[j]!;
@@ -23,12 +42,6 @@ export function fftComplex(re: Float64Array, im: Float64Array, inverse: boolean)
 			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;
@@ -59,56 +72,46 @@ export function fftComplex(re: Float64Array, im: Float64Array, inverse: boolean)
 	}
 
 	if (inverse) {
+		const scale = 1 / n;
 		for (let i = 0; i < n; i++) {
-			re[i]! /= n;
-			im[i]! /= n;
+			re[i] = re[i]! * scale;
+			im[i] = im[i]! * scale;
 		}
 	}
 }
 
 function bluestein(re: Float64Array, im: Float64Array, inverse: boolean): void {
 	const n = re.length;
-	const m = nextPow2(n * 2 - 1);
-	const s = inverse ? 1 : -1;
-
-	const aRe = new Float64Array(m);
-	const aIm = new Float64Array(m);
-	const bRe = new Float64Array(m);
-	const bIm = new Float64Array(m);
+	const { m, chirpRe, chirpIm, bFftRe, bFftIm, aRe, aIm } = getBluesteinPlan(n, inverse);
 
+	aRe.fill(0);
+	aIm.fill(0);
 	for (let i = 0; i < n; i++) {
-		const angle = (s * Math.PI * ((i * i) % (2 * n))) / n;
-		const cosA = Math.cos(angle);
-		const sinA = Math.sin(angle);
-
-		aRe[i] = re[i]! * cosA - im[i]! * sinA;
-		aIm[i] = re[i]! * sinA + im[i]! * cosA;
-
-		bRe[i] = cosA;
-		bIm[i] = -sinA;
-	}
-	for (let i = 1; i < n; i++) {
-		bRe[m - i] = bRe[i]!;
-		bIm[m - i] = bIm[i]!;
+		const cosA = chirpRe[i]!;
+		const sinA = chirpIm[i]!;
+		const inRe = re[i]!;
+		const inIm = im[i]!;
+		aRe[i] = inRe * cosA - inIm * sinA;
+		aIm[i] = inRe * sinA + inIm * cosA;
 	}
 
 	fftComplex(aRe, aIm, false);
-	fftComplex(bRe, bIm, false);
 
 	for (let i = 0; i < m; i++) {
-		const r = aRe[i]! * bRe[i]! - aIm[i]! * bIm[i]!;
-		const iIm = aRe[i]! * bIm[i]! + aIm[i]! * bRe[i]!;
-		aRe[i] = r;
-		aIm[i] = iIm;
+		const ar = aRe[i]!;
+		const ai = aIm[i]!;
+		const br = bFftRe[i]!;
+		const bi = bFftIm[i]!;
+		aRe[i] = ar * br - ai * bi;
+		aIm[i] = ar * bi + ai * br;
 	}
 
 	fftComplex(aRe, aIm, true);
 
 	const scale = inverse ? 1 / n : 1;
 	for (let i = 0; i < n; i++) {
-		const angle = (s * Math.PI * ((i * i) % (2 * n))) / n;
-		const cosA = Math.cos(angle);
-		const sinA = Math.sin(angle);
+		const cosA = chirpRe[i]!;
+		const sinA = chirpIm[i]!;
 
 		const r = aRe[i]! * cosA - aIm[i]! * sinA;
 		const iIm = aRe[i]! * sinA + aIm[i]! * cosA;
@@ -117,6 +120,63 @@ function bluestein(re: Float64Array, im: Float64Array, inverse: boolean): void {
 	}
 }
 
+function getRadix2Plan(n: number): Radix2Plan {
+	let plan = RADIX2_PLAN_CACHE.get(n);
+	if (plan) return plan;
+
+	const bits = 31 - Math.clz32(n);
+	const bitReversed = new Uint32Array(n);
+	for (let i = 1; i < n; i++) {
+		bitReversed[i] = (bitReversed[i >> 1]! >> 1) | ((i & 1) << (bits - 1));
+	}
+
+	plan = { bitReversed };
+	RADIX2_PLAN_CACHE.set(n, plan);
+	return plan;
+}
+
+function getBluesteinPlan(n: number, inverse: boolean): BluesteinPlan {
+	const key = `${n}:${inverse ? 1 : 0}`;
+	const cached = BLUESTEIN_PLAN_CACHE.get(key);
+	if (cached) return cached;
+
+	const m = nextPow2(n * 2 - 1);
+	const s = inverse ? 1 : -1;
+	const chirpRe = new Float64Array(n);
+	const chirpIm = new Float64Array(n);
+	for (let i = 0; i < n; i++) {
+		const angle = (s * Math.PI * ((i * i) % (2 * n))) / n;
+		chirpRe[i] = Math.cos(angle);
+		chirpIm[i] = Math.sin(angle);
+	}
+
+	const bFftRe = new Float64Array(m);
+	const bFftIm = new Float64Array(m);
+	for (let i = 0; i < n; i++) {
+		const cosA = chirpRe[i]!;
+		const sinA = chirpIm[i]!;
+		bFftRe[i] = cosA;
+		bFftIm[i] = -sinA;
+	}
+	for (let i = 1; i < n; i++) {
+		bFftRe[m - i] = bFftRe[i]!;
+		bFftIm[m - i] = bFftIm[i]!;
+	}
+	fftComplex(bFftRe, bFftIm, false);
+
+	const plan: BluesteinPlan = {
+		m,
+		chirpRe,
+		chirpIm,
+		bFftRe,
+		bFftIm,
+		aRe: new Float64Array(m),
+		aIm: new Float64Array(m),
+	};
+	BLUESTEIN_PLAN_CACHE.set(key, plan);
+	return plan;
+}
+
 /**
  * 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].

package/src/util/waveform.ts

@@ -3,10 +3,8 @@ const FT8_DEFAULT_SAMPLE_RATE = 12_000;
 const FT8_DEFAULT_SAMPLES_PER_SYMBOL = 1_920;
 const FT8_DEFAULT_BT = 2.0;
 
-import { NSPS as FT4_NSPS } from "../ft4/constants.js";
-
 const FT4_DEFAULT_SAMPLE_RATE = 12_000;
-const FT4_DEFAULT_SAMPLES_PER_SYMBOL = FT4_NSPS;
+const FT4_DEFAULT_SAMPLES_PER_SYMBOL = 576;
 const FT4_DEFAULT_BT = 1.0;
 const MODULATION_INDEX = 1.0;
 
@@ -15,6 +13,7 @@ export interface WaveformOptions {
 	samplesPerSymbol?: number;
 	bt?: number;
 	baseFrequency?: number;
+	initialPhase?: number;
 }
 
 interface WaveformDefaults {
@@ -68,6 +67,7 @@ function generateGfskWaveform(
 	const nsps = options.samplesPerSymbol ?? defaults.samplesPerSymbol;
 	const bt = options.bt ?? defaults.bt;
 	const f0 = options.baseFrequency ?? 0;
+	const initialPhase = options.initialPhase ?? 0;
 
 	assertPositiveFinite(sampleRate, "sampleRate");
 	assertPositiveFinite(nsps, "samplesPerSymbol");
@@ -75,6 +75,9 @@ function generateGfskWaveform(
 	if (!Number.isFinite(f0)) {
 		throw new Error("baseFrequency must be finite");
 	}
+	if (!Number.isFinite(initialPhase)) {
+		throw new Error("initialPhase must be finite");
+	}
 	if (!Number.isInteger(nsps)) {
 		throw new Error("samplesPerSymbol must be an integer");
 	}
@@ -111,7 +114,8 @@ function generateGfskWaveform(
 	}
 
 	const wave = new Float32Array(nwave);
-	let phi = 0;
+	let phi = initialPhase % TWO_PI;
+	if (phi < 0) phi += TWO_PI;
 	const phaseStart = shape.includeRampSymbols ? 0 : nsps;
 	for (let k = 0; k < nwave; k++) {
 		const j = phaseStart + k;