public IPolynomialCoefficients Transform(IPolesCoefficients polesCoefficients) { var complexB = polesCoefficients.Z.PolynomialCoefficients().Multiply(polesCoefficients.K); var complexA = polesCoefficients.P.PolynomialCoefficients(); return(this.polynomialCoefficientsFactory.Build(complexA.Select(x => x.Real).ToList(), complexB.Select(x => x.Real).ToList())); }
internal void GetDigitalPoles_ReturnsTheResultsOfTheDigitalTransformer_Test( [Frozen] Mock <ITransformer> transformer, [Frozen] Mock <IDigitalTransformer> digitalTransformer, IPolesCoefficients transformedCoefficients, IPolesCoefficients expectedCoefficients, IAnalog analog, double cutoff, double sampleRate, DigitalPolesProvider digitalPolesProvider) { transformer.Setup(mock => mock.Transform(analog, It.IsAny <double>())).Returns(transformedCoefficients); digitalTransformer.Setup(mock => mock.Transform(transformedCoefficients, It.IsAny <double>())) .Returns(expectedCoefficients); Assert.Equal(expectedCoefficients, digitalPolesProvider.GetDigitalPoles(analog, cutoff, sampleRate)); }
internal void GetDigitalPoles_CorrectlyCallsTheDigitalTransformer_Test( [Frozen] Mock <ITransformer> transformer, [Frozen] Mock <IDigitalTransformer> digitalTransformer, IPolesCoefficients polesCoefficients, IAnalog analog, double cutoff, double sampleRate, DigitalPolesProvider digitalPolesProvider) { transformer.Setup(mock => mock.Transform(analog, It.IsAny <double>())).Returns(polesCoefficients); digitalPolesProvider.GetDigitalPoles(analog, cutoff, sampleRate); digitalTransformer.Verify(mock => mock.Transform(polesCoefficients, sampleRate * 2.0d), Times.Once); }
internal void GetIirCoefficients_CorrectlyCallsThePolynomialTransformer_Test( [Frozen] Mock <IDigitalPolesProvider> digitialPolesProvider, [Frozen] Mock <IPolynomialTransformer> polynomialTransformer, IPolesCoefficients polesCoefficients, IAnalog analog, double cutoff, IirProvider iirProvider) { digitialPolesProvider.Setup(mock => mock.GetDigitalPoles(analog, cutoff, 2.0d)).Returns(polesCoefficients); iirProvider.GetIirCoefficients(analog, cutoff); polynomialTransformer.Verify(mock => mock.Transform(polesCoefficients), Times.Once); }
internal void Transform_CorrectlyCalculatesTheACoefficient_Test( [Frozen] Mock <IPolynomialCoefficientsFactory> polynomialCoefficientsFactory, IPolesCoefficients polesCoefficients, PolynomialTransformer polynomialTransformer) { var expected = polesCoefficients.P.PolynomialCoefficients().Select(x => x.Real).ToList(); polynomialTransformer.Transform(polesCoefficients); polynomialCoefficientsFactory.Verify(mock => mock.Build(expected, It.IsAny <IReadOnlyList <double> >()), Times.Once); }
internal void Transform_CorrectlyTransformsThePCoefficient_Test( [Frozen] Mock <IPolesCoefficientsFactory> polesCoefficientsFactory, IPolesCoefficients polesCoefficients, double sampleRate, DigitalTransformer digitalTransformer) { var expectedP = polesCoefficients.P.Add(sampleRate).Divide(sampleRate.Subtract(polesCoefficients.Z)).ToList(); digitalTransformer.Transform(polesCoefficients, sampleRate); polesCoefficientsFactory.Verify( mock => mock.Build(It.IsAny <double>(), expectedP, It.IsAny <IReadOnlyList <Complex> >()), Times.Once); }
internal void CalculateAnalog_SetsTheCoefficientsPropertyToTheBuiltCoefficients_Test( int order, [Frozen] Mock <IPolesCoefficientsFactory> polesCoefficientsFactory, IPolesCoefficients polesCoefficients, ButterworthAnalog butterworthAnalog) { polesCoefficientsFactory.Setup( mock => mock.Build(It.IsAny <double>(), It.IsAny <IReadOnlyList <Complex> >(), It.IsAny <IReadOnlyList <Complex> >())).Returns(polesCoefficients); butterworthAnalog.CalculateAnalog(order); Assert.Equal(polesCoefficients, butterworthAnalog.Coefficients); }
internal void GetIirCoefficients_CorrectlyReturnsTheValueOfThePolynomialTransformer_Test( [Frozen] Mock <IDigitalPolesProvider> digitialPolesProvider, [Frozen] Mock <IPolynomialTransformer> polynomialTransformer, IPolesCoefficients polesCoefficients, IPolynomialCoefficients polynomialCoefficients, IAnalog analog, double cutoff, IirProvider iirProvider) { digitialPolesProvider.Setup(mock => mock.GetDigitalPoles(analog, cutoff, 2.0d)).Returns(polesCoefficients); polynomialTransformer.Setup(mock => mock.Transform(polesCoefficients)).Returns(polynomialCoefficients); var actual = iirProvider.GetIirCoefficients(analog, cutoff); Assert.Equal(polynomialCoefficients, actual); }
internal void Transform_CorrectlyReturnsTheResultOfThePolynomialFactory_Test( [Frozen] Mock <IPolynomialCoefficientsFactory> polynomialCoefficientsFactory, IPolesCoefficients polesCoefficients, IPolynomialCoefficients expected, PolynomialTransformer polynomialTransformer) { polynomialCoefficientsFactory.Setup( mock => mock.Build(It.IsAny <IReadOnlyList <double> >(), It.IsAny <IReadOnlyList <double> >())) .Returns(expected); var actual = polynomialTransformer.Transform(polesCoefficients); Assert.Equal(expected, actual); }
internal void Transform_ReturnsTheResultOfThePolesFactory_Test( [Frozen] Mock <IPolesCoefficientsFactory> polesCoefficientsFactory, IAnalog analog, double cutoff, IPolesCoefficients expected, LowPassTransformer lowPassTransformer) { polesCoefficientsFactory.Setup( mock => mock.Build(It.IsAny <double>(), It.IsAny <IReadOnlyList <Complex> >(), It.IsAny <IReadOnlyList <Complex> >())).Returns(expected); var actual = lowPassTransformer.Transform(analog, cutoff); Assert.Equal(expected, actual); }
internal void Transform_CorrectlyReturnsTheResultOfThePolesFactory_Test( [Frozen] Mock <IPolesCoefficientsFactory> polesCoefficientsFactory, IPolesCoefficients polesCoefficients, IPolesCoefficients expectedCoefficients, double sampleRate, DigitalTransformer digitalTransformer) { polesCoefficientsFactory.Setup( mock => mock.Build(It.IsAny <double>(), It.IsAny <IReadOnlyList <Complex> >(), It.IsAny <IReadOnlyList <Complex> >())).Returns(expectedCoefficients); var actual = digitalTransformer.Transform(polesCoefficients, sampleRate); Assert.Equal(expectedCoefficients, actual); }
internal void Transform_CorrectlyTransformsThePCoefficient_Test( [Frozen] Mock <IPolesCoefficientsFactory> polesCoefficientsFactory, Mock <IAnalog> analog, IPolesCoefficients polesCoefficients, double cutoff, LowPassTransformer lowPassTransformer) { var expected = polesCoefficients.P.Multiply(cutoff).ToList(); analog.SetupGet(mock => mock.Coefficients).Returns(polesCoefficients); lowPassTransformer.Transform(analog.Object, cutoff); polesCoefficientsFactory.Verify( mock => mock.Build(It.IsAny <double>(), expected, It.IsAny <IReadOnlyList <Complex> >()), Times.Once); }
internal void Transform_CorrectlyTransformsTheKCoefficient_Test( [Frozen] Mock <IPolesCoefficientsFactory> polesCoefficientsFactory, IPolesCoefficients polesCoefficients, double sampleRate, DigitalTransformer digitalTransformer) { var expectedK = polesCoefficients.K * (sampleRate.Subtract(polesCoefficients.Z).Product() / sampleRate.Subtract(polesCoefficients.P).Product()); digitalTransformer.Transform(polesCoefficients, sampleRate); polesCoefficientsFactory.Verify( mock => mock.Build(expectedK.Real, It.IsAny <IReadOnlyList <Complex> >(), It.IsAny <IReadOnlyList <Complex> >()), Times.Once); }
internal void Transform_CorrectlTransformsTheKCoefficient_Test( [Frozen] Mock <IPolesCoefficientsFactory> polesCoefficientsFactory, Mock <IAnalog> analog, IPolesCoefficients polesCoefficients, double cutoff, HighpassTransformer highpassTransformer) { var expected = polesCoefficients.K * (polesCoefficients.Z.Negative().Product() / polesCoefficients.P.Negative().Product()); analog.SetupGet(mock => mock.Coefficients).Returns(polesCoefficients); highpassTransformer.Transform(analog.Object, cutoff); polesCoefficientsFactory.Verify( mock => mock.Build(expected.Real, It.IsAny <IReadOnlyList <Complex> >(), It.IsAny <IReadOnlyList <Complex> >()), Times.Once); }
public void CalculateAnalog(int order) { if (order < 1) { throw new ArgumentOutOfRangeException(nameof(order), @"Order must be greater than 0."); } var z = new List <Complex>(); var p = new List <Complex>(); var start = -order + 1; for (var i = 0; i < order; i++, start += 2) { p.Add(-Complex.Exp(new Complex(0.0d, 1.0d) * PI * start / (2 * order))); } this.Coefficients = this.polesCoefficientsFactory.Build(1.0d, p, z); }
public IPolesCoefficients Transform(IPolesCoefficients polesCoefficients, double sampleRate) { var degree = polesCoefficients.P.Count - polesCoefficients.Z.Count; var zZ = polesCoefficients.Z.Add(sampleRate).Divide(sampleRate.Subtract(polesCoefficients.Z)); var pZ = polesCoefficients.P.Add(sampleRate).Divide(sampleRate.Subtract(polesCoefficients.P)); var z = new List <Complex>(zZ); for (var i = 0; i < degree; i++) { z.Add(-1.0d); } var kZ = polesCoefficients.K * (sampleRate.Subtract(polesCoefficients.Z).Product() / sampleRate.Subtract(polesCoefficients.P).Product()); return(this.polesCoefficientsFactory.Build(kZ.Real, pZ.ToList(), z)); }
internal void Transform_CorrectlyTransformsTheZCoefficient_Test( [Frozen] Mock <IPolesCoefficientsFactory> polesCoefficientFactory, IPolesCoefficients polesCoefficients, double sampleRate, DigitalTransformer digitalTransformer) { var degree = polesCoefficients.P.Count - polesCoefficients.Z.Count; var expectedZ = polesCoefficients.Z.Add(sampleRate).Divide(sampleRate.Subtract(polesCoefficients.Z)); var expected = new List <Complex>(expectedZ); for (var i = 0; i < degree; i++) { expected.Add(-1.0d); } digitalTransformer.Transform(polesCoefficients, sampleRate); polesCoefficientFactory.Verify( mock => mock.Build(It.IsAny <double>(), It.IsAny <IReadOnlyList <Complex> >(), expected), Times.Once); }
internal void Transform_CorrectlyTransformsTheZCoefficient_Test( [Frozen] Mock <IPolesCoefficientsFactory> polesCoefficientsFactory, Mock <IAnalog> analog, IPolesCoefficients polesCoefficients, double cutoff, HighpassTransformer highpassTransformer) { var degree = polesCoefficients.P.Count - polesCoefficients.Z.Count; var z = polesCoefficients.Z.RhsDivide(cutoff).ToList(); var expected = new List <Complex>(z); for (var i = 0; i < degree; i++) { expected.Add(0.0d); } analog.SetupGet(mock => mock.Coefficients).Returns(polesCoefficients); highpassTransformer.Transform(analog.Object, cutoff); polesCoefficientsFactory.Verify( mock => mock.Build(It.IsAny <double>(), It.IsAny <IReadOnlyList <Complex> >(), expected), Times.Once); }