phase

Functions

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

phase [ option ] [ infile ]

-l int
- FFT length $(2 \leq L)$
-m int
- order of numerator coefficients $(0 \leq M < L)$
-n int
- order of denominator coefficients $(0 \leq N < L)$
-z str
- name of file containing numerator coefficients
-p str
- name of file containing denominator coefficients
-u bool
- perform phase unwrapping
infile str
- double-type real sequence
stdout
- double-type phase

The below example calculates phase spectrum from 10-th order filter coefficients:

phase -z data.z -m 10 -p data.p -n 10 -l 16 > data.ph

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

impulse -l 16 | dfs -z data.z -p data.p | phase -l 16 > data.ph

Parameters

argc – [in] Number of arguments.
argv – [in] Argument vector.

Returns

0 on success, 1 on failure.

See also

grpdelay fft fftr

class sptk::FilterCoefficientsToPhaseSpectrum

Transform filter coefficients to phase spectrum.

The input is the $M$ -th order numerator coefficients and the $N$ -th order denominator coefficients:

\begin{array}{r} \begin{array}{cccc} b (0), & b (1), & \dots, & b (M), \\ K, & a (1), & \dots, & a (N), \end{array} \end{array}

and the output is the

(L / 2 + 1)

-length phase spectrum:

\begin{array}{cccc} ∠ H (0), & ∠ H (1), & \dots, & ∠ H (L / 2), \end{array}

where

L

is the FFT length.

The general form of transfer function is given by

\begin{array}{r} \begin{array}{rcl} 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{array} \end{array}

where

a (0) = 1

. It can be rewritten as

\begin{array}{r} \begin{array}{rcl} H (z) & = & \frac{B_{R} (z) + i B_{I} (z)}{A_{R} (z) + i A_{I} (z)} \\ = & \frac{B_{R} (z) + i B_{I} (z)}{A_{R} (z) + i A_{I} (z)} \cdot \frac{A_{R} (z) - i A_{I} (z)}{A_{R} (z) - i A_{I} (z)} \\ = & \frac{B_{R} (z) A_{R} (z) + B_{I} (z) A_{I} (z)}{A_{R}^{2} (z) + A_{I}^{2} (z)} + i \frac{B_{I} (z) A_{R} (z) - B_{R} (z) A_{I} (z)}{A_{R}^{2} (z) + A_{I}^{2} (z)} . \end{array} \end{array}

where the subscripts

R

and

I

denote the real and imaginary parts. Thus

\begin{array}{r} \begin{array}{rcl} ∠ H (z) & = & \tan^{- 1} (\frac{H_{I} (z)}{H_{R} (z)}) \\ = & \tan^{- 1} (\frac{B_{I} (z) A_{R} (z) - B_{R} (z) A_{I} (z)}{B_{R} (z) A_{R} (z) + B_{I} (z) A_{I} (z)}) . \end{array} \end{array}

Public Functions

FilterCoefficientsToPhaseSpectrum(int num_numerator_order, int num_denominator_order, int fft_length, bool unwrapping)

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$ .
unwrapping – [in] If true, perform phase unwrapping.

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 bool IsUnwrapped() const

Returns: True if unwrapping is performed.

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> *phase_spectrum, FilterCoefficientsToPhaseSpectrum::Buffer *buffer) const

Parameters

numerator_coefficients – [in] $M$ -th order coefficients.
denominator_coefficients – [in] $N$ -th order coefficients.
phase_spectrum – [out] $(L / 2 + 1)$ -length phase spectrum.
buffer – [out] Buffer.

Returns

True on success, false on failure.

class Buffer: Buffer for FilterCoefficientsToPhaseSpectrum class.