tools.cs

心电信号处理库文件

            double[] returnData = new double[data.Length];
            for (int i = 0; i < data.Length - 1; i++)
                returnData[i] = data[i + 1] - data[i];

            returnData[data.Length - 1] = 0;

            return returnData;
        }

        /// <summary>
        /// Make for any value from input field: value = value^exp.
        /// </summary>
        /// <param name="data">intpu data field</param>
        /// <param name="exp"></param>
        /// <returns>Field with the same length.</returns>
        public static double[] pow(double[] data, double exp)
        {
            double[] returnData = new double[data.Length];

            for (int i = 0; i < data.Length; i++)
                returnData[i] = Math.Pow(data[i], exp);

            return returnData;
        }

        /// <summary>
        /// Return int filed with the same length as (double) input field. Output field contains on position [n]
        /// 0 input[x] != num or 1 if input[x] == num.
        /// </summary>
        /// <param name="data">Input field.</param>
        /// <param name="num">test value</param>
        /// <returns>output filed with values: 1 or 0</returns>
        public static int[] equals(double[] data, double num)
        {
            int[] returnData = new int[data.Length];
            
            for (int i = 0; i < data.Length; i++)
            {
                if (data[i] == num)
                    returnData[i] = 1;
                else
                    returnData[i] = 0;
            }

            return returnData;
        }

        /// <summary>
        /// Return int filed with the same length as (double) input field. Output field contains on position [n]
        /// 0 input[x] larger than num or 1 if input[x] lesser or equal to num.
        /// </summary>
        /// <param name="data">Input field.</param>
        /// <param name="num">test value</param>
        /// <returns>output filed with values: 1 or 0</returns>
        public static int[] lesser(double[] data, double num)
        {
            int[] returnData = new int[data.Length];

            for (int i = 0; i < data.Length; i++)
            {
                if (data[i] < num)
                    returnData[i] = 1;
                else
                    returnData[i] = 0;
            }

            return returnData;
        }

        /// <summary>
        /// Return int filed with the same length as (double) input field. Output field contains on position [n]
        /// 0 input[x] larger than num or 1 if input[x] lesser or equal to num.
        /// </summary>
        /// <param name="data">Input field.</param>
        /// <param name="num">test value</param>
        /// <returns>output filed with values: 1 or 0</returns>
        public static int[] larger(double[] data, double num)
        {
            int[] returnData = new int[data.Length];

            for (int i = 0; i < data.Length; i++)
            {
                if (data[i] > num)
                    returnData[i] = 1;
                else
                    returnData[i] = 0;
            }

            return returnData;
        }

        /// <summary>
        /// Return field with values larger than num. The length of field is given by number of
        /// values larger than num.
        /// </summary>
        /// <param name="data">Input field.</param>
        /// <param name="num">Test value.</param>
        /// <returns>Return field with values larger than num.</returns>
        public static double[] returnLarger(double[] data, double num)
        {
            int counter = 0;

            for (int i = 0; i < data.Length; i++)
            {
                if (data[i] > num)
                    counter++;
            }

            double[] returnValue = new double[counter];
            
            counter = 0;
            for (int i = 0; i < data.Length; i++)
            {
                if (data[i] > num)
                {
                    returnValue[counter] = data[i];
                    counter++;
                }
            }

            return returnValue;
        }

        /// <summary>
        /// Return field with the same length as input field. Outpu values are given by
        /// out[n] = data1[n] - data2[n].
        /// </summary>
        /// <param name="data1">data1 form data1[n]-data2[n]</param>
        /// <param name="data2">data2 from data1[n]-data2[n]</param>
        /// <returns></returns>
        /// <remarks>Fields must be the same length!</remarks>
        public static double[] minus(double[] data1, double[] data2)
        {
           //<question>What to do if the field are not the same length.</question>
           double[] returnValue = new double[data1.Length];

           for (int i = 0; i < data1.Length; i++)
                returnValue[i] = data1[i] - data2[i];

                
            //<todo>now this, throw!</todo>
            if (data1.Length != data2.Length)
            {
                Console.WriteLine("Pole nejsou stejne dlouha!");//throw System.Exception.;
                Console.WriteLine("1. vstup: " + data1.Length);
                Console.WriteLine("2. vstup: " + data2.Length);
            }
            return returnValue;
        }
        
        
        /// <summary>
        ///  Return field with length to-from. Values of return filed: 
        ///  out[n] = input[n+from] through input[n+to]
        /// </summary>
        /// <param name="data"></param>
        /// <param name="from"></param>
        /// <param name="to"></param>
        /// <returns></returns>
        public static double[] fromToVector(double[] data, int from, int to)
        {
            if (data != null && from < to && data.Length >= to)
            {
                double[] returnData = new double[to-from];
                int k =0;

                for (int i = from; i < to; i++)
                {
                    returnData[k] = data[i];
                    k++;
                }

                return returnData;
            }

            return null;
        }

        /// <summary>
        /// Return field with the same length as input field. Outpu values are given by
        /// out[n] = data1[n] - data2
        /// </summary>
        /// <param name="data1">data1 form data1[n]-data2</param>
        /// <param name="data2">data2 from data1[n]-data2</param>
        /// <returns></returns>
        public static double[] minus(double[] data1, double data2)
        {
            double[] returnValue = new double[data1.Length];

            for (int i = 0; i < data1.Length; i++)
                returnValue[i] = data1[i] - data2;

            return returnValue;
        }

        /// <summary>
        /// Return field with the same length as input field. Outpu values are given by
        /// out[n] = data1[n] - data2
        /// </summary>
        /// <param name="data1">data1 form data1[n]-data2</param>
        /// <param name="data2">data2 from data1[n]-data2</param>
        /// <returns></returns>
        public static double[] minus(int[] data1, int data2)
        {
            double[] returnValue = new double[data1.Length];

            for (int i = 0; i < data1.Length; i++)
                returnValue[i] = data1[i] - data2;

            return returnValue;
        }

        /// <summary>
        /// New double field with length filled with number given by number.
        /// </summary>
        /// <param name="length">Output field length.</param>
        /// <param name="number"></param>
        /// <returns></returns>
        public static double[] vector(int length, double number)
        {
            double[] returnValue = new double[length];

            for (int i = 0; i < returnValue.Length; i++)
                returnValue[i] = number;

            return returnValue;
        }

        /// <summary>
        /// Return field with the same length as input field. Outpu values are given by
        /// out[n] = data[n]/divider[n]
        /// </summary>
        /// <param name="data">data form data[n]/divider[n]</param>
        /// <param name="divider">divider from data[n]/divider[n]</param>
        /// <returns></returns>
        public static double[] divide(double[] data, double[] divider)
        {
            double[] returnValue = new double[data.Length];

            for (int i = 0; i < returnValue.Length; i++)
                returnValue[i] = data[i] / divider[i];

            return returnValue;
        }

        /// <summary>
        /// Return field with the same length as input field. Outpu values are given by
        /// out[n] = data[n]/divider
        /// </summary>
        /// <param name="data">data form data[n]/divider</param>
        /// <param name="divider">divider from data[n]/divider</param>
        /// <returns></returns>
        public static double[] divide(double[] data, double divider)
        {
            double[] returnValue = new double[data.Length];

            for (int i = 0; i < returnValue.Length; i++)
                returnValue[i] = data[i] / divider;

            return returnValue;
        }

        /// <summary>
        /// Return field with the same length as input field. Outpu values are given by
        /// out[n] = data[n]*multiplier
        /// </summary>
        /// <param name="data">data form data[n]*multiplier</param>
        /// <param name="multiplier">multiplier from data[n]*multiplier</param>
        /// <returns></returns>
        public static double[] mult(double[] data, double multiplier)
        {
            double[] returnValue = new double[data.Length];

            for (int i = 0; i < returnValue.Length; i++)
                returnValue[i] = data[i] * multiplier;

            return returnValue;
        }

        /// <summary>
        /// Return field with the same length as input field. Outpu values are given by
        /// out[n] = data[n]*multiplier[n]
        /// </summary>
        /// <param name="data">dataa form data[n]*multiplier[n]</param>
        /// <param name="multiplier">multiplier from data[n]*multiplier[n]</param>
        /// <returns></returns>
        public static double[] mult(double[] data, double[] multiplier)
        {
            double[] returnValue = new double[data.Length];

            for (int i = 0; i < returnValue.Length; i++)
                returnValue[i] = data[i] * multiplier[i];

            return returnValue;
        }

        /// <summary>
        /// Return field with the same length as input field. Outpu values are given by
        /// out[n] = data[n]+addend[n]
        /// </summary>
        /// <param name="data">data form data[n]+addend[n]</param>
        /// <param name="addend">addend from data[n]+addend[n]</param>
        /// <returns></returns>
        public static double[] add(double[] data, double addend)
        {
            double[] returnValue = new double[data.Length];

            for (int i = 0; i < returnValue.Length; i++)
                returnValue[i] = data[i] + addend;

            return returnValue;
        }

        /// <summary>
        /// Return field with the same length as input field. Outpu values are given by
        /// out[n] = 1/data[n]
        /// </summary>
        /// <param name="data">data form 1/data[n]</param>
        /// <returns></returns>
        public static double[] reciprocal(double[] data)
        {
            double[] returnData = new double[data.Length];
            for (int i = 0; i < data.Length; i++)
                returnData[i] = 1 / data[i];

            return returnData;
        }

        /// <summary>
        /// Return max value from a, b.
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns>Max value.</returns>
        public static double max(double a, double b)
        {
            if (a > b)
                return a;
            else
                return b;
        }

        /// <summary>
        /// Return int field contains positions (n) where: data[n] == value.
        /// </summary>
        /// <param name="data">input double field</param>
        /// <param name="value">test value</param>
        /// <returns></returns>
        public static int[] find(double[] data, int value)
        {
            List<int> where = new List<int>();

            for(int i = 0; i<data.Length; i++)
            {
                if(data[i] == value)
                    where.Add(i);
            }

            int[] returnDouble = new int[where.Count];
            for (int i = 0; i < returnDouble.Length; i++)
                returnDouble[i] = where[i];

            return returnDouble;
        }

        /// <summary>
        /// Set double field to zeros.
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static double[] setToZero(double[] data)
        {
            double[] returnValue = new double[data.Length];

            for (int i = 0; i < returnValue.Length; i++)
                returnValue[i] = 0;

            return returnValue;
        }

        /// <summary>
        /// Return double 2D with locations and values of local maxims that
        /// are larger than treshold 
        /// return 2D field: [indexs, values]
        /// </summary>
        /// <param name="data"></param>
        /// <param name="treshold">treshold</param>
        /// <returns>2D field: [indexs, values]</returns>
        public static double[,] localMaxims(double[] data, double treshold)
        {
            int peak = 0;
            List<int> intervals = new List<int>();