grpdelay

Functions

int main(int argc, char *argv[])

grpdelay [ option ] [ infile ]

  • -l int

    • FFT length \((2 \le L)\)

  • -m int

    • order of numerator coefficients \((0 \le M < L)\)

  • -n int

    • order of denominator coefficients \((0 \le N < L)\)

  • -z str

    • name of file containing numerator coefficients

  • -p str

    • name of file containing denominator coefficients

  • -a double

    • alpha

  • -g double

    • gamma

  • infile str

    • double-type real sequence

  • stdout

    • double-type group delay

The below example calculates group delay from 10-th order filter coefficients:

grpdelay -z data.z -m 10 -p data.p -n 10 -l 16 > data.gd

If the filter coefficients are stable, the below example gives the same result:

impulse -l 16 | dfs -z data.z -p data.p | grpdelay -l 16 > data.gd

Parameters

  • argc – [in] Number of arguments.

  • argv – [in] Argument vector.

Returns

0 on success, 1 on failure.

See also

phase

class sptk::FilterCoefficientsToGroupDelay

Transform filter coefficients to group delay.

The input is the \(M\)-th order numerator coefficients and the \(N\)-th order denominator coefficients:

\[\begin{split} \begin{array}{cccc} b(0), & b(1), & \ldots, & b(M), \\ K, & a(1), & \ldots, & a(N), \end{array} \end{split}\]
and the output is the \((L/2+1)\)-length group delay:
\[ \begin{array}{cccc} D(0), & D(1), & \ldots, & D(L/2), \end{array} \]
where \(L\) is the FFT length.

The general form of transfer function is given by

\[\begin{split}\begin{eqnarray} H(z) &=& \frac{\sum_{m=0}^M b(m) z^{-m}}{\sum_{n=0}^N a(n) z^{-n}} \\ &=& \frac{B(z)}{A(z)}. \end{eqnarray}\end{split}\]
The group delay is then represented as
\[ D(z) = \frac{C_R(z) C'_R(z) + C_I(z) C'_I(z)}{C_R^2(z) + C_I^2(z)} \]
where \(C(z)=B(z) \, z^{-N} A(z^{-1})\) and \(C'(z)\) is its ramped version. The subscripts \(R\) and \(I\) denote the real and imaginary parts.

The modified group delay is defined as

\[ D_{\alpha,\gamma}(z) = \mathrm{sgn}(D(z)) \left| \frac{C_R(z) C'_R(z) + C_I(z) C'_I(z)} {\left\{ C_R^2(z) + C_I^2(z) \right\}^\gamma} \right|^\alpha \]
where \(\alpha\) and \(\gamma\) are tunable positive parameters.

[1] J. O. Smith, “Numerical Computation of Group Delay,” in Introduction to digital filters with audio applications, https://ccrma.stanford.edu/~jos/fp/Numerical_Computation_Group_Delay.html

[2] H. A. Murthy and V. R. Gadde, “The modified group delay function and its application to phoneme recognition,” Proc. of ICASSP 2003.

Public Functions

FilterCoefficientsToGroupDelay(int num_numerator_order, int num_denominator_order, int fft_length, double alpha = 1.0, double gamma = 1.0)
Parameters

  • num_numerator_order – [in] Order of numerator coefficients, \(M\).

  • num_denominator_order – [in] Order of denominator coefficients, \(N\).

  • fft_length – [in] Number of FFT bins, \(L\).

  • alpha – [in] A parameter of modified group delay, \(\alpha\).

  • gamma – [in] A parameter of modified group delay, \(\gamma\).

inline int GetNumNumeratorOrder() const
Returns

Order of numerator coefficients.

inline int GetNumDenominatorOrder() const
Returns

Order of denominator coefficients.

inline int GetFftLength() const
Returns

FFT length.

inline double GetAlpha() const
Returns

Alpha.

inline double GetGamma() const
Returns

Gamma.

inline bool IsValid() const
Returns

True if this object is valid.

bool Run(const std::vector<double> &numerator_coefficients, const std::vector<double> &denominator_coefficients, std::vector<double> *group_delay, FilterCoefficientsToGroupDelay::Buffer *buffer) const
Parameters

  • numerator_coefficients – [in] \(M\)-th order coefficients.

  • denominator_coefficients – [in] \(N\)-th order coefficients.

  • group_delay – [out] \((L/2+1)\)-length group delay.

  • buffer – [out] Buffer.

Returns

True on success, false on failure.

class Buffer

Buffer for FilterCoefficientsToGroupDelay class.