Ejemplo n.º 1
0
        /// <summary>
        /// Uses the signal in vector x to build a model with <c>numberOfCoefficients</c> parameter.
        /// </summary>
        /// <param name="x">Signal for building the model.</param>
        /// <param name="coefficients">Vector to be filled with the coefficients of the model.</param>
        /// <param name="errors">Vector to be filled with the sum of forward and backward prediction error for every stage of the model.</param>
        /// <param name="reflectionCoefficients">Vector to be filled with the reflection coefficients.</param>
        /// <param name="tempStorage">Instance of this class used to hold the temporary arrays.</param>
        /// <returns>The mean square error of backward and forward prediction.</returns>
        private static double Execution(IROComplexDoubleVector x, IComplexDoubleVector coefficients, IVector <double> errors, IComplexDoubleVector reflectionCoefficients, BurgAlgorithmComplex tempStorage)
        {
            int N = x.Length - 1;
            int m = coefficients.Length;

            Complex[] Ak; // Prediction coefficients, Ak[0] is always 1
            Complex[] b;  // backward prediction errors
            Complex[] f;  // forward prediction errors

            if (null != tempStorage)
            {
                tempStorage.EnsureAllocation(x.Length, coefficients.Length);
                Ak = tempStorage._Ak;
                b  = tempStorage._b;
                f  = tempStorage._f;
                for (int i = 1; i <= coefficients.Length; i++)
                {
                    Ak[i] = 0;
                }
            }
            else
            {
                Ak = new Complex[coefficients.Length + 1];
                b  = new Complex[x.Length];
                f  = new Complex[x.Length];
            }

            Ak[0] = 1;

            // Initialize forward and backward prediction errors with x
            for (int i = 0; i <= N; i++)
            {
                f[i] = b[i] = x[i];
            }

            double Dk = 0;

            for (int i = 0; i <= N; i++)
            {
                Dk += 2 * f[i].GetModulusSquared();
            }

            Dk -= f[0].GetModulusSquared() + b[N].GetModulusSquared();

            // Burg recursion
            int    k;
            double sumE = 0; // error sum

            for (k = 0; (k < m) && (Dk > 0); k++)
            {
                // Compute mu
                Complex mu = 0;
                for (int n = 0; n < N - k; n++)
                {
                    mu += f[n + k + 1] * b[n].GetConjugate();
                }

                mu *= (-2 / Dk);

                // Update Ak
                for (int n = 0; n <= (k + 1) / 2; n++)
                {
                    Complex t1 = Ak[n] + mu * Ak[k + 1 - n].GetConjugate();
                    Complex t2 = Ak[k + 1 - n] + mu * Ak[n].GetConjugate();
                    Ak[n]         = t1;
                    Ak[k + 1 - n] = t2;
                }
                if (null != reflectionCoefficients)
                {
                    reflectionCoefficients[k] = Ak[k + 1];
                }

                // update forward and backward predition error with simultaneous total error calculation
                sumE = 0;
                for (int n = 0; n < N - k; n++)
                {
                    Complex t1 = f[n + k + 1] + mu * b[n];
                    Complex t2 = b[n] + mu.GetConjugate() * f[n + k + 1];
                    f[n + k + 1] = t1;
                    b[n]         = t2;
                    sumE        += t1.GetModulusSquared() + t2.GetModulusSquared();
                }
                if (null != errors)
                {
                    errors[k] = sumE / (2 * (N - k));
                }
                // Update Dk
                // Note that it is possible to update Dk without total error calculation because sumE = Dk*(1-mu.GetModulusSquared())
                // but this will render the algorithm numerically unstable especially for higher orders and low noise
                Dk = sumE - (f[k + 1].GetModulusSquared() + b[N - k - 1].GetModulusSquared());
            }

            // Assign coefficients
            for (int i = 0; i < m; i++)
            {
                coefficients[i] = Ak[i + 1];
            }

            // Assign the rest of reflection coefficients and errors with zero
            // if not all stages could be calculated because Dk was zero or because of rounding effects smaller than zero
            for (int i = k + 1; i < m; i++)
            {
                if (null != reflectionCoefficients)
                {
                    reflectionCoefficients[i] = 0;
                }
                if (null != errors)
                {
                    errors[i] = 0;
                }
            }

            return(sumE / (2 * (N - k)));
        }
Ejemplo n.º 2
0
		/// <summary>
		/// Uses the signal in vector x to build a model with <c>numberOfCoefficients</c> parameter.
		/// </summary>
		/// <param name="x">Signal for building the model.</param>
		/// <param name="coefficients">Vector to be filled with the coefficients of the model.</param>
		/// <param name="errors">Vector to be filled with the sum of forward and backward prediction error for every stage of the model.</param>
		/// <param name="reflectionCoefficients">Vector to be filled with the reflection coefficients.</param>
		/// <param name="tempStorage">Instance of this class used to hold the temporary arrays.</param>
		/// <returns>The mean square error of backward and forward prediction.</returns>
		private static double Execution(IROComplexDoubleVector x, IComplexDoubleVector coefficients, IVector errors, IComplexDoubleVector reflectionCoefficients, BurgAlgorithmComplex tempStorage)
		{
			int N = x.Length - 1;
			int m = coefficients.Length;

			Complex[] Ak; // Prediction coefficients, Ak[0] is always 1
			Complex[] b; // backward prediction errors
			Complex[] f; // forward prediction errors

			if (null != tempStorage)
			{
				tempStorage.EnsureAllocation(x.Length, coefficients.Length);
				Ak = tempStorage._Ak;
				b = tempStorage._b;
				f = tempStorage._f;
				for (int i = 1; i <= coefficients.Length; i++)
					Ak[i] = 0;
			}
			else
			{
				Ak = new Complex[coefficients.Length + 1];
				b = new Complex[x.Length];
				f = new Complex[x.Length];
			}

			Ak[0] = 1;

			// Initialize forward and backward prediction errors with x
			for (int i = 0; i <= N; i++)
				f[i] = b[i] = x[i];

			double Dk = 0;

			for (int i = 0; i <= N; i++)
				Dk += 2 * f[i].GetModulusSquared();

			Dk -= f[0].GetModulusSquared() + b[N].GetModulusSquared();

			// Burg recursion
			int k;
			double sumE = 0; // error sum
			for (k = 0; (k < m) && (Dk > 0); k++)
			{
				// Compute mu
				Complex mu = 0;
				for (int n = 0; n < N - k; n++)
					mu += f[n + k + 1] * b[n].GetConjugate();

				mu *= (-2 / Dk);

				// Update Ak
				for (int n = 0; n <= (k + 1) / 2; n++)
				{
					Complex t1 = Ak[n] + mu * Ak[k + 1 - n].GetConjugate();
					Complex t2 = Ak[k + 1 - n] + mu * Ak[n].GetConjugate();
					Ak[n] = t1;
					Ak[k + 1 - n] = t2;
				}
				if (null != reflectionCoefficients)
					reflectionCoefficients[k] = Ak[k + 1];

				// update forward and backward predition error with simultaneous total error calculation
				sumE = 0;
				for (int n = 0; n < N - k; n++)
				{
					Complex t1 = f[n + k + 1] + mu * b[n];
					Complex t2 = b[n] + mu.GetConjugate() * f[n + k + 1];
					f[n + k + 1] = t1;
					b[n] = t2;
					sumE += t1.GetModulusSquared() + t2.GetModulusSquared();
				}
				if (null != errors)
					errors[k] = sumE / (2 * (N - k));
				// Update Dk
				// Note that it is possible to update Dk without total error calculation because sumE = Dk*(1-mu.GetModulusSquared())
				// but this will render the algorithm numerically unstable especially for higher orders and low noise
				Dk = sumE - (f[k + 1].GetModulusSquared() + b[N - k - 1].GetModulusSquared());
			}

			// Assign coefficients
			for (int i = 0; i < m; i++)
				coefficients[i] = Ak[i + 1];

			// Assign the rest of reflection coefficients and errors with zero
			// if not all stages could be calculated because Dk was zero or because of rounding effects smaller than zero
			for (int i = k + 1; i < m; i++)
			{
				if (null != reflectionCoefficients)
					reflectionCoefficients[i] = 0;
				if (null != errors)
					errors[i] = 0;
			}

			return sumE / (2 * (N - k));
		}