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);
}
