--- 
:name: slasdq
:md5sum: ca31c86dcb1ae2e16419d7f2adab408a
:category: :subroutine
:arguments: 
- uplo: 
    :type: char
    :intent: input
- sqre: 
    :type: integer
    :intent: input
- n: 
    :type: integer
    :intent: input
- ncvt: 
    :type: integer
    :intent: input
- nru: 
    :type: integer
    :intent: input
- ncc: 
    :type: integer
    :intent: input
- d: 
    :type: real
    :intent: input/output
    :dims: 
    - n
- e: 
    :type: real
    :intent: input/output
    :dims: 
    - "sqre==0 ? n-1 : sqre==1 ? n : 0"
- vt: 
    :type: real
    :intent: input/output
    :dims: 
    - ldvt
    - ncvt
- ldvt: 
    :type: integer
    :intent: input
- u: 
    :type: real
    :intent: input/output
    :dims: 
    - ldu
    - n
- ldu: 
    :type: integer
    :intent: input
- c: 
    :type: real
    :intent: input/output
    :dims: 
    - ldc
    - ncc
- ldc: 
    :type: integer
    :intent: input
- work: 
    :type: real
    :intent: workspace
    :dims: 
    - 4*n
- info: 
    :type: integer
    :intent: output
:substitutions: {}

:fortran_help: "      SUBROUTINE SLASDQ( UPLO, SQRE, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, LDU, C, LDC, WORK, INFO )\n\n\
  *  Purpose\n\
  *  =======\n\
  *\n\
  *  SLASDQ computes the singular value decomposition (SVD) of a real\n\
  *  (upper or lower) bidiagonal matrix with diagonal D and offdiagonal\n\
  *  E, accumulating the transformations if desired. Letting B denote\n\
  *  the input bidiagonal matrix, the algorithm computes orthogonal\n\
  *  matrices Q and P such that B = Q * S * P' (P' denotes the transpose\n\
  *  of P). The singular values S are overwritten on D.\n\
  *\n\
  *  The input matrix U  is changed to U  * Q  if desired.\n\
  *  The input matrix VT is changed to P' * VT if desired.\n\
  *  The input matrix C  is changed to Q' * C  if desired.\n\
  *\n\
  *  See \"Computing  Small Singular Values of Bidiagonal Matrices With\n\
  *  Guaranteed High Relative Accuracy,\" by J. Demmel and W. Kahan,\n\
  *  LAPACK Working Note #3, for a detailed description of the algorithm.\n\
  *\n\n\
  *  Arguments\n\
  *  =========\n\
  *\n\
  *  UPLO  (input) CHARACTER*1\n\
  *        On entry, UPLO specifies whether the input bidiagonal matrix\n\
  *        is upper or lower bidiagonal, and wether it is square are\n\
  *        not.\n\
  *           UPLO = 'U' or 'u'   B is upper bidiagonal.\n\
  *           UPLO = 'L' or 'l'   B is lower bidiagonal.\n\
  *\n\
  *  SQRE  (input) INTEGER\n\
  *        = 0: then the input matrix is N-by-N.\n\
  *        = 1: then the input matrix is N-by-(N+1) if UPLU = 'U' and\n\
  *             (N+1)-by-N if UPLU = 'L'.\n\
  *\n\
  *        The bidiagonal matrix has\n\
  *        N = NL + NR + 1 rows and\n\
  *        M = N + SQRE >= N columns.\n\
  *\n\
  *  N     (input) INTEGER\n\
  *        On entry, N specifies the number of rows and columns\n\
  *        in the matrix. N must be at least 0.\n\
  *\n\
  *  NCVT  (input) INTEGER\n\
  *        On entry, NCVT specifies the number of columns of\n\
  *        the matrix VT. NCVT must be at least 0.\n\
  *\n\
  *  NRU   (input) INTEGER\n\
  *        On entry, NRU specifies the number of rows of\n\
  *        the matrix U. NRU must be at least 0.\n\
  *\n\
  *  NCC   (input) INTEGER\n\
  *        On entry, NCC specifies the number of columns of\n\
  *        the matrix C. NCC must be at least 0.\n\
  *\n\
  *  D     (input/output) REAL array, dimension (N)\n\
  *        On entry, D contains the diagonal entries of the\n\
  *        bidiagonal matrix whose SVD is desired. On normal exit,\n\
  *        D contains the singular values in ascending order.\n\
  *\n\
  *  E     (input/output) REAL array.\n\
  *        dimension is (N-1) if SQRE = 0 and N if SQRE = 1.\n\
  *        On entry, the entries of E contain the offdiagonal entries\n\
  *        of the bidiagonal matrix whose SVD is desired. On normal\n\
  *        exit, E will contain 0. If the algorithm does not converge,\n\
  *        D and E will contain the diagonal and superdiagonal entries\n\
  *        of a bidiagonal matrix orthogonally equivalent to the one\n\
  *        given as input.\n\
  *\n\
  *  VT    (input/output) REAL array, dimension (LDVT, NCVT)\n\
  *        On entry, contains a matrix which on exit has been\n\
  *        premultiplied by P', dimension N-by-NCVT if SQRE = 0\n\
  *        and (N+1)-by-NCVT if SQRE = 1 (not referenced if NCVT=0).\n\
  *\n\
  *  LDVT  (input) INTEGER\n\
  *        On entry, LDVT specifies the leading dimension of VT as\n\
  *        declared in the calling (sub) program. LDVT must be at\n\
  *        least 1. If NCVT is nonzero LDVT must also be at least N.\n\
  *\n\
  *  U     (input/output) REAL array, dimension (LDU, N)\n\
  *        On entry, contains a  matrix which on exit has been\n\
  *        postmultiplied by Q, dimension NRU-by-N if SQRE = 0\n\
  *        and NRU-by-(N+1) if SQRE = 1 (not referenced if NRU=0).\n\
  *\n\
  *  LDU   (input) INTEGER\n\
  *        On entry, LDU  specifies the leading dimension of U as\n\
  *        declared in the calling (sub) program. LDU must be at\n\
  *        least max( 1, NRU ) .\n\
  *\n\
  *  C     (input/output) REAL array, dimension (LDC, NCC)\n\
  *        On entry, contains an N-by-NCC matrix which on exit\n\
  *        has been premultiplied by Q'  dimension N-by-NCC if SQRE = 0\n\
  *        and (N+1)-by-NCC if SQRE = 1 (not referenced if NCC=0).\n\
  *\n\
  *  LDC   (input) INTEGER\n\
  *        On entry, LDC  specifies the leading dimension of C as\n\
  *        declared in the calling (sub) program. LDC must be at\n\
  *        least 1. If NCC is nonzero, LDC must also be at least N.\n\
  *\n\
  *  WORK  (workspace) REAL array, dimension (4*N)\n\
  *        Workspace. Only referenced if one of NCVT, NRU, or NCC is\n\
  *        nonzero, and if N is at least 2.\n\
  *\n\
  *  INFO  (output) INTEGER\n\
  *        On exit, a value of 0 indicates a successful exit.\n\
  *        If INFO < 0, argument number -INFO is illegal.\n\
  *        If INFO > 0, the algorithm did not converge, and INFO\n\
  *        specifies how many superdiagonals did not converge.\n\
  *\n\n\
  *  Further Details\n\
  *  ===============\n\
  *\n\
  *  Based on contributions by\n\
  *     Ming Gu and Huan Ren, Computer Science Division, University of\n\
  *     California at Berkeley, USA\n\
  *\n\
  *  =====================================================================\n\
  *\n"
