C#

public static IEnumerable<Tuple<int, double>> LocalPeakMinMax(IEnumerable<double> source, int windowSize)
{
    if (windowSize < 2) windowSize = 2;
    
    windowSize = windowSize - windowSize % 2 + 1;
    int halfWindow = windowSize / 2;
    int index = 0;
    var before = new Queue<double>(Enumerable.Repeat(double.NegativeInfinity, halfWindow));
    var after = new Queue<double>(source.Take(halfWindow + 1));

    foreach (double d in source.Skip(halfWindow + 1).Concat(Enumerable.Repeat(double.NegativeInfinity, halfWindow + 1)))
    {
        double curVal = after.Dequeue();
        if (before.All(x => curVal > x ) && after.All(x => curVal >= x ))
        {
            yield return Tuple.Create(index, curVal);
        }
        else 
        if (before.All(x => curVal <= x) && after.All(x => curVal < x))
        {
            yield return Tuple.Create(index, curVal);
        }

        before.Dequeue();
        before.Enqueue(curVal);
        after.Enqueue(d);
        index++;
        }
    }

double[] trace =
{
  47.92370605, 44, 49, 46.31715393, 44.98129654, 46.17653275, 78, 73, 82, 63, 69, 41.72979736, 41.13000488,
  41.49586487, 37, 40, 30, 40.79894257, 40.65593719, 41.37298584, 39.13498688, 55, 51, 60, 39.3440094,
  38.51491547, 42, 35.12589264
};
for (int i = 1; i < trace.Length - 1; i++)
{
  double deltaLeft = trace[i - 1];
  double deltaRight = trace[i + 1];

  if (trace[i] - deltaLeft >= 6 && trace[i] - deltaRight >= 6)
  {
    Console.WriteLine($"Peak at {i + 1}");
  }
}

Member 12616185 wrote:

The following data represents a typical trace. Only points 9,11, and 24 are real points that should be returnd.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

Nigel_Davison wrote:

LINQ isn't everything, and by elegant I meant not done with a 100 for/if loops etc.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

Krellon wrote:

It doesn't respect the 6dB peak excursion requirement.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

double[] trace = new double[] { 47.92370605, 44, 49, 46.31715393, 44.98129654, 46.17653275, 78, 73, 82, 63, 69, 41.72979736, 41.13000488, 41.49586487, 37, 40, 30, 40.79894257, 40.65593719, 41.37298584, 39.13498688, 55, 51, 60, 39.3440094, 38.51491547, 42, 35.12589264 };

Krellon wrote:

If I could embed an image into my comment I would show you.

Krellon wrote:

Your essentially looping through an array of points looking for the biggest and smallest peaks and waiting for the delta either side them to go >= 6dB. When it does you grab the biggest peak between the -6dB points. Rinse and repeat.

double lastValue = 44;
List<double> peaks = new List<double>();
for (int i = 0; i < trace.Length; i++)
{
  double currentValue = trace[i];

  // waiting for the delta (so, diff between this and last value?)
  double delta = currentValue - lastValue;

  // either side them to go >= 6dB. (both sides = do for + and -)
  if (Math.Abs(delta) > 6)
  {
    // When it does you grab the biggest peak between the -6dB points. 
    DoMagic();
  }

  // now the current value becomes our "last read value" before looping again
  lastValue = currentValue;
} // Rinse and repeat.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

Krellon wrote:

What this means is that the window could grow dynamically. By setting a physical window width we can limit the max search window +/- either sode of the located peaks.

Krellon wrote:

Thanks again for your time

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

using System;

namespace ConsoleApplication10 {

   class Program {

      static void Main( string[] args ) {

         double[] trace = new double[] {
            47.92370605, 44, 49, 46.31715393, 44.98129654, 46.17653275,
            78, 73, 82, 63, 69, 41.72979736, 41.13000488, 41.49586487,
            37, 40, 30, 40.79894257, 40.65593719, 41.37298584, 39.13498688,
            55, 51, 60, 39.3440094, 38.51491547, 42, 35.12589264 };

         double low = trace[ 0 ];
         double previous = trace[ 0 ];
         double peak = trace[ 0 ];

         for ( int i = 1; i < trace.Length; i++ ) {

            double current = trace[ i ];

            if ( current > previous ) {
               peak = current;
            } else {
               if ( current < previous ) {
                  if ( ( peak - low >= 6.0 ) && ( peak - current >= 6.0 ) ) {
                     Console.WriteLine( $"Peak: {peak} @{i}" );
                     low = peak = current;
                  }
               }
            }

            previous = current;

         }  // end for.

         Console.ReadKey();
      }

   }  // end class.
}