Struct RobustDesign 

pub struct RobustDesign {
    pub k: usize,
    pub k_o: usize,
    pub omega_d: f64,
}

The robust estimator of Li, Cimini & Sollenberger (1998) for $K$ tones (see the module): the design delay spread spans $K_{o}$ taps of the DFT grid, the design Doppler is $\omega_{d} = 2\pi f_{\max} T_{f}$.

Examples

use comnum_waveform::ofdm::wiener::RobustDesign;
// 120 tones of 160 us, blocks of 200 us, 20 us and 40 Hz: the taps 0 to 15 (their Fig. 4)
let d = RobustDesign::new(120, 20e-6 / 160e-6, 40.0 * 200e-6)?;
assert_eq!(d.k_o, 16);
let mse_db = 10.0 * d.mse(0.1).log10();                 // SNR 10 dB
assert!((mse_db + 27.7).abs() < 0.1);
let (c, mse50) = d.fir(50, 0.1)?;
assert_eq!(c.len(), 50);
assert!(mse50 > d.mse(0.1));                           // a finite filter does worse

Fields

k: usize

Tones $K$.

k_o: usize

Taps of the design delay spread on the DFT grid, $K_{o}$.

omega_d: f64

The design Doppler $\omega_{d} = 2\pi f_{\max} T_{f}$ (rad per block).

Implementations

impl RobustDesign

pub fn new(k: usize, tmax_ts: f64, fmax_tf: f64) -> Result<RobustDesign>

The design of k tones for a delay spread tmax_ts (over the useful duration $T_{s}$: the $K_{o} = \lfloor K t_{\max}/T_{s} \rfloor + 1$ taps of the grid from 0 to $t_{\max}$, at most $K$) and a maximum Doppler fmax_tf (over the block rate, $f_{\max} T_{f}$).

Errors

comnum_core::Error::Config without tones, for a negative spread or a Doppler outside $[0, 1/2]$.

pub fn mse(&self, rho: f64) -> f64

The MSE of the infinite-length estimator at the noise to signal ratio rho, eq. (57) (normalised to the power of the channel).

pub fn fir(&self, taps: usize, rho: f64) -> Result<(Vec<f64>, f64)>

The coefficients $c_{0}, \dots, c_{L-1}$ of the $L$-tap temporal filter and its MSE $K_{o} c_{0} \rho / K$ at the noise to signal ratio rho (eqs. (69)–(74)).

Errors

comnum_core::Error::Config for no tap, comnum_core::Error::Numerical for a singular system.

Trait Implementations

impl Clone for RobustDesign

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RobustDesign

impl Debug for RobustDesign

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for RobustDesign

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RobustDesign