예제 #1
0
        public void ShouldCreatePolynomialFromPolyhaseComponents(int[] evenComponentCoefficients, int[] oddComponenetCoefficients,
                                                                 int[] expectedPolynomialCoefficients)
        {
            // Given
            var evenComponent      = new Polynomial(_field, evenComponentCoefficients);
            var oddComponent       = new Polynomial(_field, oddComponenetCoefficients);
            var expectedPolynomial = new Polynomial(_field, expectedPolynomialCoefficients);

            // When
            var actualPolynomial = PolynomialsAlgorithmsExtensions.CreateFormPolyphaseComponents(evenComponent, oddComponent);

            // Then
            Assert.Equal(expectedPolynomial, actualPolynomial);
        }
예제 #2
0
        /// <summary>
        /// Method for building complementary polynomial for polynomial <paramref name="sourceFilter"/> with coefficients count <paramref name="maxFilterLength"/>
        /// </summary>
        /// <param name="sourceFilter">Polynomial for which complementary polynomial should be built</param>
        /// <param name="maxFilterLength">Coefficients count in complementary polynomial</param>
        /// <returns>Built complementary polynomial</returns>
        public Polynomial Build(Polynomial sourceFilter, int maxFilterLength)
        {
            if (sourceFilter == null)
            {
                throw new ArgumentNullException(NameOfExtension.nameof(() => sourceFilter));
            }

            var polythaseComponents = sourceFilter.GetPolyphaseComponents();
            var gcdWithQuotients    = _gcdFinder.GcdWithQuotients(polythaseComponents.Item1, polythaseComponents.Item2);

            if (gcdWithQuotients.Gcd.IsMonomial() == false)
            {
                throw new InvalidOperationException(sourceFilter + " polyphase components is not relatively prime");
            }

            var field = sourceFilter.Field;
            var complementaryFilterEvenComponent = new Polynomial(field);
            var complementaryFilterOddComponent  = field.Pow(field.InverseForAddition(1), gcdWithQuotients.Quotients.Length)
                                                   * InvertGcdInPolynomialsRing(gcdWithQuotients.Gcd, (maxFilterLength + 1) / 2);

            for (var i = gcdWithQuotients.Quotients.Length - 1; i > -1; i--)
            {
                var complementaryFilterEvenComponentOld = complementaryFilterEvenComponent;

                complementaryFilterEvenComponent = gcdWithQuotients.Quotients[i] * complementaryFilterEvenComponentOld
                                                   + complementaryFilterOddComponent;
                complementaryFilterOddComponent = complementaryFilterEvenComponentOld;
            }

            var m = new Polynomial(field, 1).RightShift(maxFilterLength);

            m[0] = field.InverseForAddition(1);
            return(PolynomialsAlgorithmsExtensions.CreateFormPolyphaseComponents(
                       complementaryFilterEvenComponent,
                       complementaryFilterOddComponent
                       ) % m);
        }