Type System

doppler uses C99 standard types throughout — no custom struct wrappers for complex samples in the DSP path. Every public API takes or returns types from <stdint.h> or <complex.h>, exactly as the C99 standard defines them. The dp_*_t family in dp/stream.h provides named interleaved-struct aliases for use in streaming and FFI contexts.

Integer types — <stdint.h>

Complex integers (e.g., int16_t I/Q pairs) are always passed as interleaved pairs: input[2*k] = I sample, input[2*k+1] = Q sample. Functions that accept them document the pointer as const int16_t *samples with a num_samples argument counting complex samples (so the array length is 2 × num_samples).

Complex floating-point types — <complex.h>

These are the standard C99 complex types — not structs, not typedefs. Call sites use the C99 spelling directly:

#include <complex.h>
#include <dp/fir.h>

float _Complex in[1024];
float _Complex out[1024];

dp_fir_t *f = dp_fir_create(taps, 63);
dp_fir_execute_cf32(f, in, out, 1024);

Creating complex constants: CMPLXF / CMPLX

float _Complex tone = CMPLXF(0.5f, 0.866f);  /* e^{iπ/3} */
double _Complex dc  = CMPLX(1.0, 0.0);

Named IQ types — dp_*_t (streaming & FFI)

Defined in dp/stream.h, available via doppler.h. All are #[repr(C)] interleaved structs with i (in-phase) and q (quadrature) fields matching the on-wire format and NumPy complex layout.

¹ Rust FFI uses num_complex::Complex64 directly for dp_cf64_t because it has the same [f64; 2] memory layout — no wrapper needed.

The DSP path (NCO, FIR, resamplers, DDC) uses the C99 float _Complex / double _Complex types, not dp_cf32_t / dp_cf64_t. They are layout-compatible but distinct at the source level.

dp_sample_type_t — runtime type tag

The streaming API identifies the wire type of a message at runtime:

typedef enum {
    DP_CI32  = 0,   /* int32_t  I/Q — 8 bytes/sample  */
    DP_CF64  = 1,   /* double _Complex — 16 bytes/sample */
    DP_CF128 = 2,   /* long double _Complex — 32 bytes/sample */
    DP_CI8   = 3,   /* int8_t   I/Q — 2 bytes/sample  */
    DP_CI16  = 4,   /* int16_t  I/Q — 4 bytes/sample  */
    DP_CF32  = 5,   /* float _Complex — 8 bytes/sample */
} dp_sample_type_t;

Set at socket creation (dp_pub_create, dp_push_create) and embedded in every dp_header_t frame. Python exposes these as doppler.CI32, doppler.CF64, doppler.CF128.

Ring buffer element types

The ring buffer API (dp/buffer.h) is element-typed, not sample-typed. Each buffer holds a flat array of scalars; how they are interpreted as complex samples is the caller's responsibility.

Note: buffer types omit the _t suffix — dp_f32 not dp_f32_t. This is a known naming inconsistency with the rest of the API.

To stream complex IQ through an F32Buffer, write interleaved floats:

from doppler.buffer import F32Buffer
import numpy as np

buf = F32Buffer(2048)   # 2048 floats → 1024 complex64 samples

iq = np.ones(1024, dtype=np.complex64)
buf.write(iq.view(np.float32))   # reinterpret as float32 pairs

Which type goes where

Precision design rationale

Three levels of precision are used deliberately:

float _Complex (CF32) — default signal path. Matches native SDR hardware output (RTL-SDR, HackRF, LimeSDR, PlutoSDR, USRP). SIMD-friendly: AVX-512 processes eight CF32 pairs per instruction. Used by NCO, FIR, polyphase resampler, halfband decimator, DDC.

double _Complex (CF64) — spectral and accumulation paths. The FFT backend (FFTW or pocketfft) works in double _Complex throughout. dp_c16_mul (SIMD complex multiply) uses double _Complex to match. Running sums over many taps accumulate in double to prevent rounding error before rounding back to float.

int8_t / int16_t / int32_t — input-only integer formats. Real SDR hardware delivers quantized samples. FIR filters accept integer inputs and up-cast to float _Complex via SIMD as part of execution.

Rule: compute in the cheapest type that keeps the math clean.

Python equivalents

Rust equivalents

See also

• just-makeit — State Variable Types — maps these C types to --state name:type scaffold tokens and generated NumPy stubs.