/// <summary>
/// Возвращает спектр сигнала, вычесленное по быстрому алгоритму фурье
/// </summary>
/// <param name="input">Массив значений сигнала</param>
/// <returns>Массив со значениями спектра сигнала</returns>
public static Complex[] FastTransform(Complex[] input)
{
double log = Math.Log(input.Length, 2);
Complex[] x;
if (log - Math.Round(log) != 0)
{
x = new Complex[(int) Math.Pow(2,(int)log + 1)];
input.CopyTo(x, 0);
}
else
{
x = (Complex[]) input.Clone();
}
Complex[] X;
int N = x.Length;
if (N == 2)
{
X = new Complex[2];
X[0] = x[0] + x[1];
X[1] = x[0] - x[1];
}
else
{
Complex[] x_even = new Complex[N / 2];
Complex[] x_odd = new Complex[N / 2];
for (int i = 0; i < N / 2; i++)
{
x_even[i] = x[2 * i];
x_odd[i] = x[2 * i + 1];
}
Complex[] X_even = UnsafeFastTransform(x_even);
Complex[] X_odd = UnsafeFastTransform(x_odd);
X = new Complex[N];
for (int i = 0; i < N / 2; i++)
{
X[i] = X_even[i] + Module(i, N) * X_odd[i];
X[i + N / 2] = X_even[i] - Module(i, N) * X_odd[i];
}
}
return X;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserDefinedVector"/> class for an array.
/// </summary>
/// <param name="data">The array to create this vector from.</param>
public UserDefinedVector(Complex[] data) : base(data.Length)
{
_data = (Complex[])data.Clone();
}
/// <summary>
/// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
/// </summary>
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
/// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
/// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
/// <param name="a">The a matrix.</param>
/// <param name="rowsA">The number of rows in the <paramref name="a"/> matrix.</param>
/// <param name="columnsA">The number of columns in the <paramref name="a"/> matrix.</param>
/// <param name="b">The b matrix</param>
/// <param name="rowsB">The number of rows in the <paramref name="b"/> matrix.</param>
/// <param name="columnsB">The number of columns in the <paramref name="b"/> matrix.</param>
/// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
/// <param name="c">The c matrix.</param>
public virtual void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, int rowsA, int columnsA, Complex[] b, int rowsB, int columnsB, Complex beta, Complex[] c)
{
int m; // The number of rows of matrix op(A) and of the matrix C.
int n; // The number of columns of matrix op(B) and of the matrix C.
int k; // The number of columns of matrix op(A) and the rows of the matrix op(B).
// First check some basic requirement on the parameters of the matrix multiplication.
if (a == null)
{
throw new ArgumentNullException("a");
}
if (b == null)
{
throw new ArgumentNullException("b");
}
if ((int) transposeA > 111 && (int) transposeB > 111)
{
if (rowsA != columnsB)
{
throw new ArgumentOutOfRangeException();
}
if (columnsA*rowsB != c.Length)
{
throw new ArgumentOutOfRangeException();
}
m = columnsA;
n = rowsB;
k = rowsA;
}
else if ((int) transposeA > 111)
{
if (rowsA != rowsB)
{
throw new ArgumentOutOfRangeException();
}
if (columnsA*columnsB != c.Length)
{
throw new ArgumentOutOfRangeException();
}
m = columnsA;
n = columnsB;
k = rowsA;
}
else if ((int) transposeB > 111)
{
if (columnsA != columnsB)
{
throw new ArgumentOutOfRangeException();
}
if (rowsA*rowsB != c.Length)
{
throw new ArgumentOutOfRangeException();
}
m = rowsA;
n = rowsB;
k = columnsA;
}
else
{
if (columnsA != rowsB)
{
throw new ArgumentOutOfRangeException();
}
if (rowsA*columnsB != c.Length)
{
throw new ArgumentOutOfRangeException();
}
m = rowsA;
n = columnsB;
k = columnsA;
}
if (alpha.IsZero() && beta.IsZero())
{
Array.Clear(c, 0, c.Length);
return;
}
// Check whether we will be overwriting any of our inputs and make copies if necessary.
// TODO - we can don't have to allocate a completely new matrix when x or y point to the same memory
// as result, we can do it on a row wise basis. We should investigate this.
Complex[] adata;
if (ReferenceEquals(a, c))
{
adata = (Complex[]) a.Clone();
}
else
{
adata = a;
}
Complex[] bdata;
if (ReferenceEquals(b, c))
{
bdata = (Complex[]) b.Clone();
}
else
{
bdata = b;
}
if (beta.IsZero())
{
Array.Clear(c, 0, c.Length);
}
else if (!beta.IsOne())
{
Control.LinearAlgebraProvider.ScaleArray(beta, c, c);
}
if (alpha.IsZero())
{
return;
}
CacheObliviousMatrixMultiply(transposeA, transposeB, alpha, adata, 0, 0, bdata, 0, 0, c, 0, 0, m, n, k, m, n, k, true);
}
/// <summary>
/// Multiples two matrices. <c>result = x * y</c>
/// </summary>
/// <param name="x">The x matrix.</param>
/// <param name="rowsX">The number of rows in the x matrix.</param>
/// <param name="columnsX">The number of columns in the x matrix.</param>
/// <param name="y">The y matrix.</param>
/// <param name="rowsY">The number of rows in the y matrix.</param>
/// <param name="columnsY">The number of columns in the y matrix.</param>
/// <param name="result">Where to store the result of the multiplication.</param>
/// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
/// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
public virtual void MatrixMultiply(Complex[] x, int rowsX, int columnsX, Complex[] y, int rowsY, int columnsY, Complex[] result)
{
// First check some basic requirement on the parameters of the matrix multiplication.
if (x == null)
{
throw new ArgumentNullException("x");
}
if (y == null)
{
throw new ArgumentNullException("y");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
if (rowsX*columnsX != x.Length)
{
throw new ArgumentException("x.Length != xRows * xColumns");
}
if (rowsY*columnsY != y.Length)
{
throw new ArgumentException("y.Length != yRows * yColumns");
}
if (columnsX != rowsY)
{
throw new ArgumentException("xColumns != yRows");
}
if (rowsX*columnsY != result.Length)
{
throw new ArgumentException("xRows * yColumns != result.Length");
}
// Check whether we will be overwriting any of our inputs and make copies if necessary.
// TODO - we can don't have to allocate a completely new matrix when x or y point to the same memory
// as result, we can do it on a row wise basis. We should investigate this.
Complex[] xdata;
if (ReferenceEquals(x, result))
{
xdata = (Complex[]) x.Clone();
}
else
{
xdata = x;
}
Complex[] ydata;
if (ReferenceEquals(y, result))
{
ydata = (Complex[]) y.Clone();
}
else
{
ydata = y;
}
MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, Complex.One, xdata, rowsX, columnsX, ydata, rowsY, columnsY, Complex.Zero, result);
}
/// <summary>
/// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
/// </summary>
/// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
/// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
/// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
/// <param name="a">The a matrix.</param>
/// <param name="rowsA">The number of rows in the <paramref name="a"/> matrix.</param>
/// <param name="columnsA">The number of columns in the <paramref name="a"/> matrix.</param>
/// <param name="b">The b matrix</param>
/// <param name="rowsB">The number of rows in the <paramref name="b"/> matrix.</param>
/// <param name="columnsB">The number of columns in the <paramref name="b"/> matrix.</param>
/// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
/// <param name="c">The c matrix.</param>
public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, int rowsA, int columnsA, Complex[] b, int rowsB, int columnsB, Complex beta, Complex[] c)
{
// Choose nonsensical values for the number of rows in c; fill them in depending
// on the operations on a and b.
int rowsC;
// First check some basic requirement on the parameters of the matrix multiplication.
if (a == null)
{
throw new ArgumentNullException("a");
}
if (b == null)
{
throw new ArgumentNullException("b");
}
if ((int)transposeA > 111 && (int)transposeB > 111)
{
if (rowsA != columnsB)
{
throw new ArgumentOutOfRangeException();
}
if (columnsA * rowsB != c.Length)
{
throw new ArgumentOutOfRangeException();
}
rowsC = columnsA;
}
else if ((int)transposeA > 111)
{
if (rowsA != rowsB)
{
throw new ArgumentOutOfRangeException();
}
if (columnsA * columnsB != c.Length)
{
throw new ArgumentOutOfRangeException();
}
rowsC = columnsA;
}
else if ((int)transposeB > 111)
{
if (columnsA != columnsB)
{
throw new ArgumentOutOfRangeException();
}
if (rowsA * rowsB != c.Length)
{
throw new ArgumentOutOfRangeException();
}
rowsC = rowsA;
}
else
{
if (columnsA != rowsB)
{
throw new ArgumentOutOfRangeException();
}
if (rowsA * columnsB != c.Length)
{
throw new ArgumentOutOfRangeException();
}
rowsC = rowsA;
}
if (alpha == 0.0 && beta == 0.0)
{
Array.Clear(c, 0, c.Length);
return;
}
// Check whether we will be overwriting any of our inputs and make copies if necessary.
// TODO - we can don't have to allocate a completely new matrix when x or y point to the same memory
// as result, we can do it on a row wise basis. We should investigate this.
Complex[] adata;
if (ReferenceEquals(a, c))
{
adata = (Complex[])a.Clone();
}
else
{
adata = a;
}
Complex[] bdata;
if (ReferenceEquals(b, c))
{
bdata = (Complex[])b.Clone();
}
else
{
bdata = b;
}
if (alpha == 1.0)
{
if (beta == 0.0)
{
if ((int)transposeA > 111 && (int)transposeB > 111)
{
CommonParallel.For(
0,
columnsA,
j =>
{
var jIndex = j * rowsC;
for (var i = 0; i != rowsB; i++)
{
var iIndex = i * rowsA;
Complex s = 0;
for (var l = 0; l != columnsB; l++)
{
s += adata[iIndex + l] * bdata[(l * rowsB) + j];
}
c[jIndex + i] = s;
}
});
}
else if ((int)transposeA > 111)
{
CommonParallel.For(
0,
columnsB,
j =>
{
var jcIndex = j * rowsC;
var jbIndex = j * rowsB;
for (var i = 0; i != columnsA; i++)
{
var iIndex = i * rowsA;
Complex s = 0;
for (var l = 0; l != rowsA; l++)
{
s += adata[iIndex + l] * bdata[jbIndex + l];
}
c[jcIndex + i] = s;
}
});
}
else if ((int)transposeB > 111)
{
CommonParallel.For(
0,
rowsB,
j =>
{
var jIndex = j * rowsC;
for (var i = 0; i != rowsA; i++)
{
Complex s = 0;
for (var l = 0; l != columnsA; l++)
{
s += adata[(l * rowsA) + i] * bdata[(l * rowsB) + j];
}
c[jIndex + i] = s;
}
});
}
else
{
CommonParallel.For(
0,
columnsB,
j =>
{
var jcIndex = j * rowsC;
var jbIndex = j * rowsB;
for (var i = 0; i != rowsA; i++)
{
Complex s = 0;
for (var l = 0; l != columnsA; l++)
{
s += adata[(l * rowsA) + i] * bdata[jbIndex + l];
}
c[jcIndex + i] = s;
}
});
}
}
else
{
if ((int)transposeA > 111 && (int)transposeB > 111)
{
CommonParallel.For(
0,
columnsA,
j =>
{
var jIndex = j * rowsC;
for (var i = 0; i != rowsB; i++)
{
var iIndex = i * rowsA;
Complex s = 0;
for (var l = 0; l != columnsB; l++)
{
s += adata[iIndex + l] * bdata[(l * rowsB) + j];
}
c[jIndex + i] = (c[jIndex + i] * beta) + s;
}
});
}
else if ((int)transposeA > 111)
{
CommonParallel.For(
0,
columnsB,
j =>
{
var jcIndex = j * rowsC;
var jbIndex = j * rowsB;
for (var i = 0; i != columnsA; i++)
{
var iIndex = i * rowsA;
Complex s = 0;
for (var l = 0; l != rowsA; l++)
{
s += adata[iIndex + l] * bdata[jbIndex + l];
}
c[jcIndex + i] = s + (c[jcIndex + i] * beta);
}
});
}
else if ((int)transposeB > 111)
{
CommonParallel.For(
0,
rowsB,
j =>
{
var jIndex = j * rowsC;
for (var i = 0; i != rowsA; i++)
{
Complex s = 0;
for (var l = 0; l != columnsA; l++)
{
s += adata[(l * rowsA) + i] * bdata[(l * rowsB) + j];
}
c[jIndex + i] = s + (c[jIndex + i] * beta);
}
});
}
else
{
CommonParallel.For(
0,
columnsB,
j =>
{
var jcIndex = j * rowsC;
var jbIndex = j * rowsB;
for (var i = 0; i != rowsA; i++)
{
Complex s = 0;
for (var l = 0; l != columnsA; l++)
{
s += adata[(l * rowsA) + i] * bdata[jbIndex + l];
}
c[jcIndex + i] = s + (c[jcIndex + i] * beta);
}
});
}
}
}
else
{
if ((int)transposeA > 111 && (int)transposeB > 111)
{
CommonParallel.For(
0,
columnsA,
j =>
{
var jIndex = j * rowsC;
for (var i = 0; i != rowsB; i++)
{
var iIndex = i * rowsA;
Complex s = 0;
for (var l = 0; l != columnsB; l++)
{
s += adata[iIndex + l] * bdata[(l * rowsB) + j];
}
c[jIndex + i] = (c[jIndex + i] * beta) + (alpha * s);
}
});
}
else if ((int)transposeA > 111)
{
CommonParallel.For(
0,
columnsB,
j =>
{
var jcIndex = j * rowsC;
var jbIndex = j * rowsB;
for (var i = 0; i != columnsA; i++)
{
var iIndex = i * rowsA;
Complex s = 0;
for (var l = 0; l != rowsA; l++)
{
s += adata[iIndex + l] * bdata[jbIndex + l];
}
c[jcIndex + i] = (alpha * s) + (c[jcIndex + i] * beta);
}
});
}
else if ((int)transposeB > 111)
{
CommonParallel.For(
0,
rowsB,
j =>
{
var jIndex = j * rowsC;
for (var i = 0; i != rowsA; i++)
{
Complex s = 0;
for (var l = 0; l != columnsA; l++)
{
s += adata[(l * rowsA) + i] * bdata[(l * rowsB) + j];
}
c[jIndex + i] = (alpha * s) + (c[jIndex + i] * beta);
}
});
}
else
{
CommonParallel.For(
0,
columnsB,
j =>
{
var jcIndex = j * rowsC;
var jbIndex = j * rowsB;
for (var i = 0; i != rowsA; i++)
{
Complex s = 0;
for (var l = 0; l != columnsA; l++)
{
s += adata[(l * rowsA) + i] * bdata[jbIndex + l];
}
c[jcIndex + i] = (alpha * s) + (c[jcIndex + i] * beta);
}
});
}
}
}
/// <summary>
/// Multiples two matrices. <c>result = x * y</c>
/// </summary>
/// <param name="x">The x matrix.</param>
/// <param name="rowsX">The number of rows in the x matrix.</param>
/// <param name="columnsX">The number of columns in the x matrix.</param>
/// <param name="y">The y matrix.</param>
/// <param name="rowsY">The number of rows in the y matrix.</param>
/// <param name="columnsY">The number of columns in the y matrix.</param>
/// <param name="result">Where to store the result of the multiplication.</param>
/// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
/// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
public void MatrixMultiply(Complex[] x, int rowsX, int columnsX, Complex[] y, int rowsY, int columnsY, Complex[] result)
{
// First check some basic requirement on the parameters of the matrix multiplication.
if (x == null)
{
throw new ArgumentNullException("x");
}
if (y == null)
{
throw new ArgumentNullException("y");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
if (rowsX * columnsX != x.Length)
{
throw new ArgumentException("x.Length != xRows * xColumns");
}
if (rowsY * columnsY != y.Length)
{
throw new ArgumentException("y.Length != yRows * yColumns");
}
if (columnsX != rowsY)
{
throw new ArgumentException("xColumns != yRows");
}
if (rowsX * columnsY != result.Length)
{
throw new ArgumentException("xRows * yColumns != result.Length");
}
// Check whether we will be overwriting any of our inputs and make copies if necessary.
// TODO - we can don't have to allocate a completely new matrix when x or y point to the same memory
// as result, we can do it on a row wise basis. We should investigate this.
Complex[] xdata;
if (ReferenceEquals(x, result))
{
xdata = (Complex[])x.Clone();
}
else
{
xdata = x;
}
Complex[] ydata;
if (ReferenceEquals(y, result))
{
ydata = (Complex[])y.Clone();
}
else
{
ydata = y;
}
// Start the actual matrix multiplication.
// TODO - For small matrices we should get rid of the parallelism because of startup costs.
// Perhaps the following implementations would be a good one
// http://blog.feradz.com/2009/01/cache-efficient-matrix-multiplication/
MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, Complex.One, xdata, rowsX, columnsX, ydata, rowsY, columnsY, Complex.Zero, result);
}
/// <summary>
/// Initializes a new instance of the <see cref="UserDefinedMatrix"/> class from a 2D array.
/// </summary>
/// <param name="data">The 2D array to create this matrix from.</param>
public UserDefinedMatrix(Complex[,] data) : base(data.GetLength(0), data.GetLength(1))
{
_data = (Complex[,])data.Clone();
}
