/// Returns a finder to find the next largest eigen value of the receiver's matrix.
/// @return DhbMatrixAlgebra.LargestEigenvalueFinder
public LargestEigenvalueFinder NextLargestEigenvalueFinder()
{
double norm = 1.0 / _eigenvector.SecureProduct(_transposedEigenvector);
DhbVector v1 = _eigenvector * norm;
return(new LargestEigenvalueFinder(this.DesiredPrecision,
_matrix.SecureProduct(SymmetricMatrix.IdentityMatrix(v1.Dimension)
.SecureSubtract(v1.TensorProduct(_transposedEigenvector)))));
}
/// Compute the scalar product (or dot product) of two vectors.
/// No dimension checking is made.
/// @return double the scalar product of the receiver with the argument
/// @param v DHBmatrixAlgebra.DhbVector
internal protected double SecureProduct(DhbVector v)
{
double sum = 0;
for (int i = 0; i < _components.Length; i++)
{
sum += _components[i] * v._components[i];
}
return(sum);
}
/// Iterate matrix product in eigenvalue information.
public override double EvaluateIteration()
{
double oldEigenvalue = _eigenvalue;
_transposedEigenvector = _transposedEigenvector.SecureProduct(_matrix);
_transposedEigenvector *= (1.0 / _transposedEigenvector[0]);
_eigenvector = _matrix.SecureProduct(_eigenvector);
_eigenvalue = _eigenvector[0];
_eigenvector *= (1.0 / _eigenvalue);
return(double.IsNaN(oldEigenvalue)
? 10 * this.DesiredPrecision
: Math.Abs(_eigenvalue - oldEigenvalue));
}
/// @return true if the supplied vector is equal to the receiver
/// @param v DHBmatrixAlgebra.DhbVector
public bool Equals(DhbVector v)
{
if (v.Dimension != _components.Length)
{
return(false);
}
for (int i = 0; i < _components.Length; i++)
{
if (v._components[i] != _components[i])
{
return(false);
}
}
return(true);
}
/// @return MatrixAlgebra.Matrix tensor product with the specified
/// vector
/// @param v MatrixAlgebra.DhbVector second vector to build tensor
/// product with.
public Matrix TensorProduct(DhbVector v)
{
int n = _components.Length;
int m = v.Dimension;
double[,] newComponents = new double[n, m];
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{
newComponents[i, j] = _components[i] * v._components[j];
}
}
return(n == m ? new SymmetricMatrix(newComponents)
: new Matrix(newComponents));
}
/// Computes the product of the matrix with a vector.
/// @return DHBmatrixAlgebra.DhbVector
/// @param v DHBmatrixAlgebra.DhbVector
internal protected DhbVector SecureProduct(DhbVector v)
{
int n = this.Rows;
int m = this.Columns;
double[] vectorComponents = new double[n];
for (int i = 0; i < n; i++)
{
vectorComponents[i] = 0;
for (int j = 0; j < m; j++)
{
vectorComponents[i] += _components[i, j] * v.Components[j];
}
}
return(new DhbVector(vectorComponents));
}
/// @return DhbMatrixAlgebra.SymmetricMatrix
public DhbVector[] Eigenvectors()
{
int n = _rows.GetLength(0);
DhbVector[] eigenvectors = new DhbVector[n];
double[] temp = new double[n];
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
temp[j] = _transform[j, i];
}
eigenvectors[i] = new DhbVector(temp);
}
return(eigenvectors);
}
/// Computes the solution for constant vector p applying
/// backsubstitution.
/// @param p int
/// @exception ArithmeticException if one diagonal element
/// of the triangle matrix is zero.
private void BackSubstitution(int p)
{
int n = _rows.GetLength(0);
double[] answer = new double[n];
double x;
for (int i = n - 1; i >= 0; i--)
{
x = _rows[i, n + p];
for (int j = i + 1; j < n; j++)
{
x -= answer[j] * _rows[i, j];
}
answer[i] = x / _rows[i, i];
}
_solutions[p] = new DhbVector(answer);
}
/// Set result to undefined.
public override void InitializeIterations()
{
_eigenvalue = double.NaN;
int n = _matrix.Columns;
double[] eigenvectorComponents = new double[n];
for (int i = 0; i < n; i++)
{
eigenvectorComponents[i] = 1.0;
}
_eigenvector = new DhbVector(eigenvectorComponents);
n = _matrix.Rows;
eigenvectorComponents = new double[n];
for (int i = 0; i < n; i++)
{
eigenvectorComponents[i] = 1.0;
}
_transposedEigenvector = new DhbVector(eigenvectorComponents);
}
/// @return double[]
/// @param c double[]
public DhbVector Solve(DhbVector c)
{
double[] components = Solve(c.Components);
return(components == null ? null : new DhbVector(components));
}
/// Construct a system of linear equation Ax = y.
/// @param a MatrixAlgebra.Matrix matrix A
/// @param y MatrixAlgebra.DhbVector vector y
/// @exception MatrixAlgebra.DhbIllegalDimension
/// if the system's matrix is not square
/// if vector dimension does not match
/// that of the matrix
public LinearEquations(Matrix a, DhbVector y) : this(a.Components, y.Components)
{
}
/// @param v DhbMatrixAlgebra.DhbVector
/// @exception DhbMatrixAlgebra.DhbIllegalDimension if the vector
/// and supplied vector do not have the same dimension.
public void AccumulateNegated(DhbVector v)
{
AccumulateNegated(v._components);
}
/// @param v DhbMatrixAlgebra.DhbVector
/// @exception DhbMatrixAlgebra.DhbIllegalDimension if the vector
/// and supplied vector do not have the same dimension.
public void Accumulate(DhbVector v)
{
Accumulate(v._components);
}
