Revisions to Implementing discrete and continuous Hilbert transforms

lots of formatting fixes

Source Link

edited Sep 7, 2012 at 9:39

125.5k
11
407
581

Here's a direct implementation of the formula

$$\mathcal H(u)(t) = \frac1{\pi} {\int_{-\infty}^{\infty} \!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!-}\quad \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$$$\mathcal H(u)(t) = \frac1{\pi} -\hspace{-1.1em}\int_{-\infty}^\infty \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$

hilbertTransform[f_, u_, t_] :=
                  FullSimplify[Convolve[f, 1/u, u, t, PrincipalValue -> True]/Pi]π]

Try it out:

hilbertTransform[#, v, w] & /@ {Sin[v], Cos[v], 1/(1 + v^2), Sinc[v], DiracDelta[v]}
   {-Cos[w], Sin[w], w/(1 + w^2), (1 - Cos[w])/w, 1/(Pi*wπ w)}

For the discrete Hilbert transform, here is a Mathematica routine:

hilbert[data_?VectorQ] := Block[Module[{nfopts = FourierParameters -> {1, -1}, e, n},
   e = Boole[EvenQ[n = Length[data]]]; 
   Im[InverseFourier[Im[InverseFourier[Fourier[data, fopts] * 
     PadRight[
       ArrayPad[ConstantArray[2         PadRight[ArrayPad[ConstantArray[2, Quotient[n, 2] - e], {1, e}, 1], n],
       n] Fourier[data, FourierParameters -> {1, -1}], 
      FourierParameters -> {1, -1}]]]fopts]]] /; And @@ Thread[Im[data] == 0]

(making everything completely analogous to FourierTransform[] and Fourier[]). The algorithm is based on the routine in Marple's paper, and is essentially the same algorithm used by the function hilbert() in MATLAB's Signal Processing Toolbox.

Examples:

hilbert[{1, -2, 1}]
   {1.73205, 0., -1.73205}

hilbert[{1, -2, 1, 2}]
   {2., 0., -2., 0.}

Here's a direct implementation of the formula

$$\mathcal H(u)(t) = \frac1{\pi} {\int_{-\infty}^{\infty} \!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!-}\quad \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$

hilbertTransform[f_, u_, t_] :=
                  FullSimplify[Convolve[f, 1/u, u, t, PrincipalValue -> True]/Pi]

Try it out:

hilbertTransform[#, v, w] & /@ {Sin[v], Cos[v], 1/(1 + v^2), Sinc[v], DiracDelta[v]}
{-Cos[w], Sin[w], w/(1 + w^2), (1 - Cos[w])/w, 1/(Pi*w)}

For the discrete Hilbert transform, here is a Mathematica routine:

hilbert[data_?VectorQ] := Block[{n, e},
   e = Boole[EvenQ[n = Length[data]]]; 
   Im[InverseFourier[
     PadRight[
       ArrayPad[ConstantArray[2, Quotient[n, 2] - e], {1, e}, 1], 
       n] Fourier[data, FourierParameters -> {1, -1}], 
      FourierParameters -> {1, -1}]]] /; And @@ Thread[Im[data] == 0]

(making everything completely analogous to FourierTransform[] and Fourier[]). The algorithm is based on the routine in Marple's paper, and is essentially the same algorithm used by the function hilbert() in MATLAB's Signal Processing Toolbox.

Examples:

hilbert[{1, -2, 1}]
{1.73205, 0., -1.73205}

hilbert[{1, -2, 1, 2}]
{2., 0., -2., 0.}

Here's a direct implementation of the formula

$$\mathcal H(u)(t) = \frac1{\pi} -\hspace{-1.1em}\int_{-\infty}^\infty \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$

hilbertTransform[f_, u_, t_] :=
       FullSimplify[Convolve[f, 1/u, u, t, PrincipalValue -> True]/π]

Try it out:

hilbertTransform[#, v, w] & /@ {Sin[v], Cos[v], 1/(1 + v^2), Sinc[v], DiracDelta[v]}
   {-Cos[w], Sin[w], w/(1 + w^2), (1 - Cos[w])/w, 1/(π w)}

For the discrete Hilbert transform, here is a Mathematica routine:

hilbert[data_?VectorQ] := Module[{fopts = FourierParameters -> {1, -1}, e, n},
   e = Boole[EvenQ[n = Length[data]]]; 
   Im[InverseFourier[Fourier[data, fopts] * 
                     PadRight[ArrayPad[ConstantArray[2, Quotient[n, 2] - e], {1, e}, 1], n],
                     fopts]]] /; And @@ Thread[Im[data] == 0]

(making everything completely analogous to FourierTransform[] and Fourier[]). The algorithm is based on the routine in Marple's paper, and is essentially the same algorithm used by the function hilbert() in MATLAB's Signal Processing Toolbox.

Examples:

hilbert[{1, -2, 1}]
   {1.73205, 0., -1.73205}

hilbert[{1, -2, 1, 2}]
   {2., 0., -2., 0.}

shortened hilbertTransform[] implementation

Source Link

edited Jan 22, 2012 at 14:57

J. M.'s missing motivation ♦

125.5k
11
407
581

Here's a direct implementation of the formula

$$\mathcal H(u)(t) = \frac1{\pi} {\int_{-\infty}^{\infty} \!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!-}\quad \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$

hilbertTransform[f_, u_, t_] := FullSimplify[
                 Integrate[f/(t - u)FullSimplify[Convolve[f, {1/u, -Infinity, Infinity},
                           Assumptions -> Element[tu, Reals]t,
                           PrincipalValue -> True]/Pi]

Try it out:

hilbertTransform[#, v, w] & /@ {Sin[v], Cos[v], 1/(1 + v^2), Sinc[v], DiracDelta[v]}
{-Cos[w], Sin[w], w/(1 + w^2), (1 - Cos[w])/w, 1/(Pi*w)}

For the discrete Hilbert transform, here is a Mathematica routine:

hilbert[data_?VectorQ] := Block[{n, e},
   e = Boole[EvenQ[n = Length[data]]]; 
   Im[InverseFourier[
     PadRight[
       ArrayPad[ConstantArray[2, Quotient[n, 2] - e], {1, e}, 1], 
       n] Fourier[data, FourierParameters -> {1, -1}], 
     FourierParameters -> {1, -1}]]] /; And @@ Thread[Im[data] == 0]

(making everything completely analogous to FourierTransform[] and Fourier[]). The algorithm is based on the routine in Marple's paper, and is essentially the same algorithm used by the function hilbert() in MATLAB's Signal Processing Toolbox.

Examples:

hilbert[{1, -2, 1}]
{1.73205, 0., -1.73205}

hilbert[{1, -2, 1, 2}]
{2., 0., -2., 0.}

Here's a direct implementation of the formula

$$\mathcal H(u)(t) = \frac1{\pi} {\int_{-\infty}^{\infty} \!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!-}\quad \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$

hilbertTransform[f_, u_, t_] := FullSimplify[
                 Integrate[f/(t - u), {u, -Infinity, Infinity},
                           Assumptions -> Element[t, Reals],
                           PrincipalValue -> True]/Pi]

Try it out:

hilbertTransform[#, v, w] & /@ {Sin[v], Cos[v], 1/(1 + v^2), Sinc[v], DiracDelta[v]}
{-Cos[w], Sin[w], w/(1 + w^2), (1 - Cos[w])/w, 1/(Pi*w)}

For the discrete Hilbert transform, here is a Mathematica routine:

hilbert[data_?VectorQ] := Block[{n, e},
   e = Boole[EvenQ[n = Length[data]]]; 
   Im[InverseFourier[
     PadRight[
       ArrayPad[ConstantArray[2, Quotient[n, 2] - e], {1, e}, 1], 
       n] Fourier[data, FourierParameters -> {1, -1}], 
     FourierParameters -> {1, -1}]]] /; And @@ Thread[Im[data] == 0]

(making everything completely analogous to FourierTransform[] and Fourier[]). The algorithm is based on the routine in Marple's paper, and is essentially the same algorithm used by the function hilbert() in MATLAB's Signal Processing Toolbox.

Examples:

hilbert[{1, -2, 1}]
{1.73205, 0., -1.73205}

hilbert[{1, -2, 1, 2}]
{2., 0., -2., 0.}

Here's a direct implementation of the formula

$$\mathcal H(u)(t) = \frac1{\pi} {\int_{-\infty}^{\infty} \!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!-}\quad \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$

hilbertTransform[f_, u_, t_] :=
                  FullSimplify[Convolve[f, 1/u, u, t, PrincipalValue -> True]/Pi]

Try it out:

hilbertTransform[#, v, w] & /@ {Sin[v], Cos[v], 1/(1 + v^2), Sinc[v], DiracDelta[v]}
{-Cos[w], Sin[w], w/(1 + w^2), (1 - Cos[w])/w, 1/(Pi*w)}

For the discrete Hilbert transform, here is a Mathematica routine:

hilbert[data_?VectorQ] := Block[{n, e},
   e = Boole[EvenQ[n = Length[data]]]; 
   Im[InverseFourier[
     PadRight[
       ArrayPad[ConstantArray[2, Quotient[n, 2] - e], {1, e}, 1], 
       n] Fourier[data, FourierParameters -> {1, -1}], 
     FourierParameters -> {1, -1}]]] /; And @@ Thread[Im[data] == 0]

(making everything completely analogous to FourierTransform[] and Fourier[]). The algorithm is based on the routine in Marple's paper, and is essentially the same algorithm used by the function hilbert() in MATLAB's Signal Processing Toolbox.

Examples:

hilbert[{1, -2, 1}]
{1.73205, 0., -1.73205}

hilbert[{1, -2, 1, 2}]
{2., 0., -2., 0.}

added discrete transform

Source Link

edited Jan 20, 2012 at 13:38

J. M.'s missing motivation ♦

125.5k
11
407
581

Here's a direct implementation of the formula

$$\mathcal H(u)(t) = \frac1{\pi} {\int_{-\infty}^{\infty} \!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!-}\quad \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$

hilbertTransform[f_, u_, t_] := FullSimplify[
                 Integrate[f/(t - u), {u, -Infinity, Infinity},
                           Assumptions -> Element[t, Reals],
                           PrincipalValue -> True]/Pi]

Try it out:

hilbertTransform[#, v, w] & /@ {Sin[v], Cos[v], 1/(1 + v^2), Sinc[v], DiracDelta[v]}
{-Cos[w], Sin[w], w/(1 + w^2), (1 - Cos[w])/w, 1/(Pi*w)}

For the discrete Hilbert transform, here is a Mathematica routine:

hilbert[data_?VectorQ] := Block[{n, e},
   e = Boole[EvenQ[n = Length[data]]]; 
   Im[InverseFourier[
     PadRight[
       ArrayPad[ConstantArray[2, Quotient[n, 2] - e], {1, e}, 1], 
       n] Fourier[data, FourierParameters -> {1, -1}], 
     FourierParameters -> {1, -1}]]] /; And @@ Thread[Im[data] == 0]

(making everything completely analogous to FourierTransform[] and Fourier[]). The algorithm is based on the routine in Marple's paper, and is essentially the same algorithm used by the function hilbert() in MATLAB's Signal Processing Toolbox.

Examples:

hilbert[{1, -2, 1}]
{1.73205, 0., -1.73205}

hilbert[{1, -2, 1, 2}]
{2., 0., -2., 0.}

Here's a direct implementation of the formula

$$\mathcal H(u)(t) = \frac1{\pi} {\int_{-\infty}^{\infty} \!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!-}\quad \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$

hilbertTransform[f_, u_, t_] := FullSimplify[
                 Integrate[f/(t - u), {u, -Infinity, Infinity},
                           Assumptions -> Element[t, Reals],
                           PrincipalValue -> True]/Pi]

Try it out:

hilbertTransform[#, v, w] & /@ {Sin[v], Cos[v], 1/(1 + v^2), Sinc[v], DiracDelta[v]}
{-Cos[w], Sin[w], w/(1 + w^2), (1 - Cos[w])/w, 1/(Pi*w)}

Here's a direct implementation of the formula

$$\mathcal H(u)(t) = \frac1{\pi} {\int_{-\infty}^{\infty} \!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!\!-}\quad \frac{u(\tau)}{t-\tau}\, \mathrm d\tau$$

hilbertTransform[f_, u_, t_] := FullSimplify[
                 Integrate[f/(t - u), {u, -Infinity, Infinity},
                           Assumptions -> Element[t, Reals],
                           PrincipalValue -> True]/Pi]

Try it out:

hilbertTransform[#, v, w] & /@ {Sin[v], Cos[v], 1/(1 + v^2), Sinc[v], DiracDelta[v]}
{-Cos[w], Sin[w], w/(1 + w^2), (1 - Cos[w])/w, 1/(Pi*w)}

For the discrete Hilbert transform, here is a Mathematica routine:

hilbert[data_?VectorQ] := Block[{n, e},
   e = Boole[EvenQ[n = Length[data]]]; 
   Im[InverseFourier[
     PadRight[
       ArrayPad[ConstantArray[2, Quotient[n, 2] - e], {1, e}, 1], 
       n] Fourier[data, FourierParameters -> {1, -1}], 
     FourierParameters -> {1, -1}]]] /; And @@ Thread[Im[data] == 0]

(making everything completely analogous to FourierTransform[] and Fourier[]). The algorithm is based on the routine in Marple's paper, and is essentially the same algorithm used by the function hilbert() in MATLAB's Signal Processing Toolbox.

Examples:

hilbert[{1, -2, 1}]
{1.73205, 0., -1.73205}

hilbert[{1, -2, 1, 2}]
{2., 0., -2., 0.}

Source Link

created Jan 20, 2012 at 12:28

J. M.'s missing motivation ♦

125.5k
11
407
581

Loading

Stack Exchange Network

Return to Answer