/// <summary> /// Computes the eigenvalues and eigenvectors of a matrix. /// </summary> /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param> /// <param name="order">The order of the matrix.</param> /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param> /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param> /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param> /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param> public override void EigenDecomp(bool isSymmetric, int order, Complex[] matrix, Complex[] matrixEv, Complex[] vectorEv, Complex[] matrixD) { if (matrix == null) { throw new ArgumentNullException("matrix"); } if (matrix.Length != order * order) { throw new ArgumentException(String.Format(Resources.ArgumentArrayWrongLength, order * order), "matrix"); } if (matrixEv == null) { throw new ArgumentNullException("matrixEv"); } if (matrixEv.Length != order * order) { throw new ArgumentException(String.Format(Resources.ArgumentArrayWrongLength, order * order), "matrixEv"); } if (vectorEv == null) { throw new ArgumentNullException("vectorEv"); } if (vectorEv.Length != order) { throw new ArgumentException(String.Format(Resources.ArgumentArrayWrongLength, order), "vectorEv"); } if (matrixD == null) { throw new ArgumentNullException("matrixD"); } if (matrixD.Length != order * order) { throw new ArgumentException(String.Format(Resources.ArgumentArrayWrongLength, order * order), "matrixD"); } var info = SafeNativeMethods.z_eigen(isSymmetric, order, matrix, matrixEv, vectorEv, matrixD); if (info == (int)NativeError.MemoryAllocation) { throw new MemoryAllocationException(); } if (info < 0) { throw new InvalidParameterException(Math.Abs(info)); } if (info > 0) { throw new NonConvergenceException(); } }
/// <summary> /// Computes the eigenvalues and eigenvectors of a matrix. /// </summary> /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param> /// <param name="order">The order of the matrix.</param> /// <param name="matrix">The matrix to decompose. The length of the array must be order * order.</param> /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The length of the array must be order * order.</param> /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the array must <paramref name="order"/>.</param> /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The length of the array must be order * order.</param> public override void EigenDecomp(bool isSymmetric, int order, Complex[] matrix, Complex[] matrixEv, Complex[] vectorEv, Complex[] matrixD) { if (matrix == null) { throw new ArgumentNullException(nameof(matrix)); } if (matrix.Length != order * order) { throw new ArgumentException($"The given array has the wrong length. Should be {order * order}.", nameof(matrix)); } if (matrixEv == null) { throw new ArgumentNullException(nameof(matrixEv)); } if (matrixEv.Length != order * order) { throw new ArgumentException($"The given array has the wrong length. Should be {order * order}.", nameof(matrixEv)); } if (vectorEv == null) { throw new ArgumentNullException(nameof(vectorEv)); } if (vectorEv.Length != order) { throw new ArgumentException($"The given array has the wrong length. Should be {order}.", nameof(vectorEv)); } if (matrixD == null) { throw new ArgumentNullException(nameof(matrixD)); } if (matrixD.Length != order * order) { throw new ArgumentException($"The given array has the wrong length. Should be {order * order}.", nameof(matrixD)); } var info = SafeNativeMethods.z_eigen(isSymmetric, order, matrix, matrixEv, vectorEv, matrixD); if (info == (int)NativeError.MemoryAllocation) { throw new MemoryAllocationException(); } if (info < 0) { throw new InvalidParameterException(Math.Abs(info)); } if (info > 0) { throw new NonConvergenceException(); } }
/// <summary> /// Computes the eigenvalues and eigenvectors of a matrix. /// </summary> /// <param name="isSymmetric">Whether the matrix is symmetric or not.</param> /// <param name="order">The order of the matrix.</param> /// <param name="matrix">The matrix to decompose. The lenth of the array must be order * order.</param> /// <param name="matrixEv">On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.</param> /// <param name="vectorEv">On output, the eigen values (λ) of matrix in ascending value. The length of the arry must <paramref name="order"/>.</param> /// <param name="matrixD">On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.</param> public override void EigenDecomp(bool isSymmetric, int order, Complex[] matrix, Complex[] matrixEv, Complex[] vectorEv, Complex[] matrixD) { if (matrix == null) { throw new ArgumentNullException("matrix"); } if (matrix.Length != order * order) { throw new ArgumentException(String.Format(Resources.ArgumentArrayWrongLength, order * order), "matrix"); } if (matrixEv == null) { throw new ArgumentNullException("matrixEv"); } if (matrixEv.Length != order * order) { throw new ArgumentException(String.Format(Resources.ArgumentArrayWrongLength, order * order), "matrixEv"); } if (vectorEv == null) { throw new ArgumentNullException("vectorEv"); } if (vectorEv.Length != order) { throw new ArgumentException(String.Format(Resources.ArgumentArrayWrongLength, order), "vectorEv"); } if (matrixD == null) { throw new ArgumentNullException("matrixD"); } if (matrixD.Length != order * order) { throw new ArgumentException(String.Format(Resources.ArgumentArrayWrongLength, order * order), "matrixD"); } if (SafeNativeMethods.z_eigen(isSymmetric, order, matrix, matrixEv, vectorEv, matrixD) > 0) { throw new NonConvergenceException(); } }