wsArray

using System;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;

namespace wsControls
{
    public class wsArray
    {
        #region [ Static ] GetFrequency, GetChanPower, PeakSearch, SortTrace ... To Verify
        public static decimal[] ApplyFrequency(decimal start, decimal stop, int nop)
        {
            decimal[] frequency = new decimal[nop];
            decimal span = stop - start;
            int interval = nop - 1;
            for (int i = 0; i < nop; i++)
                frequency[i] = start + i * span / interval;
            return frequency;
        }

        public static decimal GetValue(decimal start, decimal stop, decimal nop, decimal index)
        {
            decimal span = stop - start;
            return start + span * index / (nop - 1);
        }

        public static decimal GetValue(decimal[] array, decimal index)
        {
            return array[0] + (array[array.Length - 1] - array[0]) * index / (array.Length - 1);
        }

        public static decimal GetIndex(decimal start, decimal stop, int nop, decimal frequency)
        {
            decimal span = stop - start;
            return (frequency - start) * (nop - 1) / span;
        }

        public static decimal GetIndex(decimal[] array, decimal frequency)
        {
            return (frequency - array[0]) * (array.Length - 1) / (array[array.Length - 1] - array[0]);
        }

        public static double GetChanPower(decimal[] trace, int startindex, int stopindex)
        {
            double p = 0D;
            for (int i = startindex; i <= stopindex; i++)
            {
                p += Math.Pow(10D, (double)trace[i] / 10D);
            }

            return p < Math.Pow(10D, -17) ? -175 : 10 * Math.Log10(p);
        }

        public static decimal GetFlatnesss(decimal[] trace, int istart, int istop)
        {
            decimal max = trace[istart]; decimal min = trace[istart];
            for (int i = istart+1; i <= istop; i++)
            {
                if (trace[i] > max)
                {
                    max = trace[i];
                    continue;
                }
                if (trace[i] < min)
                    min = trace[i];
            }
            return max - min;
        }

        public static double GetChanPower(decimal[] trace, decimal span, decimal bandwidth)
        {
            decimal N = bandwidth * (trace.Length - 1) / span;
            N = N / 2;
            decimal istart = (trace.Length - 1) / 2 - N;
            decimal istop = (trace.Length - 1) / 2 + N;

            return GetChanPower(trace, (int)istart, istop - (int)istop > 0 ? (int)istop + 1 : (int)istop);
        }

        public static int[] SortMinMax(decimal[] trace)
        {//From Min to Max
            int[] index = new int[trace.Length];
            for (int i = 0; i < index.Length; i++)
                index[i] = i;

            decimal[] sort = (decimal[])trace.Clone();
            Array.Sort(sort, index, 0, index.Length);//from 0 -> N
            //Array.Reverse(index);
            return index;
        }

        public static int[] SortMinMax(Collection<decimal> trace)
        {//From Min to Max
            int[] index = new int[trace.Count];
            for (int i = 0; i < index.Length; i++)
                index[i] = i;

            decimal[] sort = (decimal[])trace.ToArray();
            Array.Sort(sort, index, 0, index.Length);//from 0 -> N
            //Array.Reverse(index);
            return index;
        }

        public static int[] SortMaxMin(decimal[] trace)
        {
            int[] index = SortMinMax(trace);
            Array.Reverse(index);
            return index;
        }

        public static decimal GetPeak(decimal[] trace, int istart, int istop)
        {
            decimal max = decimal.MinValue; 
            for (int i = istart; i <= istop; i++)
            {
                if (trace[i] > max)                
                    max = trace[i];                               
            }
            return max;
        }

        public static int[] GetPeakIndex(decimal[] trace, int npeaks)
        {
            int[] peakindex = new int[npeaks];

            int[] sortindex = SortMinMax(trace);
            int n = 0;


            int candidateindex;
            for (int i = sortindex.Length - 1; i >= 0 && n < npeaks; i--)
            {
                candidateindex = sortindex[i];//peak index, n starts from 0
                if (candidateindex == 0 )
                {
                    if (trace[candidateindex] >= trace[candidateindex + 1])
                    {
                        peakindex[n] = candidateindex;
                        n++;
                    }
                    continue;
                }
                else if (candidateindex == sortindex.Length - 1 )
                {
                    if (trace[candidateindex] >= trace[candidateindex - 1])
                    {
                        peakindex[n] = candidateindex;
                        n++;
                    }
                    continue;
                }
                else if (trace[candidateindex] >= trace[candidateindex - 1] && trace[candidateindex] >= trace[candidateindex + 1])
                {
                    peakindex[n] = candidateindex;
                    n++;
                    continue;
                }
            }
            return peakindex;
        }

        public static int[] GetPeakIndex(Collection<decimal> trace, int npeaks)
        {
            int[] peakindex = new int[npeaks];

            int[] sortindex = SortMinMax(trace);
            int n = 0;


            int candidateindex;
            for (int i = sortindex.Length - 1; i >= 0 && n < npeaks; i--)
            {
                candidateindex = sortindex[i];//peak index, n starts from 0
                if (candidateindex == 0)
                {
                    if (trace[candidateindex] >= trace[candidateindex + 1])
                    {
                        peakindex[n] = candidateindex;
                        n++;
                    }
                    continue;
                }
                else if (candidateindex == sortindex.Length - 1)
                {
                    if (trace[candidateindex] >= trace[candidateindex - 1])
                    {
                        peakindex[n] = candidateindex;
                        n++;
                    }
                    continue;
                }
                else if (trace[candidateindex] >= trace[candidateindex - 1] && trace[candidateindex] >= trace[candidateindex + 1])
                {
                    peakindex[n] = candidateindex;
                    n++;
                    continue;
                }
            }
            return peakindex;
        }
        #endregion
    }
}