WOLFRAM

Wolfram Language & System Documentation Center

DiscreteHilbertTransform[list]

finds the discrete Hilbert transform of the list list of real numbers.

Details
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Applications  
Communications  
ECG Frequency Analysis  
Wind Speed Prediction  
Seismic Data Analysis  
Properties & Relations  
See Also
Related Guides
History
Cite this Page

DiscreteHilbertTransform

DiscreteHilbertTransform[list]

finds the discrete Hilbert transform of the list list of real numbers.

Details

  • Discrete Hilbert transforms have applications in signal processing, communications, acoustics, data compression, seismic ambient data, gravitational waves, etc.
  • This transform imparts a phase shift to the original sequence for positive frequencies and a phase shift for negative frequencies.
  • For a list , DiscreteHilbertTransform, calculates its FFT, annihilates negative frequencies and calculates the inverse FFT of the result, of which the imaginary part is . »
  • In signal processing, the complex sequence is called the analytic signal, and its magnitude is the envelope:
  • can have any positive integer length.
  • If the elements of are exact numbers, DiscreteHilbertTransform begins by applying N to them.
  • can also be a SparseArray object, resulting in , also a SparseArray object.

Examples

open all close all

Basic Examples  (2)

Find a discrete Hilbert transform:

Wolfram Language code: DiscreteHilbertTransform[{1, 1, 2, 2, 1, 1, 0, 0}]

Find the analytic representation for a real value signal:

Wolfram Language code: {1, 2, 3, 4, 5, 6} + I DiscreteHilbertTransform[{1, 2, 3, 4, 5, 6}]

Scope  (9)

x is a list of real values:

Wolfram Language code: x = {1, 0, 0, 1, 0, 0, 1};

Compute the discrete Hilbert transform with machine arithmetic:

Wolfram Language code: DiscreteHilbertTransform[x]

Compute using 24-digit precision arithmetic:

Wolfram Language code: DiscreteHilbertTransform[N[x, 24]]

Compute a 2D discrete Hilbert transform:

Wolfram Language code: DiscreteHilbertTransform[RandomReal[{2, 4}, {3, 6}]]

x is a rank-3 tensor with nonzero diagonal:

Wolfram Language code: x = ConstantArray[0, {2, 3, 4}];x[[1, 1, 1]] = 1;x[[2, 2, 2]] = 1;

Compute the 3D Discrete Hilbert transform:

Wolfram Language code: DiscreteHilbertTransform[x]

x is a SparseArray of real values:

Wolfram Language code: x = SparseArray[{{1, 2} -> -1, {2, 2} -> 2π, {3, 3} -> 1.3, {2, 3} -> 7}];

Compute the discrete Hilbert transform and get the result as a SparseArray:

Wolfram Language code: DiscreteHilbertTransform[x]

x is a large sparse matrix of real values:

Wolfram Language code: x = SparseArray[Table[3 ^ i -> 1, {i, 10}]];

Compute the discrete Hilbert transform and get the result as a SparseArray:

Wolfram Language code: DiscreteHilbertTransform[x]

Consider a discrete cosine wave:

Wolfram Language code: discreteCosine = Table[Cos[t], {t, -π, π, π / 25}];

DiscreteHilbertTransform applies a degree phase shift:

Wolfram Language code: discreteHCosine = DiscreteHilbertTransform[discreteCosine];
Wolfram Language code: ListPlot[{discreteCosine, discreteHCosine}, ...]

Here are the values for the first 10 elements of the discrete signal and its discrete Hilbert transform:

Wolfram Language code: Tabular[(Transpose[{N[discreteCosine], discreteHCosine}])[[ ;; 10]] , {...}]

Generate a random sequence of real numbers:

Wolfram Language code: x = RandomReal[1, 200];

Compute the discrete Hilbert transform:

Wolfram Language code: dhtx = DiscreteHilbertTransform[x];

Plot the original data and its transform together:

Wolfram Language code: ListLinePlot[{x, dhtx}, ...]

Consider instead a sinusoidal sequence with some noise:

Wolfram Language code: x = Sin[17 * 2π * Range[0, 1, 0.001]] + RandomVariate[NormalDistribution[0, 0.05], 1001];

Compute the discrete Hilbert transform:

Wolfram Language code: dhtx = DiscreteHilbertTransform[x];

Plot the original data and its transform together:

Wolfram Language code: ListLinePlot[{x, dhtx}, ...]

Data from a Sinc function with noise:

Wolfram Language code: n = 100; x = Table[Sinc[x - 10], {x, n}] + RandomReal[{-.05, .05}, {n}];
Wolfram Language code: ListPlot[x, PlotRange -> All]

Its power spectrum:

Wolfram Language code: p = Fourier[x, FourierParameters -> {1, 1}]; ListPlot[Abs[p] ^ 2]

Its discrete Hilbert transform:

Wolfram Language code: dHx = DiscreteHilbertTransform[x];

It provides the imaginary component for the analytic representation:

Wolfram Language code: a = x + I * dHx;

Power spectrum for the analytical signal:

Wolfram Language code: s = Fourier[a, FourierParameters -> {1, 1}]; ListPlot[Abs[s] ^ 2]

The envelope of an oscillating signal is a curve outlining its extremes, and it is the magnitude of the
analytic representation:

Wolfram Language code: ListLinePlot[{x, dHx, Abs /@ a}, ...]

Applications  (4)

Communications  (1)

Consider the following message signal:

Wolfram Language code: m = Table[Sin[2Pi 5t] + 2Sin[2Pi 7t] + 1 / 2Sin[2Pi 9t], {t, -π / 2, π / 2, π / 100}]; ListLinePlot[m, DataRange -> {-π / 2, π / 2}, ...]

Using as a message carrier, get the upper side band-suppressed carrier (USB-SC) and lower side band-suppressed carrier (LSB-SC):

Wolfram Language code: c = Table[Cos[2Pi 55t], {t, -π / 2, π / 2, π / 100}]; s = Table[Sin[2Pi 55t], {t, -π / 2, π / 2, π / 100}]; USB = m * c - DiscreteHilbertTransform[m] * s; LSB = m * c + DiscreteHilbertTransform[m] * s; ListLinePlot[{USB, LSB}, ...]

ECG Frequency Analysis  (1)

Electrocardiogram time-frequency analysis can reveal important information. Consider a patient's ECG data, which provides a voltage versus time graph of the electrical activity of the heart:

Wolfram Language code: ECGData = {...}; ListLinePlot[ECGData, ...]

Filter the data using KaiserWindow:

Wolfram Language code: filteredECG = BandpassFilter[ECGData, {(4π/25), (2π/5)}, Length[ECGData], KaiserWindow];

Find its first differential in the discrete domain(sampling frequency of 100Hz):

Wolfram Language code: differentialECG = Differences[filteredECG] / (2 * .01);

The discrete Hilbert transform is:

Wolfram Language code: dhDifferentialECG = DiscreteHilbertTransform[differentialECG];

Compare the RMS and 18% of the maximum of the discrete Hilbert transform:

Wolfram Language code: {Max[dhDifferentialECG] * .18, RootMeanSquare[dhDifferentialECG]}

This will indicate a threshold of 39% of the maximum: with this information, you can now find the location of the R peaks using the Hilbert transform of the first differential:

Wolfram Language code: RpeaksLocation = First /@ FindPeaks[dhDifferentialECG, Automatic, Automatic, Max[dhDifferentialECG] * .39];

Visualize R peaks in the ECG data:

Wolfram Language code: RPeaks = Transpose@{RpeaksLocation, ECGData[[RpeaksLocation]]}; ListPlot[{ECGData, RPeaks}, ...]

Wind Speed Prediction  (1)

Consider the weather forecast for wind speed and direction in the city of San Juan, Puerto Rico, for the next seven days:

Wolfram Language code: speedDateData = QuantityMagnitude[WeatherForecastData[...]]; directionDateData = (π/180)QuantityMagnitude[WeatherForecastData[...]]; DateListPlot[{speedDateData, directionDateData}, ...]

The predicted wind speed is given by the formula , where is the maximum value of the speed data and and are the mean values for the sequences and direction data, respectively. and are the discrete Hilbert transforms for these sequences, respectively, with their mean values removed:

Wolfram Language code: {...}; DateListPlot[{...}, ...]

Seismic Data Analysis  (1)

Consider the following seismic trace, which illustrates how ground motion, resulting from seismic waves, is detected and recorded over time:

Wolfram Language code: trace = {...}; ListLinePlot[trace]

Compute its Hilbert transform:

Wolfram Language code: dhTrace = DiscreteHilbertTransform[trace];

Get the complex trace:

Wolfram Language code: complexTrace = trace + I * dhTrace;

And its envelope:

Wolfram Language code: env = Abs[complexTrace];

Plot the trace, its transform and its envelope:

Wolfram Language code: ListLinePlot[{trace, dhTrace, env, -env}, ...]

The instantaneous phase:

Wolfram Language code: phase = ArcTan[trace, dhTrace]; ListLinePlot[phase, PlotLabel -> "Instantaneous phase for the complex trace"]

Properties & Relations  (2)

For a list :

Wolfram Language code: Subscript[f, k] = {1.1, -1.2, 5.5, -4.5};

Calculate its fast Fourier transform:

Wolfram Language code: fFourier = Fourier[Subscript[f, k], FourierParameters -> {1, -1}]

Annihilate negative frequencies:

Wolfram Language code: anhilation = {1, 2, 1, 0} * fFourier

Calculate the inverse FFT:

Wolfram Language code: InverseFourier[anhilation, FourierParameters -> {1, -1}]

Finally, compare the imaginary part with DiscreteHilbertTransform:

Wolfram Language code: Im[%] == DiscreteHilbertTransform[Subscript[f, k]]

For the analytic representation of a real value signal:

Wolfram Language code: {-2.3, -3.14, 1.62, E, Pi} + I DiscreteHilbertTransform[{-2.3, -3.14, 1.62, E, Pi}]

The DC component (first position) and the Nyquist component(TemplateBox[{{n, /, 2}}, Ceiling] position) are always real:

Wolfram Language code: Fourier[%, FourierParameters -> {1, -1}]//Chop
Wolfram Research (2026), DiscreteHilbertTransform, Wolfram Language function, https://reference.wolfram.com/language/ref/DiscreteHilbertTransform.html.

Text

Wolfram Research (2026), DiscreteHilbertTransform, Wolfram Language function, https://reference.wolfram.com/language/ref/DiscreteHilbertTransform.html.

CMS

Wolfram Language. 2026. "DiscreteHilbertTransform." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/DiscreteHilbertTransform.html.

APA

Wolfram Language. (2026). DiscreteHilbertTransform. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/DiscreteHilbertTransform.html

BibTeX

@misc{reference.wolfram_2026_discretehilberttransform, author="Wolfram Research", title="{DiscreteHilbertTransform}", year="2026", howpublished="\url{https://reference.wolfram.com/language/ref/DiscreteHilbertTransform.html}", note=[Accessed: 12-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_discretehilberttransform, organization={Wolfram Research}, title={DiscreteHilbertTransform}, year={2026}, url={https://reference.wolfram.com/language/ref/DiscreteHilbertTransform.html}, note=[Accessed: 12-June-2026]}