/// <summary>Performs the QR factorization.</summary>
protected override void InternalCompute()
{
int m = matrix.Rows;
int n = matrix.Columns;
#if MANAGED
int minmn = m < n ? m : n;
r_ = new ComplexFloatMatrix(matrix); // create a copy
ComplexFloatVector[] u = new ComplexFloatVector[minmn];
for (int i = 0; i < minmn; i++)
{
u[i] = Householder.GenerateColumn(r_, i, m - 1, i);
Householder.UA(u[i], r_, i, m - 1, i + 1, n - 1);
}
q_ = ComplexFloatMatrix.CreateIdentity(m);
for (int i = minmn - 1; i >= 0; i--)
{
Householder.UA(u[i], q_, i, m - 1, i, m - 1);
}
#else
qr = ComplexFloatMatrix.ToLinearComplexArray(matrix);
jpvt = new int[n];
jpvt[0] = 1;
Lapack.Geqp3.Compute(m, n, qr, m, jpvt, out tau);
r_ = new ComplexFloatMatrix(m, n);
// Populate R
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (i <= j) {
r_.data[j * m + i] = qr[(jpvt[j]-1) * m + i];
}
else {
r_.data[j * m + i] = ComplexFloat.Zero;
}
}
}
q_ = new ComplexFloatMatrix(m, m);
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
if (j < n)
q_.data[j * m + i] = qr[j * m + i];
else
q_.data[j * m + i] = ComplexFloat.Zero;
}
}
if( m < n ){
Lapack.Ungqr.Compute(m, m, m, q_.data, m, tau);
} else{
Lapack.Ungqr.Compute(m, m, n, q_.data, m, tau);
}
#endif
for (int i = 0; i < m; i++)
{
if (q_[i, i] == 0)
isFullRank = false;
}
}
public void CtorInitialValues()
{
ComplexFloatVector test = new ComplexFloatVector(2, (ComplexFloat)1);
Assert.AreEqual(test.Length, 2);
Assert.AreEqual(test[0], (ComplexFloat)1);
Assert.AreEqual(test[1], (ComplexFloat)1);
}
public void CtorDimensions()
{
ComplexFloatVector test = new ComplexFloatVector(2);
Assert.AreEqual(test.Length, 2);
Assert.AreEqual(test[0], (ComplexFloat)0);
Assert.AreEqual(test[1], (ComplexFloat)0);
}
public void CurrentException2()
{
ComplexFloatVector test = new ComplexFloatVector(new ComplexFloat[2]{1f,2f});
IEnumerator enumerator = test.GetEnumerator();
enumerator.MoveNext();
enumerator.MoveNext();
enumerator.MoveNext();
object value=enumerator.Current;
}
public void CtorArray()
{
float[] testvector = new float[2] { 0, 1 };
ComplexFloatVector test = new ComplexFloatVector(testvector);
Assert.AreEqual(test.Length, testvector.Length);
Assert.AreEqual(test[0], (ComplexFloat)testvector[0]);
Assert.AreEqual(test[1], (ComplexFloat)testvector[1]);
}
public void Current()
{
ComplexFloatVector test = new ComplexFloatVector(new ComplexFloat[2]{1f,2f});
IEnumerator enumerator = test.GetEnumerator();
bool movenextresult;
movenextresult=enumerator.MoveNext();
Assert.IsTrue(movenextresult);
Assert.AreEqual(enumerator.Current,test[0]);
movenextresult=enumerator.MoveNext();
Assert.IsTrue(movenextresult);
Assert.AreEqual(enumerator.Current,test[1]);
movenextresult=enumerator.MoveNext();
Assert.IsFalse(movenextresult);
}
private static void drotg(ref float da, ref float db, ref float c, ref float s)
{
// construct givens plane rotation.
// jack dongarra, linpack, 3/11/78.
float roe, scale, r, z, Absda, Absdb, sda, sdb;
roe = db;
Absda = System.Math.Abs(da);
Absdb = System.Math.Abs(db);
if (Absda > Absdb)
{
roe = da;
}
scale = Absda + Absdb;
if (scale == 0.0)
{
c = 1.0f;
s = 0.0f;
r = 0.0f;
z = 0.0f;
}
else
{
sda = da / scale;
sdb = db / scale;
r = scale * (float)System.Math.Sqrt(sda * sda + sdb * sdb);
if (roe < 0.0)
{
r = -r;
}
c = da / r;
s = db / r;
z = 1.0f;
if (Absda > Absdb)
{
z = s;
}
if (Absdb >= Absda && c != 0.0)
{
z = 1.0f / c;
}
}
da = r;
db = z;
return;
}
///<summary>Solves a system on linear equations, AX=B, where A is the factored matrixed.</summary>
///<param name="B">RHS side of the system.</param>
///<returns>the solution vector, X.</returns>
///<exception cref="ArgumentNullException">B is null.</exception>
///<exception cref="SingularMatrixException">A is singular.</exception>
///<exception cref="ArgumentException">The number of rows of A and the length of B must be the same.</exception>
public ComplexFloatVector Solve(IROComplexFloatVector B)
{
if (B == null)
{
throw new System.ArgumentNullException("B cannot be null.");
}
Compute();
if (singular)
{
throw new SingularMatrixException();
}
else
{
if (B.Length != order)
{
throw new System.ArgumentException("The length of B must be the same as the order of the matrix.");
}
#if MANAGED
// Copy right hand side with pivoting
ComplexFloatVector X = Pivot(B);
// Solve L*Y = B(piv,:)
for (int k = 0; k < order; k++)
{
for (int i = k + 1; i < order; i++)
{
X[i] -= X[k] * factor[i][k];
}
}
// Solve U*X = Y;
for (int k = order - 1; k >= 0; k--)
{
X[k] /= factor[k][k];
for (int i = 0; i < k; i++)
{
X[i] -= X[k] * factor[i][k];
}
}
return(X);
#else
ComplexFloat[] rhs = ComplexFloatMatrix.ToLinearComplexArray(B);
Lapack.Getrs.Compute(Lapack.Transpose.NoTrans, order, 1, factor, order, pivots, rhs, rhs.Length);
return(new ComplexFloatVector(rhs));
#endif
}
}
///<summary>Compute the P Norm of this <c>ComplexFloatVector</c></summary>
///<returns><c>float</c> results from norm.</returns>
///<remarks>p > 0, if p < 0, ABS(p) is used. If p = 0, the infinity norm is returned.</remarks>
public float GetNorm(double p)
{
if (p == 0)
{
return(GetInfinityNorm());
}
if (p < 0)
{
p = -p;
}
double ret = 0;
for (int i = 0; i < data.Length; i++)
{
ret += System.Math.Pow(ComplexMath.Absolute(data[i]), p);
}
return((float)System.Math.Pow(ret, 1 / p));
}
///<summary>Check if <c>ComplexFloatVector</c> variable is the same as another object</summary>
///<param name="obj"><c>obj</c> to compare present <c>ComplexFloatVector</c> to.</param>
///<returns>Returns true if the variable is the same as the <c>ComplexFloatVector</c> variable</returns>
///<remarks>The <c>obj</c> parameter is converted into a <c>ComplexFloatVector</c> variable before comparing with the current <c>ComplexFloatVector</c>.</remarks>
public override bool Equals(Object obj)
{
ComplexFloatVector vector = obj as ComplexFloatVector;
if (vector == null)
{
return(false);
}
if (this.data.Length != vector.data.Length)
{
return(false);
}
for (int i = 0; i < this.data.Length; ++i)
{
if (this.data[i] != vector.data[i])
{
return(false);
}
}
return(true);
}
public void SingularTestforStaticSolveMatrix()
{
ComplexFloatVector cfv = new ComplexFloatVector(3, 1.0f);
ComplexFloatMatrix X = ComplexFloatLevinson.Solve(cfv, cfv, ComplexFloatMatrix.CreateIdentity(3));
}
/// <overloads>
/// Solve a symmetric square Toeplitz system.
/// </overloads>
/// <summary>
/// Solve a symmetric square Toeplitz system with a right-side vector.
/// </summary>
/// <param name="T">The left-most column of the Toeplitz matrix.</param>
/// <param name="Y">The right-side vector of the system.</param>
/// <returns>The solution vector.</returns>
/// <exception cref="ArgumentNullException">
/// <B>T</B> and/or <B>Y</B> are null references
/// </exception>
/// <exception cref="RankException">
/// The length of <B>T</B> does not match the length of <B>Y</B>.
/// </exception>
/// <exception cref="SingularMatrixException">
/// The Toeplitz matrix or one of the the leading sub-matrices is singular.
/// </exception>
/// <remarks>
/// This method solves the linear system <B>AX</B> = <B>Y</B>. Where
/// <B>T</B> is a symmetric square Toeplitz matrix, <B>X</B> is an unknown
/// vector and <B>Y</B> is a known vector.
/// <para>
/// This static member combines the <b>UDL</b> decomposition and the calculation of the solution into a
/// single algorithm. When compared to the non-static member it requires minimal data storage
/// and suffers from no speed penalty.
/// </para>
/// </remarks>
public static ComplexFloatVector Solve(IROComplexFloatVector T, IROComplexFloatVector Y)
{
ComplexFloatVector X;
// check parameters
if (T == null)
{
throw new System.ArgumentNullException("T");
}
else if (Y == null)
{
throw new System.ArgumentNullException("Y");
}
else if (T.Length != Y.Length)
{
throw new RankException("The length of T and Y are not equal.");
}
else
{
// allocate memory
int N = T.Length;
X = new ComplexFloatVector(N); // solution vector
ComplexFloat e; // prediction error
// setup zero order solution
e = T[0];
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
X[0] = Y[0] / T[0];
if (N > 1)
{
ComplexFloatVector a = new ComplexFloatVector(N - 1); // prediction coefficients
ComplexFloatVector Z = new ComplexFloatVector(N - 1); // temporary storage vector
ComplexFloat g; // reflection coefficient
ComplexFloat inner; // inner product
ComplexFloat k;
int i, j, l;
// calculate solution for successive orders
for (i = 1; i < N; i++)
{
// calculate first inner product
inner = T[i];
for (j = 0, l = i - 1; j < i - 1; j++, l--)
{
inner += a[j] * T[l];
}
// update predictor coefficients
g = -(inner / e);
for (j = 0, l = i - 2; j < i - 1; j++, l--)
{
Z[j] = a[j] + g * a[l];
}
// copy vector
for (j = 0; j < i - 1; j++)
{
a[j] = Z[j];
}
a[i - 1] = g;
e *= (ComplexFloat.One - g * g);
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
// calculate second inner product
inner = Y[i];
for (j = 0, l = i; j < i; j++, l--)
{
inner -= X[j] * T[l];
}
// update solution vector
k = inner / e;
for (j = 0, l = i - 1; j < i; j++, l--)
{
X[j] = X[j] + k * a[l];
}
X[j] = k;
}
}
}
return(X);
}
///<summary>Subtract a <c>ComplexFloatVector</c> from another <c>ComplexFloatVector</c></summary>
///<param name="lhs"><c>ComplexFloatVector</c> to subtract from.</param>
///<param name="rhs"><c>ComplexFloatVector</c> to subtract.</param>
///<returns><c>ComplexFloatVector</c> with results.</returns>
public static ComplexFloatVector Subtract(ComplexFloatVector lhs, ComplexFloatVector rhs)
{
return(lhs - rhs);
}
public void ZeroVectorLengthTestforStaticSolveMatrix()
{
ComplexFloatVector LC = new ComplexFloatVector(1);
LC.RemoveAt(0);
ComplexFloatMatrix X = ComplexFloatLevinson.Solve(LC, TR10, ComplexFloatMatrix.CreateIdentity(10));
}
/// <overloads>
/// There are two permuations of the constructor, both require a parameter corresponding
/// to the left-most column of a Toeplitz matrix.
/// </overloads>
/// <summary>
/// Constructor with <c>ComplexFloatVector</c> parameter.
/// </summary>
/// <param name="T">The left-most column of the Toeplitz matrix.</param>
/// <exception cref="ArgumentNullException">
/// <B>T</B> is a null reference.
/// </exception>
/// <exception cref="RankException">
/// The length of <B>T</B> is zero.
/// </exception>
public ComplexFloatSymmetricLevinson(IROComplexFloatVector T)
{
// check parameter
if (T == null)
{
throw new System.ArgumentNullException("T");
}
else if (T.Length == 0)
{
throw new RankException("The length of T is zero.");
}
// save the vector
m_LeftColumn = new ComplexFloatVector(T);
m_Order = m_LeftColumn.Length;
// allocate memory for lower triangular matrix
m_LowerTriangle = new ComplexFloat[m_Order][];
for (int i = 0; i < m_Order; i++)
{
m_LowerTriangle[i] = new ComplexFloat[i+1];
}
// allocate memory for diagonal
m_Diagonal = new ComplexFloat[m_Order];
}
/// <overloads>
/// Solve a symmetric square Toeplitz system.
/// </overloads>
/// <summary>
/// Solve a symmetric square Toeplitz system with a right-side vector.
/// </summary>
/// <param name="T">The left-most column of the Toeplitz matrix.</param>
/// <param name="Y">The right-side vector of the system.</param>
/// <returns>The solution vector.</returns>
/// <exception cref="ArgumentNullException">
/// <B>T</B> and/or <B>Y</B> are null references
/// </exception>
/// <exception cref="RankException">
/// The length of <B>T</B> does not match the length of <B>Y</B>.
/// </exception>
/// <exception cref="SingularMatrixException">
/// The Toeplitz matrix or one of the the leading sub-matrices is singular.
/// </exception>
/// <remarks>
/// This method solves the linear system <B>AX</B> = <B>Y</B>. Where
/// <B>T</B> is a symmetric square Toeplitz matrix, <B>X</B> is an unknown
/// vector and <B>Y</B> is a known vector.
/// <para>
/// This static member combines the <b>UDL</b> decomposition and the calculation of the solution into a
/// single algorithm. When compared to the non-static member it requires minimal data storage
/// and suffers from no speed penalty.
/// </para>
/// </remarks>
public static ComplexFloatVector Solve(IROComplexFloatVector T, IROComplexFloatVector Y)
{
ComplexFloatVector X;
// check parameters
if (T == null)
{
throw new System.ArgumentNullException("T");
}
else if (Y == null)
{
throw new System.ArgumentNullException("Y");
}
else if (T.Length != Y.Length)
{
throw new RankException("The length of T and Y are not equal.");
}
else
{
// allocate memory
int N = T.Length;
X = new ComplexFloatVector(N); // solution vector
ComplexFloat e; // prediction error
// setup zero order solution
e = T[0];
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
X[0] = Y[0] / T[0];
if (N > 1)
{
ComplexFloatVector a = new ComplexFloatVector(N - 1); // prediction coefficients
ComplexFloatVector Z = new ComplexFloatVector(N - 1); // temporary storage vector
ComplexFloat g; // reflection coefficient
ComplexFloat inner; // inner product
ComplexFloat k;
int i, j, l;
// calculate solution for successive orders
for (i = 1; i < N; i++)
{
// calculate first inner product
inner = T[i];
for (j = 0, l = i - 1; j < i - 1; j++, l--)
{
inner += a[j] * T[l];
}
// update predictor coefficients
g = -(inner / e);
for (j = 0, l = i - 2; j < i - 1; j++, l--)
{
Z[j] = a[j] + g * a[l];
}
// copy vector
for (j = 0; j < i - 1; j++)
{
a[j] = Z[j];
}
a[i - 1] = g;
e *= (ComplexFloat.One - g * g);
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
// calculate second inner product
inner = Y[i];
for (j = 0, l = i; j < i; j++, l--)
{
inner -= X[j] * T[l];
}
// update solution vector
k = inner / e;
for (j = 0, l = i - 1; j < i; j++, l--)
{
X[j] = X[j] + k * a[l];
}
X[j] = k;
}
}
}
return X;
}
public void MemberMultiplyVector()
{
ComplexFloatMatrix a = new ComplexFloatMatrix(2);
a[0,0] = new ComplexFloat(1);
a[0,1] = new ComplexFloat(2);
a[1,0] = new ComplexFloat(3);
a[1,1] = new ComplexFloat(4);
ComplexFloatVector b = new ComplexFloatVector(2, 2.0f);
a.Multiply(b);
Assert.AreEqual(a[0,0],new ComplexFloat(6));
Assert.AreEqual(a[1,0],new ComplexFloat(14));
Assert.AreEqual(a.ColumnLength, 1);
Assert.AreEqual(a.RowLength, 2);
}
/// <summary>
/// Solve a symmetric square Toeplitz system with a right-side matrix.
/// </summary>
/// <param name="T">The left-most column of the Toeplitz matrix.</param>
/// <param name="Y">The right-side matrix of the system.</param>
/// <returns>The solution matrix.</returns>
/// <exception cref="ArgumentNullException">
/// <B>T</B> and/or <B>Y</B> are null references
/// </exception>
/// <exception cref="RankException">
/// The length of <B>T</B> does not match the number of rows in <B>Y</B>.
/// </exception>
/// <exception cref="SingularMatrixException">
/// The Toeplitz matrix or one of the the leading sub-matrices is singular.
/// </exception>
/// <remarks>
/// This method solves the linear system <B>AX</B> = <B>Y</B>. Where
/// <B>T</B> is a symmetric square Toeplitz matrix, <B>X</B> is an unknown
/// matrix and <B>Y</B> is a known matrix.
/// <para>
/// This static member combines the <b>UDL</b> decomposition and the calculation of the solution into a
/// single algorithm. When compared to the non-static member it requires minimal data storage
/// and suffers from no speed penalty.
/// </para>
/// </remarks>
public static ComplexFloatMatrix Solve(IROComplexFloatVector T, IROComplexFloatMatrix Y)
{
ComplexFloatMatrix X;
// check parameters
if (T == null)
{
throw new System.ArgumentNullException("T");
}
else if (Y == null)
{
throw new System.ArgumentNullException("Y");
}
else if (T.Length != Y.Columns)
{
throw new RankException("The length of T and Y are not equal.");
}
else
{
// allocate memory
int N = T.Length;
int M = Y.Rows;
X = new ComplexFloatMatrix(N, M); // solution matrix
ComplexFloatVector Z = new ComplexFloatVector(N); // temporary storage vector
ComplexFloat e; // prediction error
int i, j, l, m;
// setup zero order solution
e = T[0];
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
for (m = 0; m < M; m++)
{
X[0, m] = Y[0,m] / T[0];
}
if (N > 1)
{
ComplexFloatVector a = new ComplexFloatVector(N - 1); // prediction coefficients
ComplexFloat p; // reflection coefficient
ComplexFloat inner; // inner product
ComplexFloat k;
// calculate solution for successive orders
for (i = 1; i < N; i++)
{
// calculate first inner product
inner = T[i];
for (j = 0, l = i - 1; j < i - 1; j++, l--)
{
inner += a[j] * T[l];
}
// update predictor coefficients
p = -(inner / e);
for (j = 0, l = i - 2; j < i - 1; j++, l--)
{
Z[j] = a[j] + p * a[l];
}
// copy vector
for (j = 0; j < i - 1; j++)
{
a[j] = Z[j];
}
a[i - 1] = p;
e *= (ComplexFloat.One - p * p);
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
// update the solution matrix
for (m = 0; m < M; m++)
{
// retrieve a copy of solution column
for (j = 0; j < i; j++)
{
Z[j] = X[j, m];
}
// calculate second inner product
inner = Y[i, m];
for (j = 0, l = i; j < i; j++, l--)
{
inner -= Z[j] * T[l];
}
// update solution vector
k = inner / e;
for (j = 0, l = i - 1; j < i; j++, l--)
{
Z[j] = Z[j] + k * a[l];
}
Z[j] = k;
// store solution column in matrix
for (j = 0; j <= i; j++)
{
X[j, m] = Z[j];
}
}
}
}
}
return X;
}
public void StaticMultiplyMatrixNonConformVector()
{
ComplexFloatMatrix a = new ComplexFloatMatrix(2);
ComplexFloatVector b = new ComplexFloatVector(3, 2.0f);
ComplexFloatVector c = a * b;
}
///<summary>Add a <c>ComplexFloatVector</c> to another <c>ComplexFloatVector</c></summary>
///<param name="lhs"><c>ComplexFloatVector</c> to add to.</param>
///<param name="rhs"><c>ComplexFloatVector</c> to add.</param>
///<returns><c>ComplexFloatVector</c> with results.</returns>
public static ComplexFloatVector Add(ComplexFloatVector lhs, ComplexFloatVector rhs)
{
return(lhs + rhs);
}
///<summary>Computes the algorithm.</summary>
protected override void InternalCompute()
{
rows = matrix.RowLength;
cols = matrix.ColumnLength;
int mm = System.Math.Min(rows + 1, cols);
s = new ComplexFloatVector(mm); // singular values
#if MANAGED
// Derived from LINPACK code.
// Initialize.
u = new ComplexFloatMatrix(rows, rows); // left vectors
v = new ComplexFloatMatrix(cols, cols); // right vectors
ComplexFloatVector e = new ComplexFloatVector(cols);
ComplexFloatVector work = new ComplexFloatVector(rows);
int i, iter, j, k, kase, l, lp1, ls = 0, lu, m, nct, nctp1, ncu, nrt, nrtp1;
float b, c, cs = 0.0f, el, emm1, f, g, scale, shift, sl,
sm, sn = 0.0f, smm1, t1, test, ztest, xnorm, enorm;
ComplexFloat t, r;
ncu = rows;
// reduce matrix to bidiagonal form, storing the diagonal elements
// in s and the super-diagonal elements in e.
int info = 0;
nct = System.Math.Min(rows - 1, cols);
nrt = System.Math.Max(0, System.Math.Min(cols - 2, rows));
lu = System.Math.Max(nct, nrt);
for (l = 0; l < lu; l++)
{
lp1 = l + 1;
if (l < nct)
{
// compute the transformation for the l-th column and
// place the l-th diagonal in s[l].
xnorm = dznrm2Column(matrix, l, l);
s[l] = new ComplexFloat(xnorm, 0.0f);
if (dcabs1(s[l]) != 0.0f)
{
if (dcabs1(matrix[l, l]) != 0.0f)
{
s[l] = csign(s[l], matrix[l, l]);
}
zscalColumn(matrix, l, l, 1.0f / s[l]);
matrix[l, l] = ComplexFloat.One + matrix[l, l];
}
s[l] = -s[l];
}
for (j = lp1; j < cols; j++)
{
if (l < nct)
{
if (dcabs1(s[l]) != 0.0f)
{
// apply the transformation.
t = -zdotc(matrix, l, j, l) / matrix[l, l];
for (int ii = l; ii < matrix.RowLength; ii++)
{
matrix[ii, j] += t * matrix[ii, l];
}
}
}
//place the l-th row of matrix into e for the
//subsequent calculation of the row transformation.
e[j] = ComplexMath.Conjugate(matrix[l, j]);
}
if (computeVectors && l < nct)
{
// place the transformation in u for subsequent back multiplication.
for (i = l; i < rows; i++)
{
u[i, l] = matrix[i, l];
}
}
if (l < nrt)
{
// compute the l-th row transformation and place the l-th super-diagonal in e(l).
enorm = dznrm2Vector(e, lp1);
e[l] = new ComplexFloat(enorm, 0.0f);
if (dcabs1(e[l]) != 0.0f)
{
if (dcabs1(e[lp1]) != 0.0f)
{
e[l] = csign(e[l], e[lp1]);
}
zscalVector(e, lp1, 1.0f / e[l]);
e[lp1] = ComplexFloat.One + e[lp1];
}
e[l] = ComplexMath.Conjugate(-e[l]);
if (lp1 < rows && dcabs1(e[l]) != 0.0f)
{
// apply the transformation.
for (i = lp1; i < rows; i++)
{
work[i] = ComplexFloat.Zero;
}
for (j = lp1; j < cols; j++)
{
for (int ii = lp1; ii < matrix.RowLength; ii++)
{
work[ii] += e[j] * matrix[ii, j];
}
}
for (j = lp1; j < cols; j++)
{
ComplexFloat ww = ComplexMath.Conjugate(-e[j] / e[lp1]);
for (int ii = lp1; ii < matrix.RowLength; ii++)
{
matrix[ii, j] += ww * work[ii];
}
}
}
if (computeVectors)
{
// place the transformation in v for subsequent back multiplication.
for (i = lp1; i < cols; i++)
{
v[i, l] = e[i];
}
}
}
}
// set up the final bidiagonal matrix or order m.
m = System.Math.Min(cols, rows + 1);
nctp1 = nct + 1;
nrtp1 = nrt + 1;
if (nct < cols)
{
s[nctp1 - 1] = matrix[nctp1 - 1, nctp1 - 1];
}
if (rows < m)
{
s[m - 1] = ComplexFloat.Zero;
}
if (nrtp1 < m)
{
e[nrtp1 - 1] = matrix[nrtp1 - 1, m - 1];
}
e[m - 1] = ComplexFloat.Zero;
// if required, generate u.
if (computeVectors)
{
for (j = nctp1 - 1; j < ncu; j++)
{
for (i = 0; i < rows; i++)
{
u[i, j] = ComplexFloat.Zero;
}
u[j, j] = ComplexFloat.One;
}
for (l = nct - 1; l >= 0; l--)
{
if (dcabs1(s[l]) != 0.0)
{
for (j = l + 1; j < ncu; j++)
{
t = -zdotc(u, l, j, l) / u[l, l];
for (int ii = l; ii < u.RowLength; ii++)
{
u[ii, j] += t * u[ii, l];
}
}
zscalColumn(u, l, l, -ComplexFloat.One);
u[l, l] = ComplexFloat.One + u[l, l];
for (i = 0; i < l; i++)
{
u[i, l] = ComplexFloat.Zero;
}
}
else
{
for (i = 0; i < rows; i++)
{
u[i, l] = ComplexFloat.Zero;
}
u[l, l] = ComplexFloat.One;
}
}
}
// if it is required, generate v.
if (computeVectors)
{
for (l = cols - 1; l >= 0; l--)
{
lp1 = l + 1;
if (l < nrt)
{
if (dcabs1(e[l]) != 0.0)
{
for (j = lp1; j < cols; j++)
{
t = -zdotc(v, l, j, lp1) / v[lp1, l];
for (int ii = l; ii < v.RowLength; ii++)
{
v[ii, j] += t * v[ii, l];
}
}
}
}
for (i = 0; i < cols; i++)
{
v[i, l] = ComplexFloat.Zero;
}
v[l, l] = ComplexFloat.One;
}
}
// transform s and e so that they are float .
for (i = 0; i < m; i++)
{
if (dcabs1(s[i]) != 0.0)
{
t = new ComplexFloat(ComplexMath.Absolute(s[i]), 0.0f);
r = s[i] / t;
s[i] = t;
if (i < m - 1)
{
e[i] = e[i] / r;
}
if (computeVectors)
{
zscalColumn(u, i, 0, r);
}
}
// ...exit
if (i == m - 1)
{
break;
}
if (dcabs1(e[i]) != 0.0)
{
t = new ComplexFloat(ComplexMath.Absolute(e[i]), 0.0f);
r = t / e[i];
e[i] = t;
s[i + 1] = s[i + 1] * r;
if (computeVectors)
{
zscalColumn(v, i + 1, 0, r);
}
}
}
// main iteration loop for the singular values.
mm = m;
iter = 0;
while (m > 0)
{ // quit if all the singular values have been found.
// if too many iterations have been performed, set
// flag and return.
if (iter >= MAXITER)
{
info = m;
// ......exit
break;
}
// this section of the program inspects for
// negligible elements in the s and e arrays. on
// completion the variables kase and l are set as follows.
// kase = 1 if s[m] and e[l-1] are negligible and l < m
// kase = 2 if s[l] is negligible and l < m
// kase = 3 if e[l-1] is negligible, l < m, and
// s[l, ..., s[m] are not negligible (qr step).
// kase = 4 if e[m-1] is negligible (convergence).
for (l = m - 2; l >= 0; l--)
{
test = ComplexMath.Absolute(s[l]) + ComplexMath.Absolute(s[l + 1]);
ztest = test + ComplexMath.Absolute(e[l]);
if (ztest == test)
{
e[l] = ComplexFloat.Zero;
break;
}
}
if (l == m - 2)
{
kase = 4;
}
else
{
for (ls = m - 1; ls > l; ls--)
{
test = 0.0f;
if (ls != m - 1)
{
test = test + ComplexMath.Absolute(e[ls]);
}
if (ls != l + 1)
{
test = test + ComplexMath.Absolute(e[ls - 1]);
}
ztest = test + ComplexMath.Absolute(s[ls]);
if (ztest == test)
{
s[ls] = ComplexFloat.Zero;
break;
}
}
if (ls == l)
{
kase = 3;
}
else if (ls == m - 1)
{
kase = 1;
}
else
{
kase = 2;
l = ls;
}
}
l = l + 1;
// perform the task indicated by kase.
switch (kase)
{
// deflate negligible s[m].
case 1:
f = e[m - 2].Real;
e[m - 2] = ComplexFloat.Zero;
for (k = m - 2; k >= 0; k--)
{
t1 = s[k].Real;
drotg(ref t1, ref f, ref cs, ref sn);
s[k] = new ComplexFloat(t1, 0.0f);
if (k != l)
{
f = -sn * e[k - 1].Real;
e[k - 1] = cs * e[k - 1];
}
if (computeVectors)
{
zdrot(v, k, m - 1, cs, sn);
}
}
break;
// split at negligible s[l].
case 2:
f = e[l - 1].Real;
e[l - 1] = ComplexFloat.Zero;
for (k = l; k < m; k++)
{
t1 = s[k].Real;
drotg(ref t1, ref f, ref cs, ref sn);
s[k] = new ComplexFloat(t1, 0.0f);
f = -sn * e[k].Real;
e[k] = cs * e[k];
if (computeVectors)
{
zdrot(u, k, l - 1, cs, sn);
}
}
break;
// perform one qr step.
case 3:
// calculate the shift.
scale = 0.0f;
scale = System.Math.Max(scale, ComplexMath.Absolute(s[m - 1]));
scale = System.Math.Max(scale, ComplexMath.Absolute(s[m - 2]));
scale = System.Math.Max(scale, ComplexMath.Absolute(e[m - 2]));
scale = System.Math.Max(scale, ComplexMath.Absolute(s[l]));
scale = System.Math.Max(scale, ComplexMath.Absolute(e[l]));
sm = s[m - 1].Real / scale;
smm1 = s[m - 2].Real / scale;
emm1 = e[m - 2].Real / scale;
sl = s[l].Real / scale;
el = e[l].Real / scale;
b = ((smm1 + sm) * (smm1 - sm) + emm1 * emm1) / 2.0f;
c = (sm * emm1) * (sm * emm1);
shift = 0.0f;
if (b != 0.0f || c != 0.0f)
{
shift = (float)System.Math.Sqrt(b * b + c);
if (b < 0.0f)
{
shift = -shift;
}
shift = c / (b + shift);
}
f = (sl + sm) * (sl - sm) + shift;
g = sl * el;
// chase zeros.
for (k = l; k < m - 1; k++)
{
drotg(ref f, ref g, ref cs, ref sn);
if (k != l)
{
e[k - 1] = new ComplexFloat(f, 0.0f);
}
f = cs * s[k].Real + sn * e[k].Real;
e[k] = cs * e[k] - sn * s[k];
g = sn * s[k + 1].Real;
s[k + 1] = cs * s[k + 1];
if (computeVectors)
{
zdrot(v, k, k + 1, cs, sn);
}
drotg(ref f, ref g, ref cs, ref sn);
s[k] = new ComplexFloat(f, 0.0f);
f = cs * e[k].Real + sn * s[k + 1].Real;
s[k + 1] = -sn * e[k] + cs * s[k + 1];
g = sn * e[k + 1].Real;
e[k + 1] = cs * e[k + 1];
if (computeVectors && k < rows)
{
zdrot(u, k, k + 1, cs, sn);
}
}
e[m - 2] = new ComplexFloat(f, 0.0f);
iter = iter + 1;
break;
// convergence.
case 4:
// make the singular value positive
if (s[l].Real < 0.0)
{
s[l] = -s[l];
if (computeVectors)
{
zscalColumn(v, l, 0, -ComplexFloat.One);
}
}
// order the singular value.
while (l != mm - 1)
{
if (s[l].Real >= s[l + 1].Real)
{
break;
}
t = s[l];
s[l] = s[l + 1];
s[l + 1] = t;
if (computeVectors && l < cols)
{
zswap(v, l, l + 1);
}
if (computeVectors && l < rows)
{
zswap(u, l, l + 1);
}
l = l + 1;
}
iter = 0;
m = m - 1;
break;
}
}
// make matrix w from vector s
// there is no constructor, creating diagonal matrix from vector
// doing it ourselves
mm = System.Math.Min(matrix.RowLength, matrix.ColumnLength);
#else
float[] d = new float[mm];
u = new ComplexFloatMatrix(rows);
v = new ComplexFloatMatrix(cols);
ComplexFloat[] a = new ComplexFloat[matrix.data.Length];
Array.Copy(matrix.data, a, matrix.data.Length);
Lapack.Gesvd.Compute(rows, cols, a, d, u.data, v.data);
v.ConjugateTranspose();
for (int i = 0; i < d.Length; i++)
{
s[i] = d[i];
}
#endif
w = new FloatMatrix(matrix.RowLength, matrix.ColumnLength);
for (int ii = 0; ii < matrix.RowLength; ii++)
{
for (int jj = 0; jj < matrix.ColumnLength; jj++)
{
if (ii == jj)
{
w[ii, ii] = s[ii];
}
}
}
float eps = (float)System.Math.Pow(2.0, -52.0);
float tol = System.Math.Max(matrix.RowLength, matrix.ColumnLength) * s[0].Real * eps;
rank = 0;
for (int h = 0; h < mm; h++)
{
if (s[h].Real > tol)
{
rank++;
}
}
if (!computeVectors)
{
u = null;
v = null;
}
matrix = null;
}
///<summary>Divide a <c>ComplexFloatVector</c> x with a <c>ComplexFloat</c> y as x/y</summary>
///<param name="lhs"><c>ComplexFloatVector</c> as left hand operand.</param>
///<param name="rhs"><c>ComplexFloat</c> as right hand operand.</param>
///<returns><c>ComplexFloatVector</c> with results.</returns>
public static ComplexFloatVector Divide(ComplexFloatVector lhs, ComplexFloat rhs)
{
return(lhs / rhs);
}
///<summary>Multiply a <c>ComplexFloatVector</c> x with a <c>ComplexFloat</c> y as x*y</summary>
///<param name="lhs"><c>ComplexFloatVector</c> as left hand operand.</param>
///<param name="rhs"><c>ComplexFloat</c> as right hand operand.</param>
///<returns><c>ComplexFloatVector</c> with results.</returns>
public static ComplexFloatVector Multiply(ComplexFloatVector lhs, ComplexFloat rhs)
{
return(lhs * rhs);
}
public void StaticMultiplyNullMatrixVector()
{
ComplexFloatMatrix a = null;
ComplexFloatVector b = new ComplexFloatVector(2, 2.0f);
ComplexFloatVector c = ComplexFloatMatrix.Multiply(a,b);
}
///<summary> Constructor </summary>
public ComplexFloatVectorEnumerator(ComplexFloatVector vector)
{
v = vector;
index = -1;
length = v.Length;
}
public void MemberMultiplyMatrixNonConformVector()
{
ComplexFloatMatrix a = new ComplexFloatMatrix(2);
ComplexFloatVector b = new ComplexFloatVector(3, 2.0f);
a.Multiply(b);
}
/// <summary>
/// Solve the Yule-Walker equations for a symmetric square Toeplitz system
/// </summary>
/// <param name="R">The left-most column of the Toeplitz matrix.</param>
/// <returns>The solution vector.</returns>
/// <exception cref="ArgumentNullException">
/// <B>R</B> is a null reference.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// The length of <B>R</B> must be greater than one.
/// </exception>
/// <exception cref="SingularMatrixException">
/// The Toeplitz matrix or one of the the leading sub-matrices is singular.
/// </exception>
/// <remarks>
/// This member is used to solve the Yule-Walker system <B>AX</B> = -<B>a</B>,
/// where <B>A</B> is a symmetric square Toeplitz matrix, constructed
/// from the elements <B>R[0]</B>, ..., <B>R[N-2]</B> and
/// the vector <B>a</B> is constructed from the elements
/// <B>R[1]</B>, ..., <B>R[N-1]</B>.
/// <para>
/// Durbin's algorithm is used to solve the linear system. It requires
/// approximately the <b>N</b> squared FLOPS to calculate the
/// solution (<b>N</b> is the matrix order).
/// </para>
/// </remarks>
public static ComplexFloatVector YuleWalker(IROComplexFloatVector R)
{
ComplexFloatVector a;
// check parameters
if (R == null)
{
throw new System.ArgumentNullException("R");
}
else if (R.Length < 2)
{
throw new System.ArgumentOutOfRangeException("R", "The length of R must be greater than 1.");
}
else
{
int N = R.Length - 1;
a = new ComplexFloatVector(N); // prediction coefficients
ComplexFloatVector Z = new ComplexFloatVector(N); // temporary storage vector
ComplexFloat e; // predictor error
ComplexFloat inner; // inner product
ComplexFloat g; // reflection coefficient
int i, j, l;
// setup first order solution
e = R[0];
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
g = -R[1] / R[0];
a[0] = g;
// calculate solution for successive orders
for (i = 1; i < N; i++)
{
e *= (ComplexFloat.One - g * g);
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
// calculate inner product
inner = R[i + 1];
for (j = 0, l = i; j < i; j++, l--)
{
inner += a[j] * R[l];
}
// update prediction coefficients
g = -(inner / e);
for (j = 0, l = i - 1; j < i; j++, l--)
{
Z[j] = a[j] + g * a[l];
}
// copy vector
for (j = 0; j < i; j++)
{
a[j] = Z[j];
}
a[i] = g;
}
}
return(a);
}
/// <summary>
/// Solve the Yule-Walker equations for a symmetric square Toeplitz system
/// </summary>
/// <param name="R">The left-most column of the Toeplitz matrix.</param>
/// <returns>The solution vector.</returns>
/// <exception cref="ArgumentNullException">
/// <B>R</B> is a null reference.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// The length of <B>R</B> must be greater than one.
/// </exception>
/// <exception cref="SingularMatrixException">
/// The Toeplitz matrix or one of the the leading sub-matrices is singular.
/// </exception>
/// <remarks>
/// This member is used to solve the Yule-Walker system <B>AX</B> = -<B>a</B>,
/// where <B>A</B> is a symmetric square Toeplitz matrix, constructed
/// from the elements <B>R[0]</B>, ..., <B>R[N-2]</B> and
/// the vector <B>a</B> is constructed from the elements
/// <B>R[1]</B>, ..., <B>R[N-1]</B>.
/// <para>
/// Durbin's algorithm is used to solve the linear system. It requires
/// approximately the <b>N</b> squared FLOPS to calculate the
/// solution (<b>N</b> is the matrix order).
/// </para>
/// </remarks>
public static ComplexFloatVector YuleWalker(IROComplexFloatVector R)
{
ComplexFloatVector a;
// check parameters
if (R == null)
{
throw new System.ArgumentNullException("R");
}
else if (R.Length < 2)
{
throw new System.ArgumentOutOfRangeException("R", "The length of R must be greater than 1.");
}
else
{
int N = R.Length - 1;
a = new ComplexFloatVector(N); // prediction coefficients
ComplexFloatVector Z = new ComplexFloatVector(N); // temporary storage vector
ComplexFloat e; // predictor error
ComplexFloat inner; // inner product
ComplexFloat g; // reflection coefficient
int i, j, l;
// setup first order solution
e = R[0];
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
g = -R[1] / R[0];
a[0] = g;
// calculate solution for successive orders
for (i = 1; i < N; i++)
{
e *= (ComplexFloat.One - g * g);
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
// calculate inner product
inner = R[i + 1];
for (j = 0, l = i; j < i; j++, l--)
{
inner += a[j] * R[l];
}
// update prediction coefficients
g = -(inner / e);
for (j = 0, l = i - 1; j < i; j++, l--)
{
Z[j] = a[j] + g * a[l];
}
// copy vector
for (j = 0; j < i; j++)
{
a[j] = Z[j];
}
a[i] = g;
}
}
return a;
}
/// <summary>
/// Solve a symmetric square Toeplitz system with a right-side matrix.
/// </summary>
/// <param name="T">The left-most column of the Toeplitz matrix.</param>
/// <param name="Y">The right-side matrix of the system.</param>
/// <returns>The solution matrix.</returns>
/// <exception cref="ArgumentNullException">
/// <B>T</B> and/or <B>Y</B> are null references
/// </exception>
/// <exception cref="RankException">
/// The length of <B>T</B> does not match the number of rows in <B>Y</B>.
/// </exception>
/// <exception cref="SingularMatrixException">
/// The Toeplitz matrix or one of the the leading sub-matrices is singular.
/// </exception>
/// <remarks>
/// This method solves the linear system <B>AX</B> = <B>Y</B>. Where
/// <B>T</B> is a symmetric square Toeplitz matrix, <B>X</B> is an unknown
/// matrix and <B>Y</B> is a known matrix.
/// <para>
/// This static member combines the <b>UDL</b> decomposition and the calculation of the solution into a
/// single algorithm. When compared to the non-static member it requires minimal data storage
/// and suffers from no speed penalty.
/// </para>
/// </remarks>
public static ComplexFloatMatrix Solve(IROComplexFloatVector T, IROComplexFloatMatrix Y)
{
ComplexFloatMatrix X;
// check parameters
if (T == null)
{
throw new System.ArgumentNullException("T");
}
else if (Y == null)
{
throw new System.ArgumentNullException("Y");
}
else if (T.Length != Y.Columns)
{
throw new RankException("The length of T and Y are not equal.");
}
else
{
// allocate memory
int N = T.Length;
int M = Y.Rows;
X = new ComplexFloatMatrix(N, M); // solution matrix
ComplexFloatVector Z = new ComplexFloatVector(N); // temporary storage vector
ComplexFloat e; // prediction error
int i, j, l, m;
// setup zero order solution
e = T[0];
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
for (m = 0; m < M; m++)
{
X[0, m] = Y[0, m] / T[0];
}
if (N > 1)
{
ComplexFloatVector a = new ComplexFloatVector(N - 1); // prediction coefficients
ComplexFloat p; // reflection coefficient
ComplexFloat inner; // inner product
ComplexFloat k;
// calculate solution for successive orders
for (i = 1; i < N; i++)
{
// calculate first inner product
inner = T[i];
for (j = 0, l = i - 1; j < i - 1; j++, l--)
{
inner += a[j] * T[l];
}
// update predictor coefficients
p = -(inner / e);
for (j = 0, l = i - 2; j < i - 1; j++, l--)
{
Z[j] = a[j] + p * a[l];
}
// copy vector
for (j = 0; j < i - 1; j++)
{
a[j] = Z[j];
}
a[i - 1] = p;
e *= (ComplexFloat.One - p * p);
if (e == ComplexFloat.Zero)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
// update the solution matrix
for (m = 0; m < M; m++)
{
// retrieve a copy of solution column
for (j = 0; j < i; j++)
{
Z[j] = X[j, m];
}
// calculate second inner product
inner = Y[i, m];
for (j = 0, l = i; j < i; j++, l--)
{
inner -= Z[j] * T[l];
}
// update solution vector
k = inner / e;
for (j = 0, l = i - 1; j < i; j++, l--)
{
Z[j] = Z[j] + k * a[l];
}
Z[j] = k;
// store solution column in matrix
for (j = 0; j <= i; j++)
{
X[j, m] = Z[j];
}
}
}
}
}
return(X);
}
/// <overloads>
/// Solve a symmetric square Toeplitz system.
/// </overloads>
/// <summary>
/// Solve a symmetric square Toeplitz system with a right-side vector.
/// </summary>
/// <param name="Y">The right-hand side of the system.</param>
/// <returns>The solution vector.</returns>
/// <exception cref="ArgumentNullException">
/// Parameter <B>Y</B> is a null reference.
/// </exception>
/// <exception cref="RankException">
/// The length of <B>Y</B> is not equal to the number of rows in the Toeplitz matrix.
/// </exception>
/// <exception cref="SingularMatrixException">
/// The Toeplitz matrix or one of the the leading sub-matrices is singular.
/// </exception>
/// <remarks>
/// This member solves the linear system <B>TX</B> = <B>Y</B>, where <B>T</B> is
/// the symmetric square Toeplitz matrix, <B>X</B> is the unknown solution vector
/// and <B>Y</B> is a known vector.
/// <para>
/// The class implicitly decomposes the inverse Toeplitz matrix into a <b>UDL</b> factorisation
/// using the Levinson algorithm, and then calculates the solution vector.
/// </para>
/// </remarks>
public ComplexFloatVector Solve(IROComplexFloatVector Y)
{
ComplexFloatVector X;
// check parameters
if (Y == null)
{
throw new System.ArgumentNullException("Y");
}
else if (m_Order != Y.Length)
{
throw new RankException("The length of Y is not equal to the number of rows in the Toeplitz matrix.");
}
Compute();
if (m_IsSingular == true)
{
throw new SingularMatrixException("The Toeplitz matrix or one of the the leading sub-matrices is singular.");
}
int i, j, l; // index/loop variables
ComplexFloat Inner; // inner product
ComplexFloat G; // scaling constant
ComplexFloat[] A; // reference to current order coefficients
// allocate memory for solution
X = new ComplexFloatVector(m_Order);
// setup zero order solution
X[0] = Y[0] / m_LeftColumn[0];
// solve systems of increasing order
for (i = 1; i < m_Order; i++)
{
// calculate inner product
Inner = Y[i];
for (j = 0, l = i; j < i; j++, l--)
{
Inner -= X[j] * m_LeftColumn[l];
}
// get the current predictor coefficients row
A = m_LowerTriangle[i];
// update the solution vector
G = Inner * m_Diagonal[i];
for (j = 0; j <= i; j++)
{
X[j] += G * A[j];
}
}
return X;
}
public void SetupTestCases()
{
// unit testing values - order 1
LC1 = new ComplexFloatVector(1);
LC1[0] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
TR1 = new ComplexFloatVector(1);
TR1[0] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
L1 = new ComplexFloatMatrix(1);
L1[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
D1 = new ComplexFloatVector(1);
D1[0] = new ComplexFloat(+5.0000000E-001f, -5.0000000E-001f);
U1 = new ComplexFloatMatrix(1);
U1[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
Det1 = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
I1 = new ComplexFloatMatrix(1);
I1[0, 0] = new ComplexFloat(+5.0000000E-001f, -5.0000000E-001f);
X1 = new ComplexFloatVector(1);
X1[0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
Y1 = new ComplexFloatVector(1);
Y1[0] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
// unit testing values - order 2
LC2 = new ComplexFloatVector(2);
LC2[0] = new ComplexFloat(+3.0000000E+000f, +3.0000000E+000f);
LC2[1] = new ComplexFloat(+2.0000000E+000f, +0.0000000E+000f);
TR2 = new ComplexFloatVector(2);
TR2[0] = new ComplexFloat(+3.0000000E+000f, +3.0000000E+000f);
TR2[1] = new ComplexFloat(+2.0000000E+000f, +0.0000000E+000f);
L2 = new ComplexFloatMatrix(2);
L2[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L2[1, 0] = new ComplexFloat(-3.3333333E-001f, +3.3333333E-001f);
L2[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
D2 = new ComplexFloatVector(2);
D2[0] = new ComplexFloat(+1.6666667E-001f, -1.6666667E-001f);
D2[1] = new ComplexFloat(+1.2352941E-001f, -1.9411765E-001f);
U2 = new ComplexFloatMatrix(2);
U2[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U2[0, 1] = new ComplexFloat(-3.3333333E-001f, +3.3333333E-001f);
U2[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
Det2 = new ComplexFloat(-4.0000000E+000f, +1.8000000E+001f);
I2 = new ComplexFloatMatrix(2);
I2[0, 0] = new ComplexFloat(+1.2352941E-001f, -1.9411765E-001f);
I2[0, 1] = new ComplexFloat(+2.3529412E-002f, +1.0588235E-001f);
I2[1, 0] = new ComplexFloat(+2.3529412E-002f, +1.0588235E-001f);
I2[1, 1] = new ComplexFloat(+1.2352941E-001f, -1.9411765E-001f);
X2 = new ComplexFloatVector(2);
X2[0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
X2[1] = new ComplexFloat(+2.0000000E+000f, +0.0000000E+000f);
Y2 = new ComplexFloatVector(2);
Y2[0] = new ComplexFloat(+7.0000000E+000f, +3.0000000E+000f);
Y2[1] = new ComplexFloat(+8.0000000E+000f, +6.0000000E+000f);
// unit testing values - order 3
LC3 = new ComplexFloatVector(3);
LC3[0] = new ComplexFloat(+3.0000000E+000f, +3.0000000E+000f);
LC3[1] = new ComplexFloat(+2.0000000E+000f, +0.0000000E+000f);
LC3[2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
TR3 = new ComplexFloatVector(3);
TR3[0] = new ComplexFloat(+3.0000000E+000f, +3.0000000E+000f);
TR3[1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
TR3[2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L3 = new ComplexFloatMatrix(3);
L3[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L3[1, 0] = new ComplexFloat(-3.3333333E-001f, +3.3333333E-001f);
L3[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L3[2, 0] = new ComplexFloat(-1.7073171E-001f, -3.6585366E-002f);
L3[2, 1] = new ComplexFloat(-2.9878049E-001f, +3.1097561E-001f);
L3[2, 2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
D3 = new ComplexFloatVector(3);
D3[0] = new ComplexFloat(+1.6666667E-001f, -1.6666667E-001f);
D3[1] = new ComplexFloat(+1.4634146E-001f, -1.8292683E-001f);
D3[2] = new ComplexFloat(+1.4776571E-001f, -1.9120527E-001f);
U3 = new ComplexFloatMatrix(3);
U3[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U3[0, 1] = new ComplexFloat(-1.6666667E-001f, +1.6666667E-001f);
U3[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U3[0, 2] = new ComplexFloat(-1.5243902E-001f, +1.2804878E-001f);
U3[1, 2] = new ComplexFloat(-1.5853659E-001f, +7.3170732E-002f);
U3[2, 2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
Det3 = new ComplexFloat(-6.4000000E+001f, +3.9000000E+001f);
I3 = new ComplexFloatMatrix(3);
I3[0, 0] = new ComplexFloat(+1.4776571E-001f, -1.9120527E-001f);
I3[0, 1] = new ComplexFloat(-9.4356418E-003f, +4.1125156E-002f);
I3[0, 2] = new ComplexFloat(+1.9583408E-003f, +4.8068364E-002f);
I3[1, 0] = new ComplexFloat(+1.5310664E-002f, +1.0307994E-001f);
I3[1, 1] = new ComplexFloat(+1.3637173E-001f, -1.9814848E-001f);
I3[1, 2] = new ComplexFloat(-9.4356418E-003f, +4.1125156E-002f);
I3[2, 0] = new ComplexFloat(-3.2223607E-002f, +2.7238740E-002f);
I3[2, 1] = new ComplexFloat(+1.5310664E-002f, +1.0307994E-001f);
I3[2, 2] = new ComplexFloat(+1.4776571E-001f, -1.9120527E-001f);
X3 = new ComplexFloatVector(3);
X3[0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
X3[1] = new ComplexFloat(+2.0000000E+000f, +0.0000000E+000f);
X3[2] = new ComplexFloat(+3.0000000E+000f, +0.0000000E+000f);
Y3 = new ComplexFloatVector(3);
Y3[0] = new ComplexFloat(+8.0000000E+000f, +3.0000000E+000f);
Y3[1] = new ComplexFloat(+1.1000000E+001f, +6.0000000E+000f);
Y3[2] = new ComplexFloat(+1.4000000E+001f, +9.0000000E+000f);
// unit testing values - order 4
LC4 = new ComplexFloatVector(4);
LC4[0] = new ComplexFloat(+4.0000000E+000f, +4.0000000E+000f);
LC4[1] = new ComplexFloat(+3.0000000E+000f, +3.0000000E+000f);
LC4[2] = new ComplexFloat(+2.0000000E+000f, +2.0000000E+000f);
LC4[3] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
TR4 = new ComplexFloatVector(4);
TR4[0] = new ComplexFloat(+4.0000000E+000f, +4.0000000E+000f);
TR4[1] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
TR4[2] = new ComplexFloat(+2.0000000E+000f, +2.0000000E+000f);
TR4[3] = new ComplexFloat(+3.0000000E+000f, +3.0000000E+000f);
L4 = new ComplexFloatMatrix(4);
L4[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L4[1, 0] = new ComplexFloat(-7.5000000E-001f, +0.0000000E+000f);
L4[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L4[2, 0] = new ComplexFloat(+7.6923077E-002f, +0.0000000E+000f);
L4[2, 1] = new ComplexFloat(-7.6923077E-001f, +0.0000000E+000f);
L4[2, 2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L4[3, 0] = new ComplexFloat(+9.0909091E-002f, +0.0000000E+000f);
L4[3, 1] = new ComplexFloat(+9.0909091E-002f, +0.0000000E+000f);
L4[3, 2] = new ComplexFloat(-8.1818182E-001f, +0.0000000E+000f);
L4[3, 3] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
D4 = new ComplexFloatVector(4);
D4[0] = new ComplexFloat(+1.2500000E-001f, -1.2500000E-001f);
D4[1] = new ComplexFloat(+1.5384615E-001f, -1.5384615E-001f);
D4[2] = new ComplexFloat(+1.4772727E-001f, -1.4772727E-001f);
D4[3] = new ComplexFloat(+1.3750000E-001f, -1.3750000E-001f);
U4 = new ComplexFloatMatrix(4);
U4[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U4[0, 1] = new ComplexFloat(-2.5000000E-001f, +0.0000000E+000f);
U4[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U4[0, 2] = new ComplexFloat(-5.3846154E-001f, +0.0000000E+000f);
U4[1, 2] = new ComplexFloat(+1.5384615E-001f, +0.0000000E+000f);
U4[2, 2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U4[0, 3] = new ComplexFloat(-8.1818182E-001f, +0.0000000E+000f);
U4[1, 3] = new ComplexFloat(+9.0909091E-002f, +0.0000000E+000f);
U4[2, 3] = new ComplexFloat(+9.0909091E-002f, +0.0000000E+000f);
U4[3, 3] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
Det4 = new ComplexFloat(-6.4000000E+002f, +0.0000000E+000f);
I4 = new ComplexFloatMatrix(4);
I4[0, 0] = new ComplexFloat(+1.3750000E-001f, -1.3750000E-001f);
I4[0, 1] = new ComplexFloat(+1.2500000E-002f, -1.2500000E-002f);
I4[0, 2] = new ComplexFloat(+1.2500000E-002f, -1.2500000E-002f);
I4[0, 3] = new ComplexFloat(-1.1250000E-001f, +1.1250000E-001f);
I4[1, 0] = new ComplexFloat(-1.1250000E-001f, +1.1250000E-001f);
I4[1, 1] = new ComplexFloat(+1.3750000E-001f, -1.3750000E-001f);
I4[1, 2] = new ComplexFloat(+1.2500000E-002f, -1.2500000E-002f);
I4[1, 3] = new ComplexFloat(+1.2500000E-002f, -1.2500000E-002f);
I4[2, 0] = new ComplexFloat(+1.2500000E-002f, -1.2500000E-002f);
I4[2, 1] = new ComplexFloat(-1.1250000E-001f, +1.1250000E-001f);
I4[2, 2] = new ComplexFloat(+1.3750000E-001f, -1.3750000E-001f);
I4[2, 3] = new ComplexFloat(+1.2500000E-002f, -1.2500000E-002f);
I4[3, 0] = new ComplexFloat(+1.2500000E-002f, -1.2500000E-002f);
I4[3, 1] = new ComplexFloat(+1.2500000E-002f, -1.2500000E-002f);
I4[3, 2] = new ComplexFloat(-1.1250000E-001f, +1.1250000E-001f);
I4[3, 3] = new ComplexFloat(+1.3750000E-001f, -1.3750000E-001f);
X4 = new ComplexFloatVector(4);
X4[0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
X4[1] = new ComplexFloat(+2.0000000E+000f, +0.0000000E+000f);
X4[2] = new ComplexFloat(+3.0000000E+000f, +0.0000000E+000f);
X4[3] = new ComplexFloat(+4.0000000E+000f, +0.0000000E+000f);
Y4 = new ComplexFloatVector(4);
Y4[0] = new ComplexFloat(+2.4000000E+001f, +2.4000000E+001f);
Y4[1] = new ComplexFloat(+2.2000000E+001f, +2.2000000E+001f);
Y4[2] = new ComplexFloat(+2.4000000E+001f, +2.4000000E+001f);
Y4[3] = new ComplexFloat(+3.0000000E+001f, +3.0000000E+001f);
// unit testing values - order 5
LC5 = new ComplexFloatVector(5);
LC5[0] = new ComplexFloat(+5.0000000E+000f, +1.0000000E+000f);
LC5[1] = new ComplexFloat(+4.0000000E+000f, +1.0000000E+000f);
LC5[2] = new ComplexFloat(+3.0000000E+000f, +1.0000000E+000f);
LC5[3] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
LC5[4] = new ComplexFloat(+0.0000000E+000f, +0.0000000E+000f);
TR5 = new ComplexFloatVector(5);
TR5[0] = new ComplexFloat(+5.0000000E+000f, +1.0000000E+000f);
TR5[1] = new ComplexFloat(+1.0000000E+000f, +4.0000000E+000f);
TR5[2] = new ComplexFloat(+1.0000000E+000f, +3.0000000E+000f);
TR5[3] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
TR5[4] = new ComplexFloat(+0.0000000E+000f, +0.0000000E+000f);
L5 = new ComplexFloatMatrix(5);
L5[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L5[1, 0] = new ComplexFloat(-8.0769231E-001f, -3.8461538E-002f);
L5[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L5[2, 0] = new ComplexFloat(+3.8400000E-002f, +1.1200000E-002f);
L5[2, 1] = new ComplexFloat(-8.1280000E-001f, -7.0400000E-002f);
L5[2, 2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L5[3, 0] = new ComplexFloat(+2.2603093E-001f, +9.7680412E-002f);
L5[3, 1] = new ComplexFloat(+8.8659794E-002f, -4.9484536E-002f);
L5[3, 2] = new ComplexFloat(-8.9149485E-001f, -2.3788660E-001f);
L5[3, 3] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L5[4, 0] = new ComplexFloat(-1.1100961E-001f, +5.9189712E-002f);
L5[4, 1] = new ComplexFloat(+2.3807881E-001f, +1.3619525E-001f);
L5[4, 2] = new ComplexFloat(+1.0797070E-001f, +5.4774906E-003f);
L5[4, 3] = new ComplexFloat(-8.0625940E-001f, -2.8594254E-001f);
L5[4, 4] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
D5 = new ComplexFloatVector(5);
D5[0] = new ComplexFloat(+1.9230769E-001f, -3.8461538E-002f);
D5[1] = new ComplexFloat(+1.8080000E-001f, +9.4400000E-002f);
D5[2] = new ComplexFloat(+1.8015464E-001f, +8.8402062E-002f);
D5[3] = new ComplexFloat(+1.5698660E-001f, +6.5498707E-002f);
D5[4] = new ComplexFloat(+1.6335863E-001f, +5.3379923E-002f);
U5 = new ComplexFloatMatrix(5);
U5[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U5[0, 1] = new ComplexFloat(-3.4615385E-001f, -7.3076923E-001f);
U5[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U5[0, 2] = new ComplexFloat(-5.6320000E-001f, -4.9760000E-001f);
U5[1, 2] = new ComplexFloat(+8.9600000E-002f, -3.0720000E-001f);
U5[2, 2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U5[0, 3] = new ComplexFloat(-7.7757732E-001f, +1.8298969E-002f);
U5[1, 3] = new ComplexFloat(+7.0103093E-002f, -4.5773196E-001f);
U5[2, 3] = new ComplexFloat(+5.9536082E-002f, -3.1520619E-001f);
U5[3, 3] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U5[0, 4] = new ComplexFloat(-3.8732272E-001f, +5.0102819E-001f);
U5[1, 4] = new ComplexFloat(-3.1309322E-001f, -3.3622620E-001f);
U5[2, 4] = new ComplexFloat(+6.0556288E-002f, -3.9414442E-001f);
U5[3, 4] = new ComplexFloat(-7.6951473E-002f, -2.3979216E-001f);
U5[4, 4] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
Det5 = new ComplexFloat(+5.0900000E+002f, -4.2310000E+003f);
I5 = new ComplexFloatMatrix(5);
I5[0, 0] = new ComplexFloat(+1.6335863E-001f, +5.3379923E-002f);
I5[0, 1] = new ComplexFloat(+2.2939970E-004f, -4.3279784E-002f);
I5[0, 2] = new ComplexFloat(+3.0931791E-002f, -6.1154404E-002f);
I5[0, 3] = new ComplexFloat(-3.3198751E-002f, -7.1638344E-002f);
I5[0, 4] = new ComplexFloat(-9.0017358E-002f, +6.1172024E-002f);
I5[1, 0] = new ComplexFloat(-1.1644584E-001f, -8.9749247E-002f);
I5[1, 1] = new ComplexFloat(+1.4442611E-001f, +1.0032784E-001f);
I5[1, 2] = new ComplexFloat(-1.2433728E-002f, -5.1220119E-003f);
I5[1, 3] = new ComplexFloat(+4.7268453E-002f, -1.4096573E-005f);
I5[1, 4] = new ComplexFloat(-3.3198751E-002f, -7.1638344E-002f);
I5[2, 0] = new ComplexFloat(+1.7345558E-002f, +6.6582631E-003f);
I5[2, 1] = new ComplexFloat(-1.2410964E-001f, -1.0040846E-001f);
I5[2, 2] = new ComplexFloat(+1.4624793E-001f, +1.1547147E-001f);
I5[2, 3] = new ComplexFloat(-1.2433728E-002f, -5.1220119E-003f);
I5[2, 4] = new ComplexFloat(+3.0931791E-002f, -6.1154404E-002f);
I5[3, 0] = new ComplexFloat(+3.1622138E-002f, +3.4957299E-002f);
I5[3, 1] = new ComplexFloat(+2.3108689E-002f, -1.2234063E-002f);
I5[3, 2] = new ComplexFloat(-1.2410964E-001f, -1.0040846E-001f);
I5[3, 3] = new ComplexFloat(+1.4442611E-001f, +1.0032784E-001f);
I5[3, 4] = new ComplexFloat(+2.2939970E-004f, -4.3279784E-002f);
I5[4, 0] = new ComplexFloat(-2.1293920E-002f, +3.7434662E-003f);
I5[4, 1] = new ComplexFloat(+3.1622138E-002f, +3.4957299E-002f);
I5[4, 2] = new ComplexFloat(+1.7345558E-002f, +6.6582631E-003f);
I5[4, 3] = new ComplexFloat(-1.1644584E-001f, -8.9749247E-002f);
I5[4, 4] = new ComplexFloat(+1.6335863E-001f, +5.3379923E-002f);
X5 = new ComplexFloatVector(5);
X5[0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
X5[1] = new ComplexFloat(+2.0000000E+000f, +0.0000000E+000f);
X5[2] = new ComplexFloat(+3.0000000E+000f, +0.0000000E+000f);
X5[3] = new ComplexFloat(+4.0000000E+000f, +0.0000000E+000f);
X5[4] = new ComplexFloat(+5.0000000E+000f, +0.0000000E+000f);
Y5 = new ComplexFloatVector(5);
Y5[0] = new ComplexFloat(+1.4000000E+001f, +2.2000000E+001f);
Y5[1] = new ComplexFloat(+2.6000000E+001f, +3.2000000E+001f);
Y5[2] = new ComplexFloat(+3.5000000E+001f, +3.7000000E+001f);
Y5[3] = new ComplexFloat(+4.4000000E+001f, +3.0000000E+001f);
Y5[4] = new ComplexFloat(+5.2000000E+001f, +1.4000000E+001f);
// unit testing values - order 10
LC10 = new ComplexFloatVector(10);
LC10[0] = new ComplexFloat(+1.0000000E+001f, +1.0000000E+000f);
LC10[1] = new ComplexFloat(+9.0000000E+000f, +1.0000000E+000f);
LC10[2] = new ComplexFloat(+8.0000000E+000f, +1.0000000E+000f);
LC10[3] = new ComplexFloat(+7.0000000E+000f, +1.0000000E+000f);
LC10[4] = new ComplexFloat(+6.0000000E+000f, +1.0000000E+000f);
LC10[5] = new ComplexFloat(+5.0000000E+000f, +1.0000000E+000f);
LC10[6] = new ComplexFloat(+4.0000000E+000f, +1.0000000E+000f);
LC10[7] = new ComplexFloat(+3.0000000E+000f, +1.0000000E+000f);
LC10[8] = new ComplexFloat(+2.0000000E+000f, +1.0000000E+000f);
LC10[9] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
TR10 = new ComplexFloatVector(10);
TR10[0] = new ComplexFloat(+1.0000000E+001f, +1.0000000E+000f);
TR10[1] = new ComplexFloat(+1.0000000E+000f, +9.0000000E+000f);
TR10[2] = new ComplexFloat(+1.0000000E+000f, +8.0000000E+000f);
TR10[3] = new ComplexFloat(+1.0000000E+000f, +2.0000000E+000f);
TR10[4] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
TR10[5] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
TR10[6] = new ComplexFloat(+1.0000000E+000f, +4.0000000E+000f);
TR10[7] = new ComplexFloat(+1.0000000E+000f, +3.0000000E+000f);
TR10[8] = new ComplexFloat(+1.0000000E+000f, +2.0000000E+000f);
TR10[9] = new ComplexFloat(+1.0000000E+000f, +1.0000000E+000f);
L10 = new ComplexFloatMatrix(10);
L10[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L10[1, 0] = new ComplexFloat(-9.0099010E-001f, -9.9009901E-003f);
L10[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L10[2, 0] = new ComplexFloat(+7.2554049E-003f, +4.5437889E-003f);
L10[2, 1] = new ComplexFloat(-8.9835104E-001f, -1.7149139E-002f);
L10[2, 2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L10[3, 0] = new ComplexFloat(+8.1190931E-003f, +4.8283630E-003f);
L10[3, 1] = new ComplexFloat(+8.5500220E-003f, +3.8783605E-003f);
L10[3, 2] = new ComplexFloat(-8.9685128E-001f, -2.5375839E-002f);
L10[3, 3] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L10[4, 0] = new ComplexFloat(+9.0797285E-003f, +5.0413564E-003f);
L10[4, 1] = new ComplexFloat(+9.5223197E-003f, +3.9833209E-003f);
L10[4, 2] = new ComplexFloat(+1.3594954E-002f, +1.3510004E-003f);
L10[4, 3] = new ComplexFloat(-9.0106887E-001f, -3.2599942E-002f);
L10[4, 4] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L10[5, 0] = new ComplexFloat(+1.0110174E-002f, +5.1587582E-003f);
L10[5, 1] = new ComplexFloat(+1.0553084E-002f, +3.9861933E-003f);
L10[5, 2] = new ComplexFloat(+1.4900585E-002f, +9.5517949E-004f);
L10[5, 3] = new ComplexFloat(+1.4574245E-002f, -1.1129242E-003f);
L10[5, 4] = new ComplexFloat(-9.0776628E-001f, -3.8281015E-002f);
L10[5, 5] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L10[6, 0] = new ComplexFloat(+1.1163789E-002f, +5.1884795E-003f);
L10[6, 1] = new ComplexFloat(+1.1597112E-002f, +3.8999115E-003f);
L10[6, 2] = new ComplexFloat(+1.6188452E-002f, +4.4138654E-004f);
L10[6, 3] = new ComplexFloat(+1.5752309E-002f, -1.7871732E-003f);
L10[6, 4] = new ComplexFloat(+1.4568519E-002f, -5.3100094E-003f);
L10[6, 5] = new ComplexFloat(-9.1612446E-001f, -3.9858108E-002f);
L10[6, 6] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L10[7, 0] = new ComplexFloat(+1.2250407E-002f, +5.1493111E-003f);
L10[7, 1] = new ComplexFloat(+1.2666180E-002f, +3.7419578E-003f);
L10[7, 2] = new ComplexFloat(+1.7480233E-002f, -1.7281679E-004f);
L10[7, 3] = new ComplexFloat(+1.6920428E-002f, -2.5592884E-003f);
L10[7, 4] = new ComplexFloat(+1.5502251E-002f, -6.3119298E-003f);
L10[7, 5] = new ComplexFloat(+1.0175586E-002f, -6.2706520E-003f);
L10[7, 6] = new ComplexFloat(-9.2129653E-001f, -4.0086723E-002f);
L10[7, 7] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L10[8, 0] = new ComplexFloat(+1.3361099E-002f, +5.0636594E-003f);
L10[8, 1] = new ComplexFloat(+1.3753926E-002f, +3.5354454E-003f);
L10[8, 2] = new ComplexFloat(+1.8776835E-002f, -8.5571402E-004f);
L10[8, 3] = new ComplexFloat(+1.8083822E-002f, -3.3986502E-003f);
L10[8, 4] = new ComplexFloat(+1.6416076E-002f, -7.3767089E-003f);
L10[8, 5] = new ComplexFloat(+1.0693868E-002f, -7.1281839E-003f);
L10[8, 6] = new ComplexFloat(+8.4803223E-003f, -7.7622936E-003f);
L10[8, 7] = new ComplexFloat(-9.2544568E-001f, -3.8329752E-002f);
L10[8, 8] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
L10[9, 0] = new ComplexFloat(+1.4514517E-002f, +4.9086455E-003f);
L10[9, 1] = new ComplexFloat(+1.4876264E-002f, +3.2557272E-003f);
L10[9, 2] = new ComplexFloat(+2.0088847E-002f, -1.6446645E-003f);
L10[9, 3] = new ComplexFloat(+1.9247642E-002f, -4.3429207E-003f);
L10[9, 4] = new ComplexFloat(+1.7306259E-002f, -8.5413384E-003f);
L10[9, 5] = new ComplexFloat(+1.1183742E-002f, -8.0532599E-003f);
L10[9, 6] = new ComplexFloat(+8.7870452E-003f, -8.6470170E-003f);
L10[9, 7] = new ComplexFloat(+6.7700213E-003f, -5.2124680E-003f);
L10[9, 8] = new ComplexFloat(-9.2836000E-001f, -3.8752385E-002f);
L10[9, 9] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
D10 = new ComplexFloatVector(10);
D10[0] = new ComplexFloat(+9.9009901E-002f, -9.9009901E-003f);
D10[1] = new ComplexFloat(+6.8010260E-002f, +5.2693294E-002f);
D10[2] = new ComplexFloat(+6.8503012E-002f, +5.2264825E-002f);
D10[3] = new ComplexFloat(+6.8598237E-002f, +5.1618595E-002f);
D10[4] = new ComplexFloat(+6.8466983E-002f, +5.0945485E-002f);
D10[5] = new ComplexFloat(+6.8034270E-002f, +5.0441605E-002f);
D10[6] = new ComplexFloat(+6.7730052E-002f, +5.0175369E-002f);
D10[7] = new ComplexFloat(+6.7391349E-002f, +5.0080104E-002f);
D10[8] = new ComplexFloat(+6.7234262E-002f, +4.9912171E-002f);
D10[9] = new ComplexFloat(+6.7024327E-002f, +4.9751098E-002f);
U10 = new ComplexFloatMatrix(10);
U10[0, 0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U10[0, 1] = new ComplexFloat(-1.8811881E-001f, -8.8118812E-001f);
U10[1, 1] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U10[0, 2] = new ComplexFloat(-3.0868450E-001f, -8.2968120E-001f);
U10[1, 2] = new ComplexFloat(+8.1788201E-002f, -1.3059729E-001f);
U10[2, 2] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U10[0, 3] = new ComplexFloat(-6.9271338E-001f, -4.1101317E-001f);
U10[1, 3] = new ComplexFloat(+3.0656677E-001f, -4.4856765E-001f);
U10[2, 3] = new ComplexFloat(+7.8629842E-002f, -1.3672690E-001f);
U10[3, 3] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U10[0, 4] = new ComplexFloat(-7.5308973E-001f, -1.7764936E-001f);
U10[1, 4] = new ComplexFloat(-2.1811893E-002f, -2.3257783E-001f);
U10[2, 4] = new ComplexFloat(+3.0081682E-001f, -4.5300731E-001f);
U10[3, 4] = new ComplexFloat(+7.3373192E-002f, -1.4180544E-001f);
U10[4, 4] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U10[0, 5] = new ComplexFloat(-6.6968846E-001f, +1.6997563E-001f);
U10[1, 5] = new ComplexFloat(-1.4411312E-001f, -3.0897730E-001f);
U10[2, 5] = new ComplexFloat(-3.1145914E-002f, -2.3117177E-001f);
U10[3, 5] = new ComplexFloat(+2.9376277E-001f, -4.5405633E-001f);
U10[4, 5] = new ComplexFloat(+6.6435695E-002f, -1.4363825E-001f);
U10[5, 5] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U10[0, 6] = new ComplexFloat(-3.6546783E-001f, +1.3495818E-001f);
U10[1, 6] = new ComplexFloat(-3.3276275E-001f, +6.1455619E-002f);
U10[2, 6] = new ComplexFloat(-1.4928934E-001f, -3.0660365E-001f);
U10[3, 6] = new ComplexFloat(-3.6720508E-002f, -2.2950990E-001f);
U10[4, 6] = new ComplexFloat(+2.8936799E-001f, -4.5408893E-001f);
U10[5, 6] = new ComplexFloat(+6.2044535E-002f, -1.4415916E-001f);
U10[6, 6] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U10[0, 7] = new ComplexFloat(-2.2796156E-001f, +2.1789305E-001f);
U10[1, 7] = new ComplexFloat(-1.4794186E-001f, -5.5572852E-002f);
U10[2, 7] = new ComplexFloat(-3.3492680E-001f, +6.5840476E-002f);
U10[3, 7] = new ComplexFloat(-1.5249085E-001f, -3.0276392E-001f);
U10[4, 7] = new ComplexFloat(-4.0507028E-002f, -2.2608317E-001f);
U10[5, 7] = new ComplexFloat(+2.8587453E-001f, -4.5245103E-001f);
U10[6, 7] = new ComplexFloat(+5.8369087E-002f, -1.4290942E-001f);
U10[7, 7] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U10[0, 8] = new ComplexFloat(-1.8901586E-001f, +3.4805079E-002f);
U10[1, 8] = new ComplexFloat(-5.2426683E-002f, +1.9340427E-001f);
U10[2, 8] = new ComplexFloat(-1.4964696E-001f, -5.4033437E-002f);
U10[3, 8] = new ComplexFloat(-3.3763728E-001f, +6.7573088E-002f);
U10[4, 8] = new ComplexFloat(-1.5560000E-001f, -3.0169126E-001f);
U10[5, 8] = new ComplexFloat(-4.3805054E-002f, -2.2544210E-001f);
U10[6, 8] = new ComplexFloat(+2.8335018E-001f, -4.5271747E-001f);
U10[7, 8] = new ComplexFloat(+5.5874343E-002f, -1.4345634E-001f);
U10[8, 8] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
U10[0, 9] = new ComplexFloat(-1.9701952E-001f, +6.3155749E-002f);
U10[1, 9] = new ComplexFloat(-4.2642564E-003f, -1.6090427E-002f);
U10[2, 9] = new ComplexFloat(-5.3607239E-002f, +1.9546918E-001f);
U10[3, 9] = new ComplexFloat(-1.5130367E-001f, -5.1953666E-002f);
U10[4, 9] = new ComplexFloat(-3.4040569E-001f, +7.0063213E-002f);
U10[5, 9] = new ComplexFloat(-1.5894822E-001f, -2.9987956E-001f);
U10[6, 9] = new ComplexFloat(-4.7450414E-002f, -2.2408765E-001f);
U10[7, 9] = new ComplexFloat(+2.8041710E-001f, -4.5254539E-001f);
U10[8, 9] = new ComplexFloat(+5.2922147E-002f, -1.4361015E-001f);
U10[9, 9] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
Det10 = new ComplexFloat(+3.6568548E+010f, +2.4768517E+010f);
I10 = new ComplexFloatMatrix(10);
I10[0, 0] = new ComplexFloat(+6.7024327E-002f, +4.9751098E-002f);
I10[0, 1] = new ComplexFloat(+1.0691834E-002f, -6.9924390E-003f);
I10[0, 2] = new ComplexFloat(+4.1309398E-002f, -1.6380491E-002f);
I10[0, 3] = new ComplexFloat(+7.9682744E-003f, -1.7380034E-002f);
I10[0, 4] = new ComplexFloat(+4.2659401E-003f, -2.8007075E-002f);
I10[0, 5] = new ComplexFloat(-2.6301184E-002f, -1.2239617E-002f);
I10[0, 6] = new ComplexFloat(-7.5562748E-003f, -1.1009683E-002f);
I10[0, 7] = new ComplexFloat(-1.3317795E-002f, +1.0434171E-002f);
I10[0, 8] = new ComplexFloat(+5.1470750E-004f, -1.2906015E-003f);
I10[0, 9] = new ComplexFloat(-1.6347168E-002f, -5.5689657E-003f);
I10[1, 0] = new ComplexFloat(-6.0294731E-002f, -4.8784282E-002f);
I10[1, 1] = new ComplexFloat(+5.7037418E-002f, +5.5989338E-002f);
I10[1, 2] = new ComplexFloat(-2.8067888E-002f, +6.7497836E-003f);
I10[1, 3] = new ComplexFloat(+3.3576008E-002f, -4.6936404E-004f);
I10[1, 4] = new ComplexFloat(+3.2614353E-003f, +8.4914935E-003f);
I10[1, 5] = new ComplexFloat(+2.8539068E-002f, -1.5668319E-002f);
I10[1, 6] = new ComplexFloat(-1.9485222E-002f, -1.7952100E-003f);
I10[1, 7] = new ComplexFloat(+5.4035811E-003f, -2.0272674E-002f);
I10[1, 8] = new ComplexFloat(-1.3705944E-002f, +1.1564861E-002f);
I10[1, 9] = new ComplexFloat(+5.1470750E-004f, -1.2906015E-003f);
I10[2, 0] = new ComplexFloat(+7.1308213E-004f, -1.2546164E-005f);
I10[2, 1] = new ComplexFloat(-6.0272601E-002f, -4.8871146E-002f);
I10[2, 2] = new ComplexFloat(+5.7219842E-002f, +5.5680641E-002f);
I10[2, 3] = new ComplexFloat(-2.8112753E-002f, +6.6173592E-003f);
I10[2, 4] = new ComplexFloat(+3.3454600E-002f, -6.5413224E-004f);
I10[2, 5] = new ComplexFloat(+3.0216929E-003f, +8.5724569E-003f);
I10[2, 6] = new ComplexFloat(+2.8435161E-002f, -1.5684889E-002f);
I10[2, 7] = new ComplexFloat(-1.9514358E-002f, -1.6393606E-003f);
I10[2, 8] = new ComplexFloat(+5.4035811E-003f, -2.0272674E-002f);
I10[2, 9] = new ComplexFloat(-1.3317795E-002f, +1.0434171E-002f);
I10[3, 0] = new ComplexFloat(+1.0191444E-003f, -1.4239535E-004f);
I10[3, 1] = new ComplexFloat(+9.9108704E-004f, -2.5251613E-004f);
I10[3, 2] = new ComplexFloat(-5.9819166E-002f, -4.9484148E-002f);
I10[3, 3] = new ComplexFloat(+5.7389952E-002f, +5.5227507E-002f);
I10[3, 4] = new ComplexFloat(-2.8106424E-002f, +6.0757008E-003f);
I10[3, 5] = new ComplexFloat(+3.3259014E-002f, -8.2858379E-004f);
I10[3, 6] = new ComplexFloat(+2.9250084E-003f, +8.3171088E-003f);
I10[3, 7] = new ComplexFloat(+2.8435161E-002f, -1.5684889E-002f);
I10[3, 8] = new ComplexFloat(-1.9485222E-002f, -1.7952100E-003f);
I10[3, 9] = new ComplexFloat(-7.5562748E-003f, -1.1009683E-002f);
I10[4, 0] = new ComplexFloat(+1.1502413E-003f, +1.6639121E-005f);
I10[4, 1] = new ComplexFloat(+1.1380402E-003f, -1.0980979E-004f);
I10[4, 2] = new ComplexFloat(+1.3977289E-003f, -5.8000250E-004f);
I10[4, 3] = new ComplexFloat(-5.9700112E-002f, -4.9533948E-002f);
I10[4, 4] = new ComplexFloat(+5.7405368E-002f, +5.5059022E-002f);
I10[4, 5] = new ComplexFloat(-2.8274330E-002f, +6.2766221E-003f);
I10[4, 6] = new ComplexFloat(+3.3259014E-002f, -8.2858379E-004f);
I10[4, 7] = new ComplexFloat(+3.0216929E-003f, +8.5724569E-003f);
I10[4, 8] = new ComplexFloat(+2.8539068E-002f, -1.5668319E-002f);
I10[4, 9] = new ComplexFloat(-2.6301184E-002f, -1.2239617E-002f);
I10[5, 0] = new ComplexFloat(+1.5848813E-003f, +2.8852793E-004f);
I10[5, 1] = new ComplexFloat(+1.5972212E-003f, +1.1105891E-004f);
I10[5, 2] = new ComplexFloat(+2.0644546E-003f, -4.7842310E-004f);
I10[5, 3] = new ComplexFloat(+1.9356717E-003f, -7.4622243E-004f);
I10[5, 4] = new ComplexFloat(-5.9306111E-002f, -4.9933722E-002f);
I10[5, 5] = new ComplexFloat(+5.7405368E-002f, +5.5059022E-002f);
I10[5, 6] = new ComplexFloat(-2.8106424E-002f, +6.0757008E-003f);
I10[5, 7] = new ComplexFloat(+3.3454600E-002f, -6.5413224E-004f);
I10[5, 8] = new ComplexFloat(+3.2614353E-003f, +8.4914935E-003f);
I10[5, 9] = new ComplexFloat(+4.2659401E-003f, -2.8007075E-002f);
I10[6, 0] = new ComplexFloat(+1.5061253E-003f, +6.6650996E-004f);
I10[6, 1] = new ComplexFloat(+1.5609115E-003f, +4.9307536E-004f);
I10[6, 2] = new ComplexFloat(+2.1665459E-003f, +1.9121555E-005f);
I10[6, 3] = new ComplexFloat(+2.1027094E-003f, -2.7790747E-004f);
I10[6, 4] = new ComplexFloat(+1.9356717E-003f, -7.4622243E-004f);
I10[6, 5] = new ComplexFloat(-5.9700112E-002f, -4.9533948E-002f);
I10[6, 6] = new ComplexFloat(+5.7389952E-002f, +5.5227507E-002f);
I10[6, 7] = new ComplexFloat(-2.8112753E-002f, +6.6173592E-003f);
I10[6, 8] = new ComplexFloat(+3.3576008E-002f, -4.6936404E-004f);
I10[6, 9] = new ComplexFloat(+7.9682744E-003f, -1.7380034E-002f);
I10[7, 0] = new ComplexFloat(+1.4282653E-003f, +8.8920966E-004f);
I10[7, 1] = new ComplexFloat(+1.5084436E-003f, +7.2160481E-004f);
I10[7, 2] = new ComplexFloat(+2.1887064E-003f, +3.2867753E-004f);
I10[7, 3] = new ComplexFloat(+2.1665459E-003f, +1.9121555E-005f);
I10[7, 4] = new ComplexFloat(+2.0644546E-003f, -4.7842310E-004f);
I10[7, 5] = new ComplexFloat(+1.3977289E-003f, -5.8000250E-004f);
I10[7, 6] = new ComplexFloat(-5.9819166E-002f, -4.9484148E-002f);
I10[7, 7] = new ComplexFloat(+5.7219842E-002f, +5.5680641E-002f);
I10[7, 8] = new ComplexFloat(-2.8067888E-002f, +6.7497836E-003f);
I10[7, 9] = new ComplexFloat(+4.1309398E-002f, -1.6380491E-002f);
I10[8, 0] = new ComplexFloat(+8.3509562E-004f, +9.5832342E-004f);
I10[8, 1] = new ComplexFloat(+9.3009336E-004f, +8.5497971E-004f);
I10[8, 2] = new ComplexFloat(+1.5084436E-003f, +7.2160481E-004f);
I10[8, 3] = new ComplexFloat(+1.5609115E-003f, +4.9307536E-004f);
I10[8, 4] = new ComplexFloat(+1.5972212E-003f, +1.1105891E-004f);
I10[8, 5] = new ComplexFloat(+1.1380402E-003f, -1.0980979E-004f);
I10[8, 6] = new ComplexFloat(+9.9108704E-004f, -2.5251613E-004f);
I10[8, 7] = new ComplexFloat(-6.0272601E-002f, -4.8871146E-002f);
I10[8, 8] = new ComplexFloat(+5.7037418E-002f, +5.5989338E-002f);
I10[8, 9] = new ComplexFloat(+1.0691834E-002f, -6.9924390E-003f);
I10[9, 0] = new ComplexFloat(+7.2861524E-004f, +1.0511118E-003f);
I10[9, 1] = new ComplexFloat(+8.3509562E-004f, +9.5832342E-004f);
I10[9, 2] = new ComplexFloat(+1.4282653E-003f, +8.8920966E-004f);
I10[9, 3] = new ComplexFloat(+1.5061253E-003f, +6.6650996E-004f);
I10[9, 4] = new ComplexFloat(+1.5848813E-003f, +2.8852793E-004f);
I10[9, 5] = new ComplexFloat(+1.1502413E-003f, +1.6639121E-005f);
I10[9, 6] = new ComplexFloat(+1.0191444E-003f, -1.4239535E-004f);
I10[9, 7] = new ComplexFloat(+7.1308213E-004f, -1.2546164E-005f);
I10[9, 8] = new ComplexFloat(-6.0294731E-002f, -4.8784282E-002f);
I10[9, 9] = new ComplexFloat(+6.7024327E-002f, +4.9751098E-002f);
X10 = new ComplexFloatVector(10);
X10[0] = new ComplexFloat(+1.0000000E+000f, +0.0000000E+000f);
X10[1] = new ComplexFloat(+2.0000000E+000f, +0.0000000E+000f);
X10[2] = new ComplexFloat(+3.0000000E+000f, +0.0000000E+000f);
X10[3] = new ComplexFloat(+4.0000000E+000f, +0.0000000E+000f);
X10[4] = new ComplexFloat(+5.0000000E+000f, +0.0000000E+000f);
X10[5] = new ComplexFloat(+6.0000000E+000f, +0.0000000E+000f);
X10[6] = new ComplexFloat(+7.0000000E+000f, +0.0000000E+000f);
X10[7] = new ComplexFloat(+8.0000000E+000f, +0.0000000E+000f);
X10[8] = new ComplexFloat(+9.0000000E+000f, +0.0000000E+000f);
X10[9] = new ComplexFloat(+1.0000000E+001f, +0.0000000E+000f);
Y10 = new ComplexFloatVector(10);
Y10[0] = new ComplexFloat(+6.4000000E+001f, +1.4200000E+002f);
Y10[1] = new ComplexFloat(+8.1000000E+001f, +1.6400000E+002f);
Y10[2] = new ComplexFloat(+1.0500000E+002f, +1.7500000E+002f);
Y10[3] = new ComplexFloat(+1.3500000E+002f, +1.7400000E+002f);
Y10[4] = new ComplexFloat(+1.7000000E+002f, +1.6000000E+002f);
Y10[5] = new ComplexFloat(+2.0900000E+002f, +1.7600000E+002f);
Y10[6] = new ComplexFloat(+2.5100000E+002f, +1.9200000E+002f);
Y10[7] = new ComplexFloat(+2.9500000E+002f, +1.9700000E+002f);
Y10[8] = new ComplexFloat(+3.4000000E+002f, +1.3500000E+002f);
Y10[9] = new ComplexFloat(+3.8500000E+002f, +5.5000000E+001f);
// Tolerances
Tolerance1 = 1.000E-06f;
Tolerance2 = 2.000E-06f;
Tolerance3 = 1.000E-06f;
Tolerance4 = 1.000E-05f;
Tolerance5 = 1.000E-05f;
Tolerance10 = 5.000E-05f;
}
public void SingularityPropertyTest2()
{
ComplexFloatVector LC = new ComplexFloatVector(4);
LC[0] = new ComplexFloat(4.0f);
LC[1] = new ComplexFloat(2.0f);
LC[2] = new ComplexFloat(1.0f);
LC[3] = new ComplexFloat(0.0f);
ComplexFloatVector TR = new ComplexFloatVector(4);
TR[0] = new ComplexFloat(4.0f);
TR[1] = new ComplexFloat(8.0f);
TR[2] = new ComplexFloat(2.0f);
TR[3] = new ComplexFloat(1.0f);
ComplexFloatLevinson cfl = new ComplexFloatLevinson(LC,TR);
Assert.IsTrue(cfl.IsSingular);
}
public void FirstElementTestforStaticSolveVector()
{
ComplexFloatVector cfv = new ComplexFloatVector(3, 1.0f);
ComplexFloatVector X = ComplexFloatLevinson.Solve(cfv, TR3, Y3);
}
public void ZeroVectorLengthTestforStaticSolveVector()
{
ComplexFloatVector LC = new ComplexFloatVector(1);
LC.RemoveAt(0);
ComplexFloatVector X = ComplexFloatLevinson.Solve(LC, TR10, Y10);
}
public void FirstElementTestforStaticInverse()
{
ComplexFloatVector cfv = new ComplexFloatVector(3, 1.0f);
ComplexFloatMatrix X = ComplexFloatLevinson.Inverse(cfv, TR3);
}
public void SingularTestforStaticSolveVector()
{
ComplexFloatVector cfv = new ComplexFloatVector(3, 1.0f);
ComplexFloatVector X = ComplexFloatLevinson.Solve(cfv, cfv, Y3);
}
public void ZeroLengthVectorTestsforConstructor1()
{
ComplexFloatVector cfv = new ComplexFloatVector(1);
cfv.RemoveAt(0);
ComplexFloatLevinson cfl = new ComplexFloatLevinson(cfv, cfv);
}
public void FirstElementTestforStaticSolveMatrix()
{
ComplexFloatVector cfv = new ComplexFloatVector(3, 1.0f);
ComplexFloatMatrix X = ComplexFloatLevinson.Solve(cfv, TR3, ComplexFloatMatrix.CreateIdentity(3));
}
/// <summary>Performs the QR factorization.</summary>
protected override void InternalCompute()
{
int m = matrix.Rows;
int n = matrix.Columns;
#if MANAGED
int minmn = m < n ? m : n;
r_ = new ComplexFloatMatrix(matrix); // create a copy
var u = new ComplexFloatVector[minmn];
for (int i = 0; i < minmn; i++)
{
u[i] = Householder.GenerateColumn(r_, i, m - 1, i);
Householder.UA(u[i], r_, i, m - 1, i + 1, n - 1);
}
q_ = ComplexFloatMatrix.CreateIdentity(m);
for (int i = minmn - 1; i >= 0; i--)
{
Householder.UA(u[i], q_, i, m - 1, i, m - 1);
}
#else
qr = ComplexFloatMatrix.ToLinearComplexArray(matrix);
jpvt = new int[n];
jpvt[0] = 1;
Lapack.Geqp3.Compute(m, n, qr, m, jpvt, out tau);
r_ = new ComplexFloatMatrix(m, n);
// Populate R
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i <= j)
{
r_.data[j * m + i] = qr[(jpvt[j] - 1) * m + i];
}
else
{
r_.data[j * m + i] = ComplexFloat.Zero;
}
}
}
q_ = new ComplexFloatMatrix(m, m);
for (int i = 0; i < m; i++)
{
for (int j = 0; j < m; j++)
{
if (j < n)
{
q_.data[j * m + i] = qr[j * m + i];
}
else
{
q_.data[j * m + i] = ComplexFloat.Zero;
}
}
}
if (m < n)
{
Lapack.Ungqr.Compute(m, m, m, q_.data, m, tau);
}
else
{
Lapack.Ungqr.Compute(m, m, n, q_.data, m, tau);
}
#endif
for (int i = 0; i < m; i++)
{
if (q_[i, i] == 0)
{
isFullRank = false;
}
}
}
public void ZeroVectorLengthTestforStaticInverse()
{
ComplexFloatVector LC = new ComplexFloatVector(1);
LC.RemoveAt(0);
ComplexFloatMatrix X = ComplexFloatLevinson.Inverse(LC, LC);
}
/// <summary>
/// Invert a symmetric square Toeplitz matrix.
/// </summary>
/// <param name="T">The left-most column of the symmetric Toeplitz matrix.</param>
/// <returns>The inverse matrix.</returns>
/// <exception cref="ArgumentNullException">
/// <B>T</B> is a null reference.
/// </exception>
/// <exception cref="RankException">
/// The length of <B>T</B> must be greater than zero.
/// </exception>
/// <exception cref="SingularMatrixException">
/// The Toeplitz matrix or one of the the leading sub-matrices is singular.
/// </exception>
/// <remarks>
/// This static member combines the <b>UDL</b> decomposition and Trench's algorithm into a
/// single algorithm. When compared to the non-static member it requires minimal data storage
/// and suffers from no speed penalty.
/// <para>
/// Trench's algorithm requires <b>N</b> squared FLOPS, compared to <b>N</b> cubed FLOPS
/// if we simply solved a linear Toeplitz system with a right-side identity matrix (<b>N</b> is the matrix order).
/// </para>
/// </remarks>
public static ComplexFloatMatrix Inverse(IROComplexFloatVector T)
{
ComplexFloatMatrix X;
// check parameters
if (T == null)
{
throw new System.ArgumentNullException("T");
}
else if (T.Length < 1)
{
throw new System.RankException("The length of T must be greater than zero.");
}
else if (T.Length == 1)
{
X = new ComplexFloatMatrix(1);
X[0, 0] = ComplexFloat.One / T[0];
}
else
{
int N = T.Length;
ComplexFloat f, g;
int i, j, l, k, m, n;
X = new ComplexFloatMatrix(N);
// calculate the predictor coefficients
ComplexFloatVector Y = ComplexFloatSymmetricLevinson.YuleWalker(T);
// calculate gamma
f = T[0];
for (i = 1, j = 0; i < N; i++, j++)
{
f += T[i] * Y[j];
}
g = ComplexFloat.One / f;
// calculate first row of inverse
X[0, 0] = g;
for (i = 1, j = 0; i < N; i++, j++)
{
X[0, i] = g * Y[j];
}
// calculate successive rows of upper wedge
for (i = 0, j = 1, k = N - 2; i < N / 2; i++, j++, k--)
{
for (l = j, m = i, n = N - 1 - j; l < N - j; l++, m++, n--)
{
X[j, l] = X[i, m] + g * (Y[i] * Y[m] - Y[k] * Y[n]);
}
}
// this is symmetric matrix ...
for (i = 0; i <= N / 2; i++)
{
for (j = i + 1; j < N - i; j++)
{
X[j, i] = X[i, j];
}
}
// and a persymmetric matrix.
for (i = 0, j = N - 1; i < N; i++, j--)
{
for (k = 0, l = N - 1; k < j; k++, l--)
{
X[l, j] = X[i, k];
}
}
}
return(X);
}
public void SingularTestforStaticInverse()
{
ComplexFloatVector cfv = new ComplexFloatVector(3, 1.0f);
ComplexFloatMatrix X = ComplexFloatLevinson.Inverse(cfv, cfv);
}
public void OperatorMultiplyNullMatrixVector()
{
ComplexFloatMatrix a = null;
ComplexFloatVector b = new ComplexFloatVector(2, 2.0f);
ComplexFloatVector c = a * b;
}
public void FirstElementTestforConstructor1()
{
ComplexFloatVector cfv = new ComplexFloatVector(3, ComplexFloat.One);
ComplexFloatLevinson cfl = new ComplexFloatLevinson(LC3, cfv);
}
public void StaticMultiplyMatrixVector()
{
ComplexFloatMatrix a = new ComplexFloatMatrix(2);
a[0,0] = new ComplexFloat(1);
a[0,1] = new ComplexFloat(2);
a[1,0] = new ComplexFloat(3);
a[1,1] = new ComplexFloat(4);
ComplexFloatVector b = new ComplexFloatVector(2, 2.0f);
ComplexFloatVector c = ComplexFloatMatrix.Multiply(a,b);
Assert.AreEqual(c[0],new ComplexFloat(6));
Assert.AreEqual(c[1],new ComplexFloat(14));
}