DLASDARun Method

Purpose ======= Using a divide and conquer approach, DLASDA computes the singular value decomposition (SVD) of a real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = N + SQRE. The algorithm computes the singular values in the SVD B = U * S * VT. The orthogonal matrices U and VT are optionally computed in compact form. A related subroutine, DLASD0, computes the singular values and the singular vectors in explicit form.

Namespace: DotNumerics.LinearAlgebra.CSLapack
Assembly: DWSIM.MathOps.DotNumerics (in DWSIM.MathOps.DotNumerics.dll) Version: 1.0.0.0 (1.0.0.0)

Syntax

Copy

public void Run(
	int ICOMPQ,
	int SMLSIZ,
	int N,
	int SQRE,
	ref double[] D,
	int offset_d,
	ref double[] E,
	int offset_e,
	ref double[] U,
	int offset_u,
	int LDU,
	ref double[] VT,
	int offset_vt,
	ref int[] K,
	int offset_k,
	ref double[] DIFL,
	int offset_difl,
	ref double[] DIFR,
	int offset_difr,
	ref double[] Z,
	int offset_z,
	ref double[] POLES,
	int offset_poles,
	ref int[] GIVPTR,
	int offset_givptr,
	ref int[] GIVCOL,
	int offset_givcol,
	int LDGCOL,
	ref int[] PERM,
	int offset_perm,
	ref double[] GIVNUM,
	int offset_givnum,
	ref double[] C,
	int offset_c,
	ref double[] S,
	int offset_s,
	ref double[] WORK,
	int offset_work,
	ref int[] IWORK,
	int offset_iwork,
	ref int INFO
)

Public Sub Run ( 
	ICOMPQ As Integer,
	SMLSIZ As Integer,
	N As Integer,
	SQRE As Integer,
	ByRef D As Double(),
	offset_d As Integer,
	ByRef E As Double(),
	offset_e As Integer,
	ByRef U As Double(),
	offset_u As Integer,
	LDU As Integer,
	ByRef VT As Double(),
	offset_vt As Integer,
	ByRef K As Integer(),
	offset_k As Integer,
	ByRef DIFL As Double(),
	offset_difl As Integer,
	ByRef DIFR As Double(),
	offset_difr As Integer,
	ByRef Z As Double(),
	offset_z As Integer,
	ByRef POLES As Double(),
	offset_poles As Integer,
	ByRef GIVPTR As Integer(),
	offset_givptr As Integer,
	ByRef GIVCOL As Integer(),
	offset_givcol As Integer,
	LDGCOL As Integer,
	ByRef PERM As Integer(),
	offset_perm As Integer,
	ByRef GIVNUM As Double(),
	offset_givnum As Integer,
	ByRef C As Double(),
	offset_c As Integer,
	ByRef S As Double(),
	offset_s As Integer,
	ByRef WORK As Double(),
	offset_work As Integer,
	ByRef IWORK As Integer(),
	offset_iwork As Integer,
	ByRef INFO As Integer
)

Request Example View Source

Parameters

ICOMPQ Int32: (input) INTEGER Specifies whether singular vectors are to be computed in compact form, as follows = 0: Compute singular values only. = 1: Compute singular vectors of upper bidiagonal matrix in compact form.
SMLSIZ Int32: (input) INTEGER The maximum size of the subproblems at the bottom of the computation tree.
N Int32: (input) INTEGER The row dimension of the upper bidiagonal matrix. This is also the dimension of the main diagonal array D.
SQRE Int32: (input) INTEGER Specifies the column dimension of the bidiagonal matrix. = 0: The bidiagonal matrix has column dimension M = N; = 1: The bidiagonal matrix has column dimension M = N + 1.
D Double: (input/output) DOUBLE PRECISION array, dimension ( N ) On entry D contains the main diagonal of the bidiagonal matrix. On exit D, if INFO = 0, contains its singular values.
offset_d Int32
E Double: (input) DOUBLE PRECISION array, dimension ( M-1 ) Contains the subdiagonal entries of the bidiagonal matrix. On exit, E has been destroyed.
offset_e Int32
U Double: (output) DOUBLE PRECISION array, dimension ( LDU, SMLSIZ ) if ICOMPQ = 1, and not referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, U contains the left singular vector matrices of all subproblems at the bottom level.
offset_u Int32
LDU Int32: (input) INTEGER, LDU = .GT. N. The leading dimension of arrays U, VT, DIFL, DIFR, POLES, GIVNUM, and Z.
VT Double: (output) DOUBLE PRECISION array, dimension ( LDU, SMLSIZ+1 ) if ICOMPQ = 1, and not referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, VT' contains the right singular vector matrices of all subproblems at the bottom level.
offset_vt Int32
K Int32: (output) INTEGER array, dimension ( N ) if ICOMPQ = 1 and dimension 1 if ICOMPQ = 0. If ICOMPQ = 1, on exit, K(I) is the dimension of the I-th secular equation on the computation tree.
offset_k Int32
DIFL Double: (output) DOUBLE PRECISION array, dimension ( LDU, NLVL ), where NLVL = floor(log_2 (N/SMLSIZ))).
offset_difl Int32
DIFR Double: (output) DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1 and dimension ( N ) if ICOMPQ = 0. If ICOMPQ = 1, on exit, DIFL(1:N, I) and DIFR(1:N, 2 * I - 1) record distances between singular values on the I-th level and singular values on the (I -1)-th level, and DIFR(1:N, 2 * I ) contains the normalizing factors for the right singular vector matrix. See DLASD8 for details.
offset_difr Int32
Z Double: (output) DOUBLE PRECISION array, dimension ( LDU, NLVL ) if ICOMPQ = 1 and dimension ( N ) if ICOMPQ = 0. The first K elements of Z(1, I) contain the components of the deflation-adjusted updating row vector for subproblems on the I-th level.
offset_z Int32
POLES Double: (output) DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1, and not referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, POLES(1, 2*I - 1) and POLES(1, 2*I) contain the new and old singular values involved in the secular equations on the I-th level.
offset_poles Int32
GIVPTR Int32: (output) INTEGER array, dimension ( N ) if ICOMPQ = 1, and not referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, GIVPTR( I ) records the number of Givens rotations performed on the I-th problem on the computation tree.
offset_givptr Int32
GIVCOL Int32: (output) INTEGER array, dimension ( LDGCOL, 2 * NLVL ) if ICOMPQ = 1, and not referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I, GIVCOL(1, 2 *I - 1) and GIVCOL(1, 2 *I) record the locations of Givens rotations performed on the I-th level on the computation tree.
offset_givcol Int32
LDGCOL Int32: (input) INTEGER, LDGCOL = .GT. N. The leading dimension of arrays GIVCOL and PERM.
PERM Int32: (output) INTEGER array, dimension ( LDGCOL, NLVL ) if ICOMPQ = 1, and not referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, PERM(1, I) records permutations done on the I-th level of the computation tree.
offset_perm Int32
GIVNUM Double: (output) DOUBLE PRECISION array, dimension ( LDU, 2 * NLVL ) if ICOMPQ = 1, and not referenced if ICOMPQ = 0. If ICOMPQ = 1, on exit, for each I, GIVNUM(1, 2 *I - 1) and GIVNUM(1, 2 *I) record the C- and S- values of Givens rotations performed on the I-th level on the computation tree.
offset_givnum Int32
C Double: (output) DOUBLE PRECISION array, dimension ( N ) if ICOMPQ = 1, and dimension 1 if ICOMPQ = 0. If ICOMPQ = 1 and the I-th subproblem is not square, on exit, C( I ) contains the C-value of a Givens rotation related to the right null space of the I-th subproblem.
offset_c Int32
S Double: (output) DOUBLE PRECISION array, dimension ( N ) if ICOMPQ = 1, and dimension 1 if ICOMPQ = 0. If ICOMPQ = 1 and the I-th subproblem is not square, on exit, S( I ) contains the S-value of a Givens rotation related to the right null space of the I-th subproblem.
offset_s Int32
WORK Double: (workspace) DOUBLE PRECISION array, dimension (6 * N + (SMLSIZ + 1)*(SMLSIZ + 1)).
offset_work Int32
IWORK Int32: (workspace) INTEGER array. Dimension must be at least (7 * N).
offset_iwork Int32
INFO Int32: (output) INTEGER = 0: successful exit. .LT. 0: if INFO = -i, the i-th argument had an illegal value. .GT. 0: if INFO = 1, an singular value did not converge

Reference

DLASDA Class

DotNumerics.LinearAlgebra.CSLapack Namespace