DLASD2Run Method

Purpose ======= DLASD2 merges the two sets of singular values together into a single sorted set. Then it tries to deflate the size of the problem. There are two ways in which deflation can occur: when two or more singular values are close together or if there is a tiny entry in the Z vector. For each such occurrence the order of the related secular equation problem is reduced by one. DLASD2 is called from DLASD1.

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 NL,
	int NR,
	int SQRE,
	ref int K,
	ref double[] D,
	int offset_d,
	ref double[] Z,
	int offset_z,
	double ALPHA,
	double BETA,
	ref double[] U,
	int offset_u,
	int LDU,
	ref double[] VT,
	int offset_vt,
	int LDVT,
	ref double[] DSIGMA,
	int offset_dsigma,
	ref double[] U2,
	int offset_u2,
	int LDU2,
	ref double[] VT2,
	int offset_vt2,
	int LDVT2,
	ref int[] IDXP,
	int offset_idxp,
	ref int[] IDX,
	int offset_idx,
	ref int[] IDXC,
	int offset_idxc,
	ref int[] IDXQ,
	int offset_idxq,
	ref int[] COLTYP,
	int offset_coltyp,
	ref int INFO
)

Public Sub Run ( 
	NL As Integer,
	NR As Integer,
	SQRE As Integer,
	ByRef K As Integer,
	ByRef D As Double(),
	offset_d As Integer,
	ByRef Z As Double(),
	offset_z As Integer,
	ALPHA As Double,
	BETA As Double,
	ByRef U As Double(),
	offset_u As Integer,
	LDU As Integer,
	ByRef VT As Double(),
	offset_vt As Integer,
	LDVT As Integer,
	ByRef DSIGMA As Double(),
	offset_dsigma As Integer,
	ByRef U2 As Double(),
	offset_u2 As Integer,
	LDU2 As Integer,
	ByRef VT2 As Double(),
	offset_vt2 As Integer,
	LDVT2 As Integer,
	ByRef IDXP As Integer(),
	offset_idxp As Integer,
	ByRef IDX As Integer(),
	offset_idx As Integer,
	ByRef IDXC As Integer(),
	offset_idxc As Integer,
	ByRef IDXQ As Integer(),
	offset_idxq As Integer,
	ByRef COLTYP As Integer(),
	offset_coltyp As Integer,
	ByRef INFO As Integer
)

Request Example View Source

Parameters

NL Int32: (input) INTEGER The row dimension of the upper block. NL .GE. 1.
NR Int32: (input) INTEGER The row dimension of the lower block. NR .GE. 1.
SQRE Int32: (input) INTEGER = 0: the lower block is an NR-by-NR square matrix. = 1: the lower block is an NR-by-(NR+1) rectangular matrix. The bidiagonal matrix has N = NL + NR + 1 rows and M = N + SQRE .GE. N columns.
K Int32: (output) INTEGER Contains the dimension of the non-deflated matrix, This is the order of the related secular equation. 1 .LE. K .LE.N.
D Double: (input/output) DOUBLE PRECISION array, dimension(N) On entry D contains the singular values of the two submatrices to be combined. On exit D contains the trailing (N-K) updated singular values (those which were deflated) sorted into increasing order.
offset_d Int32
Z Double: (output) DOUBLE PRECISION array, dimension(N) On exit Z contains the updating row vector in the secular equation.
offset_z Int32
ALPHA Double: (input) DOUBLE PRECISION Contains the diagonal element associated with the added row.
BETA Double: (input) DOUBLE PRECISION Contains the off-diagonal element associated with the added row.
U Double: (input/output) DOUBLE PRECISION array, dimension(LDU,N) On entry U contains the left singular vectors of two submatrices in the two square blocks with corners at (1,1), (NL, NL), and (NL+2, NL+2), (N,N). On exit U contains the trailing (N-K) updated left singular vectors (those which were deflated) in its last N-K columns.
offset_u Int32
LDU Int32: (input) INTEGER The leading dimension of the array U. LDU .GE. N.
VT Double: (input/output) DOUBLE PRECISION array, dimension(LDVT,M) On entry VT' contains the right singular vectors of two submatrices in the two square blocks with corners at (1,1), (NL+1, NL+1), and (NL+2, NL+2), (M,M). On exit VT' contains the trailing (N-K) updated right singular vectors (those which were deflated) in its last N-K columns. In case SQRE =1, the last row of VT spans the right null space.
offset_vt Int32
LDVT Int32: (input) INTEGER The leading dimension of the array VT. LDVT .GE. M.
DSIGMA Double: (output) DOUBLE PRECISION array, dimension (N) Contains a copy of the diagonal elements (K-1 singular values and one zero) in the secular equation.
offset_dsigma Int32
U2 Double: (output) DOUBLE PRECISION array, dimension(LDU2,N) Contains a copy of the first K-1 left singular vectors which will be used by DLASD3 in a matrix multiply (DGEMM) to solve for the new left singular vectors. U2 is arranged into four blocks. The first block contains a column with 1 at NL+1 and zero everywhere else; the second block contains non-zero entries only at and above NL; the third contains non-zero entries only below NL+1; and the fourth is dense.
offset_u2 Int32
LDU2 Int32: (input) INTEGER The leading dimension of the array U2. LDU2 .GE. N.
VT2 Double: (output) DOUBLE PRECISION array, dimension(LDVT2,N) VT2' contains a copy of the first K right singular vectors which will be used by DLASD3 in a matrix multiply (DGEMM) to solve for the new right singular vectors. VT2 is arranged into three blocks. The first block contains a row that corresponds to the special 0 diagonal element in SIGMA; the second block contains non-zeros only at and before NL +1; the third block contains non-zeros only at and after NL +2.
offset_vt2 Int32
LDVT2 Int32: (input) INTEGER The leading dimension of the array VT2. LDVT2 .GE. M.
IDXP Int32: (workspace) INTEGER array dimension(N) This will contain the permutation used to place deflated values of D at the end of the array. On output IDXP(2:K) points to the nondeflated D-values and IDXP(K+1:N) points to the deflated singular values.
offset_idxp Int32
IDX Int32: (workspace) INTEGER array dimension(N) This will contain the permutation used to sort the contents of D into ascending order.
offset_idx Int32
IDXC Int32: (output) INTEGER array dimension(N) This will contain the permutation used to arrange the columns of the deflated U matrix into three groups: the first group contains non-zero entries only at and above NL, the second contains non-zero entries only below NL+2, and the third is dense.
offset_idxc Int32
IDXQ Int32: (input/output) INTEGER array dimension(N) This contains the permutation which separately sorts the two sub-problems in D into ascending order. Note that entries in the first hlaf of this permutation must first be moved one position backward; and entries in the second half must first have NL+1 added to their values.
offset_idxq Int32
COLTYP Int32: (workspace/output) INTEGER array dimension(N) As workspace, this will contain a label which will indicate which of the following types a column in the U2 matrix or a row in the VT2 matrix is: 1 : non-zero in the upper half only 2 : non-zero in the lower half only 3 : dense 4 : deflated On exit, it is an array of dimension 4, with COLTYP(I) being the dimension of the I-th type columns.
offset_coltyp Int32
INFO Int32: (output) INTEGER = 0: successful exit. .LT. 0: if INFO = -i, the i-th argument had an illegal value.

Reference

DLASD2 Class

DotNumerics.LinearAlgebra.CSLapack Namespace