---
title: "FindPeaks"
language: "en"
type: "Symbol"
summary: "FindPeaks[list] gives positions and values of the detected peaks in list. FindPeaks[list, \\[Sigma]] finds peaks that survive Gaussian blurring up to scale \\[Sigma]. FindPeaks[list, \\[Sigma], s] finds peaks with minimum sharpness s. FindPeaks[list, \\[Sigma], s, t] finds only peaks with values greater than t. FindPeaks[list, \\[Sigma], {s, \\[Sigma]s}, {t, \\[Sigma]t}] uses different scales for thresholding sharpness and value."
keywords: 
- peak fitting
- peak detection
- maxiumum finding
- spike detection
- resonance detection
canonical_url: "https://reference.wolfram.com/language/ref/FindPeaks.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Data Transforms and Smoothing"
    link: "https://reference.wolfram.com/language/guide/DataTransformsAndSmoothing.en.md"
  - 
    title: "Curve Fitting & Approximate Functions"
    link: "https://reference.wolfram.com/language/guide/CurveFittingAndApproximateFunctions.en.md"
  - 
    title: "Signal Visualization & Analysis"
    link: "https://reference.wolfram.com/language/guide/SignalAnalysis.en.md"
  - 
    title: "Feature Detection"
    link: "https://reference.wolfram.com/language/guide/FeatureDetection.en.md"
  - 
    title: "Statistical Data Analysis"
    link: "https://reference.wolfram.com/language/guide/Statistics.en.md"
  - 
    title: "Signal Processing"
    link: "https://reference.wolfram.com/language/guide/SignalProcessing.en.md"
related_functions: 
  - 
    title: "PeakDetect"
    link: "https://reference.wolfram.com/language/ref/PeakDetect.en.md"
  - 
    title: "FindMaximum"
    link: "https://reference.wolfram.com/language/ref/FindMaximum.en.md"
  - 
    title: "FindArgMax"
    link: "https://reference.wolfram.com/language/ref/FindArgMax.en.md"
  - 
    title: "FindMinimum"
    link: "https://reference.wolfram.com/language/ref/FindMinimum.en.md"
  - 
    title: "MaxDetect"
    link: "https://reference.wolfram.com/language/ref/MaxDetect.en.md"
  - 
    title: "MaximalBy"
    link: "https://reference.wolfram.com/language/ref/MaximalBy.en.md"
  - 
    title: "EstimatedBackground"
    link: "https://reference.wolfram.com/language/ref/EstimatedBackground.en.md"
  - 
    title: "Fourier"
    link: "https://reference.wolfram.com/language/ref/Fourier.en.md"
  - 
    title: "FindAnomalies"
    link: "https://reference.wolfram.com/language/ref/FindAnomalies.en.md"
---
# FindPeaks

FindPeaks[list] gives positions and values of the detected peaks in list.

FindPeaks[list, σ] finds peaks that survive Gaussian blurring up to scale σ.

FindPeaks[list, σ, s] finds peaks with minimum sharpness s.

FindPeaks[list, σ, s, t] finds only peaks with values greater than t.

FindPeaks[list, σ, {s, σs}, {t, σt}] uses different scales for thresholding sharpness and value.

## Details and Options

* ``FindPeaks`` finds local maxima using the given constraints, returning the result as ``{{x1, y1}, {x2, y2}, …}``.

* Input ``list`` can be of one of the following forms:

|                |                                       |
| -------------- | ------------------------------------- |
| {y1, y2, …}    | a list of values                      |
| TimeSeries[…]  | regularly sampled time series object  |
| EventSeries[…] | regularly sampled event series object |

* ``FindPeaks[list]`` automatically chooses scale, sharpness and threshold parameters.

* To avoid the detection of noise-related peaks, the input is regularized by performing a Gaussian filtering using the standard deviation ``σ``.

* The value of ``σ`` defaults to $(\log (n)/\log (100))^2$, with ``n`` being the number of data points in ``list``. Larger values for ``σ`` reduce the number of peaks.

* Peaks detected in the regularized data are traced back to the corresponding peaks in the original data.

* By default, peaks are not filtered based on their sharpness ($s=0$). The sharpness ``s`` is computed as the second derivative of the data with a Gaussian filter at scale ``σ``. Specify a smaller scale using ``{s, σs}``.

* By default, peaks of any height are returned. Use a threshold ``t`` to dismiss peaks with smaller values. To apply the threshold at a scale other than 0, use ``{t, σt}``.

* ``FindPeaks[list, σ, s, t]`` is equivalent to ``FindPeaks[list, σ, {s, σ}, {t, 0}]``.

* The following options can be given:

|                     |             |                                             |
| ------------------- | ----------- | ------------------------------------------- |
| InterpolationOrder  | Automatic   | spline interpolation order of up to order 3 |
| Padding             | "Reflected" | padding scheme to use                       |

* By default, ``InterpolationOrder -> 1`` is assumed for lists of data. For ``TimeSeries`` objects, the interpolation order is inherited.

* The interpolation order is used when computing peak positions. Peaks may be located in between and possibly above ``{x, y}`` samples interpolation orders.

* For interpolation orders 0 or 1, a plateau of two or more data samples is assigned a single peak at its center location.

* For possible settings for ``Padding``, see the reference page for ``ArrayPad``.

## Examples (22)

### Basic Examples (1)

Find position and height of dominant peaks in a list:

```wl
In[1]:= values = {1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 3, 2, 4, 2, 2, 1};

In[2]:= peaks = FindPeaks[values]

Out[2]= {{(9/2), 6}, {10, 7}, {13, 4}}
```

Visualize list and the detected peaks:

```wl
In[3]:=
ListLinePlot[
	{values, peaks}, 
	Joined -> {True, False}, 
	PlotStyle -> {Automatic, PointSize[.03]}
	]

Out[3]= [image]
```

### Scope (12)

#### Data (4)

Peaks of a 1D list:

```wl
In[1]:= list = {1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 3, 2, 4, 2, 2, 1};

In[2]:=
ListLinePlot[
	{list, FindPeaks[list]}, 
	Joined -> {True, False}, 
	PlotStyle -> {Automatic, PointSize[.03]}
	]

Out[2]= [image]
```

---

Peaks of a ``TimeSeries`` object:

```wl
In[1]:=
ts = TemporalData[TimeSeries, {CompressedData["«370»"], {TemporalData`DateSpecification[{2013, 1, 2, 0, 0, 0.}, {2013, 11, 27, 0, 0, 0}, 
    {1, "Week"}]}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, {}}, True, 10.];

In[2]:= peaks = FindPeaks[ts, 0, 0, 0]

Out[2]=
TemporalData[TimeSeries, {{{54.75, 55.9, 57.9, 58.32, 63.5, 64.96, 69.04, 73.5, 71.47, 81.15}}, 
  {{{3.5660736*^9, 3.5684928*^9, 3.5715168*^9, 3.5745408*^9, 3.5775648*^9, 3.579984*^9, 
     3.5824032*^9, 3.5842176*^9, 3.586032*^9, 3.5944992*^9}}}, 1, {"Discrete", 1}, {"Discrete", 1}, 
  1, {}}, True, 14.3]

In[3]:=
DateListPlot[
	{ts, peaks}, 
	Joined -> {True, False}, 
	PlotStyle -> {Automatic, PointSize[.03]}
	]

Out[3]= [image]
```

---

Peaks of an ``EventSeries`` object:

```wl
In[1]:=
v = RandomInteger[{-10, 10}, n = 50];
t = N@Range[0, 1, 1 / (n - 1)];

In[2]:= es = EventSeries[v, {t}]

Out[2]=
TemporalData[EventSeries, {{{6, -7, 7, -3, 2, 5, -5, 5, 5, -9, -9, 4, 0, -10, -8, -5, 9, 0, -1, 1, 
    -2, -6, 0, -9, -4, -3, 8, 3, -1, -6, 10, 2, 3, 4, -9, 5, 6, -6, -6, -4, -4, 7, -7, -8, -4, 7, 
    2, -6, 10, -2}}, {{0., 1., 0.02040816326530612}}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, 
  {ResamplingMethod -> None, ValueDimensions -> 1}}, False, 12.2]
```

Find peaks:

```wl
In[3]:= peaks = FindPeaks[es, 1, 0, 0]

Out[3]=
TemporalData[EventSeries, {{{6, 7, 5, 5, 4, 9, 0, 8, 10, 6, 7, 7, 10}}, 
  {{{-0.010204081632653062, 0.04081632653061224, 0.1020408163265306, 0.15306122448979592, 
     0.22448979591836732, 0.32653061224489793, 0.44897959183673464, 0.5306122448979591, 
     0.6122448979591836, 0.7346938775510203, 0.836734693877551, 0.9183673469387754, 
     0.9795918367346939}}}, 1, {"Discrete", 1}, {"Discrete", 1}, 1, 
  {ResamplingMethod -> None, ValueDimensions -> 1}}, False, 12.2]

In[4]:=
DateListPlot[
	{es, peaks["Path"]}, 
	Joined -> {False, False}, 
	Filling -> Axis, 
	PlotStyle -> {Automatic, PointSize[.03]}
	]

Out[4]= [image]
```

---

Peaks of a list of ``Quantity`` objects:

```wl
In[1]:= data = {Quantity[9, "Feet"], Quantity[86, "Inches"], Quantity[27, "Meters"], Quantity[79, "Feet"], Quantity[90, "Feet"], Quantity[41, "Inches"], Quantity[99, "Inches"], Quantity[6, "Feet"], Quantity[38, "Feet"], Quantity[89, "Feet"], Quantity[53, "Feet"], Quantity[85, "Meters"], Quantity[92, "Meters"], Quantity[95, "Meters"], Quantity[49, "Feet"]};

In[2]:= peaks = FindPeaks[data]

Out[2]= {{3, Quantity[11250/127, "Feet"]}, {5, Quantity[90, "Feet"]}, {14, Quantity[118750/381, "Feet"]}}

In[3]:= ListPlot[{data, peaks}, Joined -> {True, False}, PlotStyle -> {Automatic, PointSize[.03]}]

Out[3]= [image]
```

Threshold for values greater than 30 meters:

```wl
In[4]:= peaks30 = FindPeaks[data, Automatic, Automatic, Quantity[30, "Meters"]]

Out[4]= {{14, Quantity[118750/381, "Feet"]}}

In[5]:=
ListPlot[
	{data, peaks30}, 
	Joined -> {True, False}, 
	PlotStyle -> {Automatic, PointSize[.03]}, 
	AxesLabel -> {None, "height [ft]"}
	]

Out[5]= [image]
```

#### Parameters (8)

By default, an automatic scale is used:

```wl
In[1]:=
v = {2, 1, 6, 5, 7, 4};
FindPeaks[v]

Out[1]= {{(1/2), 2}, {5, 7}}
```

---

Find all peaks at scale $\sigma =0$ :

```wl
In[1]:=
v = {2, 1, 6, 5, 7, 4};
FindPeaks[v, 0]

Out[1]= {{1, 2}, {3, 6}, {5, 7}}
```

---

Compute peaks at different scales:

```wl
In[1]:=
list = Table[ Sin[x] + RandomReal[.5{-1, 1}], {x, 0, 3 Pi, 0.1}];
ListLinePlot[list]

Out[1]= [image]

In[2]:= Table[ListPlot[{list, FindPeaks[list, σ]}, Joined -> {True, False}, PlotStyle -> {Automatic, PointSize[.04]}], {σ, {1, 2, 4}}]

Out[2]= {[image], [image], [image]}
```

---

When finding peaks at scale $\sigma$, only peaks that sustain a blur up to scale $\sigma$ are returned:

```wl
In[1]:= values = {2, 1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 3, 4, 2, 2, 1};

In[2]:= peaks = FindPeaks[values, 1]

Out[2]= {{(11/2), 6}, {11, 7}}
```

Signal and its blurred version at scale $\sigma =1$ :

```wl
In[3]:=
ListLinePlot[
	{values, GaussianFilter[values, {3, 1}], peaks}, 
	Joined -> {True, True, False}, 
	PlotStyle -> {Automatic, Dashed, {Red, PointSize[0.03]}}, PlotLegends -> {"original", "smoothed", "peaks"}, 
	ImageSize -> 240
	]

Out[3]= [image]
```

---

By default, peaks are not filtered based on their sharpness, equivalent to $s=0$ :

```wl
In[1]:= values = {2, 1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 2, 3, 4, 3, 2};

In[2]:= FindPeaks[values, 0, 0]

Out[2]= {{(1/2), 2}, {(11/2), 6}, {11, 7}, {14, 4}}
```

---

Specify minimum sharpness value $s=3$ :

```wl
In[1]:= values = {2, 1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 2, 3, 4, 3, 2};

In[2]:= peaks = FindPeaks[values, 0, 3]

Out[2]= {{11, 7}}
```

Sharpness, defined by the negative second derivative, should be greater than the specified ``s`` :

```wl
In[3]:=
ListLinePlot[
	{values, 
	ListConvolve[{1, -2, 1}, ArrayPad[values, 1, "Reversed"]], 
	peaks}, 
	...
	]

Out[3]= [image]
```

---

Specify a minimum height value $t=5.1$ :

```wl
In[1]:= list = {2, 1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 1, 4, 2, 2, 1};

In[2]:= peaks = FindPeaks[list, 0, 0, 5.1]

Out[2]= {{(11/2), 6}, {11, 7}}

In[3]:= ListLinePlot[{list, peaks}, ...]

Out[3]= [image]
```

---

Apply the value threshold after smoothing the data using a scale $\sigma _t=1$ :

```wl
In[1]:= list = {2, 1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 1, 4, 2, 2, 1};

In[2]:= peaks = FindPeaks[list, 2, 0, {5.1, 1}]

Out[2]= {{(11/2), 6}}

In[3]:= ListPlot[{list, GaussianFilter[list, 1{3, 1}], peaks}, ...]

Out[3]= [image]
```

### Options (3)

#### InterpolationOrder (1)

By default, ``InterpolationOrder -> 1`` is used:

```wl
In[1]:= values = {2, 1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 3};

In[2]:= peaks = FindPeaks[values, 0]

Out[2]= {{(1/2), 2}, {(11/2), 6}, {11, 7}}

In[3]:= ListPlot[{values, peaks}, ...]

Out[3]= [image]
```

Find peaks of the cubic interpolation:

```wl
In[4]:= peaks = FindPeaks[values, 0, InterpolationOrder -> 3]

Out[4]= {{5.56682, 6.25058}, {10.9373, 7.0248}}
```

Note that the number and position of peaks may vary depending on the interpolation order:

```wl
In[5]:= ListPlot[{values, peaks}, InterpolationOrder -> 3, ...]

Out[5]= [image]
```

#### Padding (2)

By default, ``Padding -> "Reflected"`` is used:

```wl
In[1]:= values = {2, 1, 3, 5, 6, 6, 4, 3, 2, 4, 7, 3, 4, 2, 2, 1};

In[2]:= peaks = FindPeaks[values, 0]

Out[2]= {{1, 2}, {(11/2), 6}, {11, 7}, {13, 4}}

In[3]:= ListPlot[{values, peaks}, Joined -> {True, False}, PlotStyle -> {Automatic, {PointSize[.03], Red}}]

Out[3]= [image]
```

Specify a constant padding:

```wl
In[4]:= peaks = FindPeaks[values, 0, Padding -> 4]

Out[4]= {{(11/2), 6}, {11, 7}, {13, 4}}

In[5]:= ListPlot[{values, peaks}, Joined -> {True, False}, PlotStyle -> {Automatic, {PointSize[.03], Red}}]

Out[5]= [image]
```

---

Padding influences the occurrence and position of peaks at the boundary:

```wl
In[1]:= values = {2, 1, 3, 5, 6, 7, 3, 2, 1};
```

By default, ``"Reflected"`` padding causes a peak at position 1:

```wl
In[2]:=
peaks = FindPeaks[values, 0, Padding -> "Reflected"];
ListLinePlot[{values, peaks}, ...]

Out[2]= [image]
```

``"Reversed"`` padding induces a peak at position 1/2:

```wl
In[3]:=
values = {2, 1, 3, 5, 6, 7, 3, 2, 1};peaks = FindPeaks[values, 0, Padding -> "Reversed"];
ListLinePlot[{values, peaks}, ...]

Out[3]= [image]
```

``"Fixed"`` padding results in no peak at the boundary:

```wl
In[4]:=
peaks = FindPeaks[values, 0, Padding -> "Fixed"];
ListLinePlot[{values, peaks}, ...]

Out[4]= [image]
```

### Applications (6)

Find peaks in the stock price of Apple in the year 2013:

```wl
In[1]:= data = FinancialData["AAPL", {{2013, 1, 1}, {2014, 1, 1}, "Day"}]

Out[1]=
TemporalData[TimeSeries, {{{Quantity[19.608200073242188, "USDollars"], 
    Quantity[19.360599517822266, "USDollars"], Quantity[18.821399688720703, "USDollars"], 
    Quantity[18.7106990814209, "USDollars"], Quantity[18.76110076904297, "USDollars"] ...  Quantity[20.036399841308594, "USDollars"]}}, CompressedData["«1324»"], 1, 
  {"Continuous", 1}, {"Discrete", 1}, 1, {ValueDimensions -> 1, DateFunction -> Automatic, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}}}, True, 12.]

In[2]:= resampled = TimeSeriesResample[data, "Day"]

Out[2]=
TemporalData[TimeSeries, 
 {{QuantityArray[StructuredArray`StructuredData[{364}, 
     {CompressedData["«2130»"], "USDollars", {{1}}}]]}, 
  {TemporalData`DateSpecification[{2013, 1, 2, 0, 0, 0.}, {2013, 12, 31, 0, 0, 0.}, {1, "Day"}]}, 
  1, {"Continuous", 1}, {"Discrete", 1}, 1, {DateFunction -> Automatic, 
   ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, True, 
 13.1]

In[3]:= peaks = FindPeaks[resampled, 3]

Out[3]=
TemporalData[TimeSeries, {{{Quantity[19.608200073242188, "USDollars"], 
    Quantity[17.140399932861328, "USDollars"], Quantity[16.556400299072266, "USDollars"], 
    Quantity[15.560400009155273, "USDollars"], Quantity[16.56570053100586, "USDollars ... 832*^9, 3.5915616*^9, 3.593376*^9, 
     3.595536*^9, 3.5967456*^9}}}, 1, {"Continuous", 1}, {"Discrete", 1}, 1, 
  {DateFunction -> Automatic, ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, 
   ValueDimensions -> 1}}, True, 13.1]
```

Highlight peaks on the plot of the data:

```wl
In[4]:= DateListPlot[resampled, Epilog -> {Orange, PointSize[0.03], Point[QuantityMagnitude@peaks["Path"]]}]

Out[4]= [image]
```

---

Find peaks in elevation data:

```wl
In[1]:= list = QuantityMagnitude[GeoElevationData[{GeoPosition[{0, 0}], GeoPosition[{.2, 180}]}]][[1]];

In[2]:= peaks = FindPeaks[list, 3];

In[3]:= ListPlot[{list, peaks}, ...]

Out[3]= [image]
```

---

Mean daily temperatures for Chicago during a period of two months:

```wl
In[1]:= temp = WeatherData["Chicago", "MeanTemperature", {{2014, 11, 1}, {2014, 12, 31}, "Day"}]

Out[1]=
TemporalData[TimeSeries, 
 {{QuantityArray[StructuredArray`StructuredData[{61}, 
     {{4.44, 4.44, 9.89, 16.61, 8.17, 12.67, 5.11, 6.44, 5.44, 9.94, 14.61, 1.61, -2, -1.94, -2.44, 
       -1.67, -1.39, -9.83, -6.89, -3.67, -6.39, 0.56, 11.22, 11.0 ... {TemporalData`DateSpecification[{2014, 11, 1, 0, 0, 0.}, {2014, 12, 31, 0, 0, 0.}, {1, "Day"}]}, 
  1, {"Continuous", 1}, {"Discrete", 1}, 1, 
  {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}, ValueDimensions -> 1}}, True, 
 12.3]

In[2]:= DateListPlot[temp]

Out[2]= [image]
```

Find peaks in the temperature:

```wl
In[3]:= peaks = FindPeaks[temp, 0, Automatic, Quantity[0, "DegreesCelsius"]];

In[4]:= DateListPlot[{temp, peaks}, ...]

Out[4]= [image]
```

---

Find peaks in an ECG signal:

```wl
In[1]:= ecg = {...};

In[2]:= peaks = FindPeaks[ecg, 8, {0.01, 0}, InterpolationOrder -> 2]

Out[2]= {{1.64286, 1.0031}, {38.1749, 0.491977}, {127.407, 0.998608}, {164.429, 0.529619}, {165.522, 0.52893}}

In[3]:=
ListPlot[{ecg, peaks}, Joined -> {True, False}, PlotStyle -> {Automatic, {Orange, PointSize[.03]}}, 
	InterpolationOrder -> 2, PlotRange -> All, Axes -> None]

Out[3]= [image]
```

---

Detect the mode of a distribution using the peak of its histogram. Sample a Fréchet distribution:

```wl
In[1]:= samples = RandomReal[FrechetDistribution[2.5, 16.0], {1000000}];

In[2]:= histogram = Last@HistogramList[samples, {0.5, 50.5, 1}]

Out[2]= {0, 0, 0, 0, 0, 77, 1209, 6424, 17542, 31578, 45250, 54333, 59783, 61395, 60353, 56995, 54027, 49116, 44824, 40461, 36653, 32549, 29549, 26222, 23630, 21436, 19231, 17148, 15620, 13849, 12686, 11592, 10520, 9640, 8866, 7956, 7431, 6772, 6127, 5749, 5279, 4931, 4516, 4288, 3908, 3780, 3266, 3101, 2843, 2775}
```

Find the mode of the distribution:

```wl
In[3]:= mode = FindPeaks[histogram, InterpolationOrder -> 2][[1, 1]]

Out[3]= 14.0884

In[4]:=
Histogram[samples, {0.5, 50.5, 1}, Epilog -> {Line[{{mode, 0}, {mode, 1000000}}]}, 
	Axes -> {True, False}
	]

Out[4]= [image]
```

Compare the mode with the theoretical value of the Fréchet distribution:

```wl
In[5]:= x /. FindRoot[Subscript[∂, x]PDF[FrechetDistribution[2.5, 16.0], x], {x, 14}]

Out[5]= 13.9852
```

---

Use peaks of an audio power spectrum to detect pitches of the sound:

```wl
In[1]:= flute = ExampleData[{"Audio", "Flute"}]

Out[1]= \!\(\*AudioBox[...]\)
```

Compute the power periodogram:

```wl
In[2]:= spectrum = Take[PeriodogramArray[flute], 10000];
```

Find peaks of the power spectrum:

```wl
In[3]:= peaks = FindPeaks[spectrum, 8, Automatic, 1, InterpolationOrder -> 2]

Out[3]= {{1383.06, 684.694}, {2762.93, 90.5107}, {4150.11, 47.2721}, {5525.19, 10.276}, {6917.17, 1.20451}}

In[4]:= ListLinePlot[spectrum, PlotRange -> All, Epilog -> {Red, Point[peaks]}]

Out[4]= [image]
```

Converting peak locations into corresponding frequencies:

```wl
In[5]:= min = UnitConvert[Information[flute, "SampleRate"] / Information[flute, "Length"], "Hertz"]

Out[5]= Quantity[2205/5792, "Hertz"]

In[6]:= min peaks[[All, 1]]

Out[6]= {Quantity[526.5270111396827, "Hertz"], Quantity[1051.8393261289273, "Hertz"], Quantity[1579.9364198976843, "Hertz"], Quantity[2103.424526854959, "Hertz"], Quantity[2633.3482983062418, "Hertz"]}
```

## See Also

* [`PeakDetect`](https://reference.wolfram.com/language/ref/PeakDetect.en.md)
* [`FindMaximum`](https://reference.wolfram.com/language/ref/FindMaximum.en.md)
* [`FindArgMax`](https://reference.wolfram.com/language/ref/FindArgMax.en.md)
* [`FindMinimum`](https://reference.wolfram.com/language/ref/FindMinimum.en.md)
* [`MaxDetect`](https://reference.wolfram.com/language/ref/MaxDetect.en.md)
* [`MaximalBy`](https://reference.wolfram.com/language/ref/MaximalBy.en.md)
* [`EstimatedBackground`](https://reference.wolfram.com/language/ref/EstimatedBackground.en.md)
* [`Fourier`](https://reference.wolfram.com/language/ref/Fourier.en.md)
* [`FindAnomalies`](https://reference.wolfram.com/language/ref/FindAnomalies.en.md)

## Related Guides

* [Data Transforms and Smoothing](https://reference.wolfram.com/language/guide/DataTransformsAndSmoothing.en.md)
* [Curve Fitting & Approximate Functions](https://reference.wolfram.com/language/guide/CurveFittingAndApproximateFunctions.en.md)
* [Signal Visualization & Analysis](https://reference.wolfram.com/language/guide/SignalAnalysis.en.md)
* [Feature Detection](https://reference.wolfram.com/language/guide/FeatureDetection.en.md)
* [Statistical Data Analysis](https://reference.wolfram.com/language/guide/Statistics.en.md)
* [Signal Processing](https://reference.wolfram.com/language/guide/SignalProcessing.en.md)

## History

* [Introduced in 2014 (10.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn100.en.md) \| [Updated in 2021 (12.3)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn123.en.md)