/// <summary>
/// Initializes a new instance of the CSVD class,
/// computing the Singular Value Decomposition of a general complex matrix,
/// with the possibility of computing only the singular values.
/// </summary>
/// <param name="matrix">A general complex matrix.</param>
/// <param name="singularValuesOnly">A value that indicating whether only the singular values will be computed.</param>
public CSVD(CMatrix matrix, bool singularValuesOnly)
{
_m = matrix.RowCount;
_n = matrix.ColumnCount;
var nm = Math.Min(matrix.RowCount, matrix.ColumnCount);
var s = new Complex[nm];
var u = new Complex[matrix.RowCount * matrix.RowCount];
var vt = new Complex[matrix.ColumnCount * matrix.ColumnCount];
new ManagedLinearAlgebraProvider().SingularValueDecomposition(!singularValuesOnly, matrix.To1DimArray(), matrix.RowCount, matrix.ColumnCount, s, u, vt);
_s = s.ToArray().Select(x => x.Re).ToArray();
_u = new CMatrix(matrix.RowCount, matrix.RowCount);
for (int i = 0; i < matrix.RowCount; i++)
{
for (int j = 0; j < matrix.RowCount; j++)
{
_u[i, j] = u[j * matrix.RowCount + i];
}
}
_vt = new CMatrix(matrix.ColumnCount, matrix.ColumnCount);
for (int i = 0; i < matrix.ColumnCount; i++)
{
for (int j = 0; j < matrix.ColumnCount; j++)
{
_vt[i, j] = vt[j * matrix.ColumnCount + i];
}
}
}
/// <summary>
/// Sends audio samples read from a file.
/// </summary>
private void SendMusicSample(object state)
{
lock (_audioStreamReader)
{
int sampleSize = (SDPMediaFormatInfo.GetClockRate(_sendingAudioFormat.FormatCodec) / 1000) * AUDIO_SAMPLE_PERIOD_MILLISECONDS;
byte[] sample = new byte[sampleSize];
int bytesRead = _audioStreamReader.BaseStream.Read(sample, 0, sample.Length);
if (bytesRead == 0 || _audioStreamReader.EndOfStream)
{
_audioStreamReader.BaseStream.Position = 0;
bytesRead = _audioStreamReader.BaseStream.Read(sample, 0, sample.Length);
}
SendAudioFrame((uint)bytesRead, Convert.ToInt32(_sendingAudioFormat.FormatID), sample.Take(bytesRead).ToArray());
#region On hold audio scope.
if (OnHoldAudioScopeSampleReady != null)
{
Complex[] ieeeSamples = new Complex[sample.Length];
for (int index = 0; index < sample.Length; index++)
{
short pcm = NAudio.Codecs.MuLawDecoder.MuLawToLinearSample(sample[index]);
byte[] pcmSample = new byte[] { (byte)(pcm & 0xFF), (byte)(pcm >> 8) };
ieeeSamples[index] = pcm / 32768f;
}
OnHoldAudioScopeSampleReady(ieeeSamples.ToArray());
}
#endregion
}
}
public void zdscale_ExtendedTestCaseData(double a)
{
int n = 3;
int startX = 1;
int increment = 2;
var x = new Complex[] { 1, 2, 3, 4 - 5.9 * Complex.ImaginaryOne, 5, 6 + Complex.ImaginaryOne };
Complex[] actual = x.ToArray();
m_Level1BLAS.zdscal(n, a, actual, increment, startX);
Complex[] expected = x.ToArray();
m_BenchmarkLevel1BLAS.zdscal(n, a, expected, increment, startX);
Assert.That(actual, new ComplexArrayNUnitConstraint(expected, tolerance: 1E-9));
}
public static IComplexPolynomial Add(IComplexPolynomial left, IComplexPolynomial right)
{
if (left == null)
{
throw new ArgumentNullException(nameof(left));
}
if (right == null)
{
throw new ArgumentNullException(nameof(right));
}
Complex[] terms = new Complex[Math.Max(left.Degree, right.Degree) + 1];
for (int i = 0; i < terms.Length; i++)
{
Complex l = left[i];
Complex r = right[i];
Complex ttl = (l + r);
terms[i] = ttl;
}
IComplexPolynomial result = new ComplexPolynomial(ComplexTerm.GetTerms(terms.ToArray()));
return(result);
}
private void GetMusicSample(object state)
{
byte[] sample = new byte[BUFFER_SIZE];
int bytesRead = _audioStreamReader.BaseStream.Read(sample, 0, sample.Length);
if (bytesRead == 0 || _audioStreamReader.EndOfStream)
{
_audioStreamReader.BaseStream.Position = 0;
bytesRead = _audioStreamReader.BaseStream.Read(sample, 0, sample.Length);
}
if (sample.Length > 0)
{
Complex[] ieeeSamples = new Complex[sample.Length];
for (int index = 0; index < sample.Length; index++)
{
short pcm = NAudio.Codecs.MuLawDecoder.MuLawToLinearSample(sample[index]);
byte[] pcmSample = new byte[] { (byte)(pcm & 0xFF), (byte)(pcm >> 8) };
ieeeSamples[index] = pcm / 32768f;
}
ProcessSample(ieeeSamples.ToArray());
}
}
/// <summary>
/// Calculate scalar values
/// </summary>
/// <param name="n0">Array size</param>
/// <param name="n1">Array size</param>
/// <param name="n2">Array size</param>
/// <param name="f">Input values</param>
/// <param name="g">Input values</param>
/// <param name="fg">Output values</param>
public static void Scalar(int n0, int n1, int n2, Complex[] f, Complex[] g, Complex[] fg)
{
Debug.Assert(fg.Length == n0*n1*n2);
Debug.Assert(f.Length == fg.Length);
Debug.Assert(g.Length == fg.Length);
var length = fg.Length;
var complex = f.ToArray();
Fourier(n0, n1, n2, complex, FourierDirection.Forward);
var complex1 = g.ToArray();
Fourier(n0, n1, n2, complex1, FourierDirection.Backward);
var index = 0;
foreach (var value in complex1)
complex[index++] *= value/length;
Fourier(n0, n1, n2, complex, FourierDirection.Backward);
Array.Copy(complex, 0, fg, 0, length);
}
/// <summary>
/// Calculate convolution values
/// </summary>
/// <param name="n0">Array size</param>
/// <param name="n1">Array size</param>
/// <param name="n2">Array size</param>
/// <param name="f">Input values</param>
/// <param name="g">Input values</param>
/// <param name="fxg">Output values</param>
public static void Convolution(int n0, int n1, int n2, Complex[] f, Complex[] g, Complex[] fxg)
{
Debug.Assert(fxg.Length == n0*n1*n2);
Debug.Assert(f.Length == fxg.Length);
Debug.Assert(g.Length == fxg.Length);
int length = fxg.Length;
Complex[] complex = f.ToArray();
Fourier(n0, n1, n2, complex, FourierDirection.Forward);
Complex[] complex1 = g.ToArray();
Fourier(n0, n1, n2, complex1, FourierDirection.Forward);
int index = 0;
foreach (Complex value in complex1)
complex[index++] *= value/length;
Fourier(n0, n1, n2, complex, FourierDirection.Backward);
Array.Copy(complex, 0, fxg, 0, length);
}
public void Creation()
{
const double fd = 0.5; // Гц // Частота дискретизации
const double dt = 1 / fd; // 2с // Период дискретизации
const double fp = 0.05; // Гц // Граничная частота полосы пропускания
const double fs = 0.15; // Гц // Граничная частота полосы запирания
Assert.IsTrue(fp < fs);
Assert.IsTrue(fp < fd / 2);
//const double wp = Consts.pi2 * fp * dt; // 0.628318530717959 рад/с
//const double ws = Consts.pi2 * fs * dt; // 1.884955592153876 рад/с
const double Rp = 1; // Неравномерность в полосе пропускания (дБ)
const double Rs = 30; // Неравномерность в полосе пропускания (дБ)
var eps_p = (10d.Pow(Rp / 10) - 1).Sqrt();
var eps_s = (10d.Pow(Rs / 10) - 1).Sqrt();
Assert.That.Value(eps_p).IsEqual(0.50884713990958752);
Assert.That.Value(eps_s).IsEqual(31.606961258558215);
var Gp = (-Rp).From_dB();
var Gs = (-Rs).From_dB();
Assert.That.Value(Gp).IsEqual(0.89125093813374556);
Assert.That.Value(Gs).IsEqual(0.031622776601683791);
Assert.That.Value(Gp.In_dB()).IsEqual(-1, 4.67e-15);
Assert.That.Value(Gs.In_dB()).IsEqual(-30);
var Fp = DigitalFilter.ToAnalogFrequency(fp, dt); // Частота пропускания аналогового прототипа
var Fs = DigitalFilter.ToAnalogFrequency(fs, dt); // Частота подавления аналогового прототипа
Assert.That.Value(Fp).IsEqual(0.051712575763384123);
Assert.That.Value(Fs).IsEqual(0.2190579862253032);
var Wp = Consts.pi2 * Fp;
var Ws = Consts.pi2 * Fs;
var k_eps = eps_s / eps_p;
var k_W = Ws / Wp;
Assert.That.Value(k_eps).GreaterThan(0);
Assert.That.Value(k_W).GreaterThan(0);
var double_n = Log(k_eps) / Log(k_W);
// Порядок фильтра
var N = (int)double_n;
if (double_n - N > 0)
{
N += 1;
}
Assert.That.Value(N).IsEqual(3);
var L = N / 2;
var r = N % 2;
Assert.That.Value(L).IsEqual(1);
Assert.That.Value(r).IsEqual(1);
Assert.That.Value(2 * L + r).IsEqual(N);
var alpha = eps_p.Pow(-1d / N);
Assert.That.Value(alpha).IsEqual(1.2525763881810263);
var th0 = PI / N;
var poles = new Complex[N];
if (r != 0)
{
poles[0] = -alpha;
}
for (var i = r; i < poles.Length; i += 2)
{
var w = th0 * (i + 1 - r - 0.5);
poles[i] = (-alpha * Sin(w), alpha *Cos(w));
poles[i + 1] = poles[i].ComplexConjugate;
}
Assert.That.Collection(poles).IsEqualTo(
-1.2525763881810263,
(-0.62628819409051306, 1.0847629723453271),
(-0.62628819409051306, -1.0847629723453271)
);
var translated_poles = poles.ToArray(p => p * Wp)
.AssertThatCollection()
.IsEqualTo(
-0.40698673955629,
(-0.20349336977814494, 0.35246085545914824),
(-0.20349336977814494, -0.35246085545914824))
.ActualValue;
var z_poles = translated_poles.ToArray(p => DigitalFilter.ToZ(p, dt))
.AssertThatCollection()
.IsEqualTo(
0.42147750491999925,
(0.53055357928176117, 0.44824528113449957),
(0.53055357928176117, -0.44824528113449957))
.AllItems(z_pole => z_pole.Where(z => z.Abs < 1))
.ActualValue;
var kz = DigitalFilter.GetNormalizeCoefficient(translated_poles, dt)
.AssertThanValue()
.IsEqual(0.45194421873401691)
.ActualValue;
var WpN = Wp.Pow(N)
.AssertThanValue()
.IsEqual(0.034302685030761955)
.ActualValue;
var k = WpN * kz / eps_p;
Assert.That.Value(k).IsEqual(0.030466713814017582);
var b = Range(0, N + 1).ToArray(i => k * BinomialCoefficient(N, i));
Assert.That.Collection(b).IsEqualTo(new[]
{
1 * k,
3 * k,
3 * k,
1 * k
});
var a_complex = Polynom.Array.GetCoefficientsInverted((Complex[])z_poles);
Assert.That.Collection(a_complex)
.CountEquals(4)
.AllItems(a_value => a_value.Where(z => z.Im).IsEqual(0, 1e-16));
var a = a_complex.ToRe() ?? throw new AssertFailedException("Отсутствует ссылка на массив вещественных значений");
Assert.That.Collection(a).ValuesAreEqual(
1,
-1.4825846634835216,
0.92964373019213786,
-0.20332535619647568
);
var filter = new DSP.Filters.ButterworthLowPass(dt, fp, fs, Gp, Gs);
Assert.That.Collection(filter.A).IsEqualTo(a, 1e-15);
Assert.That.Collection(filter.B).IsEqualTo(b, 1e-16);
}
public void Creation_fp500_ps1500_fd_5000()
{
const double fp = 500; // Гц // Граничная частота полосы пропускания
const double fs = 1500; // Гц // Граничная частота полосы запирания
const double fd = 5000; // Гц // Частота дискретизации
const double dt = 1 / fd; // 2с // Период дискретизации
const double Rp = 1; // Неравномерность в полосе пропускания (дБ)
const double Rs = 30; // Неравномерность в полосе пропускания (дБ)
var Gp = (-Rp).From_dB();
var Gs = (-Rs).From_dB();
var eps_p = (10d.Pow(Rp / 10) - 1).Sqrt();
var eps_s = (10d.Pow(Rs / 10) - 1).Sqrt();
var Fp = DigitalFilter.ToAnalogFrequency(fp, dt); // Частота пропускания аналогового прототипа
var Fs = DigitalFilter.ToAnalogFrequency(fs, dt); // Частота подавления аналогового прототипа
var k_eps = eps_s / eps_p;
var k_W = Fs / Fp;
var double_n = Log(k_eps) / Log(k_W);
var N = (int)double_n;
if (double_n - N > 0)
{
N += 1;
}
var L = N / 2;
var r = N % 2;
var alpha = eps_p.Pow(-1d / N);
var th0 = PI / N;
var poles = new Complex[N];
if (r != 0)
{
poles[0] = -alpha;
}
for (var i = r; i < poles.Length; i += 2)
{
var w = th0 * (i + 1 - r - 0.5);
poles[i] = (-alpha * Sin(w), alpha *Cos(w));
poles[i + 1] = poles[i].ComplexConjugate;
}
var translated_poles = poles.ToArray(p => p * Consts.pi2 * Fp);
var z_poles = translated_poles.ToArray(p => DigitalFilter.ToZ(p, dt));
var kz = DigitalFilter.GetNormalizeCoefficient(translated_poles, dt);
var WpN = (Consts.pi2 * Fp).Pow(N);
var k = WpN * kz / eps_p;
var b = Range(0, N + 1).ToArray(i => k * BinomialCoefficient(N, i));
var a_complex = Polynom.Array.GetCoefficientsInverted(z_poles);
var a = a_complex.ToRe() ?? throw new AssertFailedException("Отсутствует ссылка на массив вещественных значений");
var filter = new DSP.Filters.ButterworthLowPass(dt, fp, fs, Gp, Gs);
Assert.That.Value(filter.Order).IsEqual(N);
var tr_k = filter.GetTransmissionCoefficient(fs, dt).Abs.In_dB();
Assert.That.Collection(filter.A).IsEqualTo(a, 3e-12);
Assert.That.Collection(filter.B).IsEqualTo(b, 1e-16);
}
