libflame  revision_anchor
Functions
sorcsd.c File Reference

(r)

Functions

int sorcsd_ (char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, integer *m, integer *p, integer *q, real *x11, integer *ldx11, real *x12, integer *ldx12, real *x21, integer *ldx21, real *x22, integer *ldx22, real *theta, real *u1, integer *ldu1, real *u2, integer *ldu2, real *v1t, integer *ldv1t, real *v2t, integer *ldv2t, real *work, integer *lwork, integer *iwork, integer *info)
 

Function Documentation

◆ sorcsd_()

int sorcsd_ ( char *  jobu1,
char *  jobu2,
char *  jobv1t,
char *  jobv2t,
char *  trans,
char *  signs,
integer m,
integer p,
integer q,
real x11,
integer ldx11,
real x12,
integer ldx12,
real x21,
integer ldx21,
real x22,
integer ldx22,
real theta,
real u1,
integer ldu1,
real u2,
integer ldu2,
real v1t,
integer ldv1t,
real v2t,
integer ldv2t,
real work,
integer lwork,
integer iwork,
integer info 
)

References sorglq_fla(), and sorgqr_fla().

295 {
296  /* System generated locals */
297  integer u1_dim1, u1_offset, u2_dim1, u2_offset, v1t_dim1, v1t_offset, v2t_dim1, v2t_offset, x11_dim1, x11_offset, x12_dim1, x12_offset, x21_dim1, x21_offset, x22_dim1, x22_offset, i__1, i__2, i__3, i__4, i__5, i__6;
298  /* Local variables */
299  logical colmajor;
300  integer lworkmin, lworkopt, i__, j, childinfo, lbbcsdwork, lorbdbwork, lorglqwork, lorgqrwork, ib11d, ib11e, ib12d, ib12e, ib21d, ib21e, ib22d, ib22e, iphi;
301  logical defaultsigns;
302  extern logical lsame_(char *, char *);
303  real dummy[1];
304  integer lbbcsdworkmin, itaup1, itaup2, itauq1, itauq2, lorbdbworkmin, lbbcsdworkopt;
305  logical wantu1, wantu2;
306  integer ibbcsd, lorbdbworkopt;
307  extern /* Subroutine */
308  int sbbcsd_(char *, char *, char *, char *, char * , integer *, integer *, integer *, real *, real *, real *, integer *, real *, integer *, real *, integer *, real *, integer * , real *, real *, real *, real *, real *, real *, real *, real *, real *, integer *, integer *);
309  integer iorbdb, lorglqworkmin, lorgqrworkmin;
310  extern /* Subroutine */
311  int sorbdb_(char *, char *, integer *, integer *, integer *, real *, integer *, real *, integer *, real *, integer * , real *, integer *, real *, real *, real *, real *, real *, real *, real *, integer *, integer *), xerbla_(char *, integer *);
312  integer lorglqworkopt, lorgqrworkopt;
313  extern /* Subroutine */
314  int slacpy_(char *, integer *, integer *, real *, integer *, real *, integer *);
315  integer iorglq;
316  extern /* Subroutine */
317  int slapmr_(logical *, integer *, integer *, real *, integer *, integer *), slapmt_(logical *, integer *, integer *, real *, integer *, integer *);
318  integer iorgqr;
319  char signst[1];
320  extern /* Subroutine */
321  int sorglq_fla(integer *, integer *, integer *, real *, integer *, real *, real *, integer *, integer *);
322  char transt[1];
323  extern /* Subroutine */
324  int sorgqr_fla(integer *, integer *, integer *, real *, integer *, real *, real *, integer *, integer *);
325  logical lquery, wantv1t, wantv2t;
326  /* -- LAPACK computational routine (version 3.5.0) -- */
327  /* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
328  /* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
329  /* November 2013 */
330  /* .. Scalar Arguments .. */
331  /* .. */
332  /* .. Array Arguments .. */
333  /* .. */
334  /* =================================================================== */
335  /* .. Parameters .. */
336  /* .. */
337  /* .. Local Arrays .. */
338  /* .. */
339  /* .. Local Scalars .. */
340  /* .. */
341  /* .. External Subroutines .. */
342  /* .. */
343  /* .. External Functions .. */
344  /* .. */
345  /* .. Intrinsic Functions */
346  /* .. */
347  /* .. Executable Statements .. */
348  /* Test input arguments */
349  /* Parameter adjustments */
350  x11_dim1 = *ldx11;
351  x11_offset = 1 + x11_dim1;
352  x11 -= x11_offset;
353  x12_dim1 = *ldx12;
354  x12_offset = 1 + x12_dim1;
355  x12 -= x12_offset;
356  x21_dim1 = *ldx21;
357  x21_offset = 1 + x21_dim1;
358  x21 -= x21_offset;
359  x22_dim1 = *ldx22;
360  x22_offset = 1 + x22_dim1;
361  x22 -= x22_offset;
362  --theta;
363  u1_dim1 = *ldu1;
364  u1_offset = 1 + u1_dim1;
365  u1 -= u1_offset;
366  u2_dim1 = *ldu2;
367  u2_offset = 1 + u2_dim1;
368  u2 -= u2_offset;
369  v1t_dim1 = *ldv1t;
370  v1t_offset = 1 + v1t_dim1;
371  v1t -= v1t_offset;
372  v2t_dim1 = *ldv2t;
373  v2t_offset = 1 + v2t_dim1;
374  v2t -= v2t_offset;
375  --work;
376  --iwork;
377  /* Function Body */
378  *info = 0;
379  wantu1 = lsame_(jobu1, "Y");
380  wantu2 = lsame_(jobu2, "Y");
381  wantv1t = lsame_(jobv1t, "Y");
382  wantv2t = lsame_(jobv2t, "Y");
383  colmajor = ! lsame_(trans, "T");
384  defaultsigns = ! lsame_(signs, "O");
385  lquery = *lwork == -1;
386  if (*m < 0)
387  {
388  *info = -7;
389  }
390  else if (*p < 0 || *p > *m)
391  {
392  *info = -8;
393  }
394  else if (*q < 0 || *q > *m)
395  {
396  *info = -9;
397  }
398  else if (colmajor && *ldx11 < max(1,*p))
399  {
400  *info = -11;
401  }
402  else if (! colmajor && *ldx11 < max(1,*q))
403  {
404  *info = -11;
405  }
406  else if (colmajor && *ldx12 < max(1,*p))
407  {
408  *info = -13;
409  }
410  else /* if(complicated condition) */
411  {
412  /* Computing MAX */
413  i__1 = 1;
414  i__2 = *m - *q; // , expr subst
415  if (! colmajor && *ldx12 < max(i__1,i__2))
416  {
417  *info = -13;
418  }
419  else /* if(complicated condition) */
420  {
421  /* Computing MAX */
422  i__1 = 1;
423  i__2 = *m - *p; // , expr subst
424  if (colmajor && *ldx21 < max(i__1,i__2))
425  {
426  *info = -15;
427  }
428  else if (! colmajor && *ldx21 < max(1,*q))
429  {
430  *info = -15;
431  }
432  else /* if(complicated condition) */
433  {
434  /* Computing MAX */
435  i__1 = 1;
436  i__2 = *m - *p; // , expr subst
437  if (colmajor && *ldx22 < max(i__1,i__2))
438  {
439  *info = -17;
440  }
441  else /* if(complicated condition) */
442  {
443  /* Computing MAX */
444  i__1 = 1;
445  i__2 = *m - *q; // , expr subst
446  if (! colmajor && *ldx22 < max(i__1,i__2))
447  {
448  *info = -17;
449  }
450  else if (wantu1 && *ldu1 < *p)
451  {
452  *info = -20;
453  }
454  else if (wantu2 && *ldu2 < *m - *p)
455  {
456  *info = -22;
457  }
458  else if (wantv1t && *ldv1t < *q)
459  {
460  *info = -24;
461  }
462  else if (wantv2t && *ldv2t < *m - *q)
463  {
464  *info = -26;
465  }
466  }
467  }
468  }
469  }
470  /* Work with transpose if convenient */
471  /* Computing MIN */
472  i__1 = *p;
473  i__2 = *m - *p; // , expr subst
474  /* Computing MIN */
475  i__3 = *q;
476  i__4 = *m - *q; // , expr subst
477  if (*info == 0 && min(i__1,i__2) < min(i__3,i__4))
478  {
479  if (colmajor)
480  {
481  *(unsigned char *)transt = 'T';
482  }
483  else
484  {
485  *(unsigned char *)transt = 'N';
486  }
487  if (defaultsigns)
488  {
489  *(unsigned char *)signst = 'O';
490  }
491  else
492  {
493  *(unsigned char *)signst = 'D';
494  }
495  sorcsd_(jobv1t, jobv2t, jobu1, jobu2, transt, signst, m, q, p, &x11[ x11_offset], ldx11, &x21[x21_offset], ldx21, &x12[x12_offset], ldx12, &x22[x22_offset], ldx22, &theta[1], &v1t[v1t_offset], ldv1t, &v2t[v2t_offset], ldv2t, &u1[u1_offset], ldu1, &u2[ u2_offset], ldu2, &work[1], lwork, &iwork[1], info);
496  return 0;
497  }
498  /* Work with permutation [ 0 I;
499  I 0 ] * X * [ 0 I;
500  I 0 ] if */
501  /* convenient */
502  if (*info == 0 && *m - *q < *q)
503  {
504  if (defaultsigns)
505  {
506  *(unsigned char *)signst = 'O';
507  }
508  else
509  {
510  *(unsigned char *)signst = 'D';
511  }
512  i__1 = *m - *p;
513  i__2 = *m - *q;
514  sorcsd_(jobu2, jobu1, jobv2t, jobv1t, trans, signst, m, &i__1, &i__2, &x22[x22_offset], ldx22, &x21[x21_offset], ldx21, &x12[ x12_offset], ldx12, &x11[x11_offset], ldx11, &theta[1], &u2[ u2_offset], ldu2, &u1[u1_offset], ldu1, &v2t[v2t_offset], ldv2t, &v1t[v1t_offset], ldv1t, &work[1], lwork, &iwork[1], info);
515  return 0;
516  }
517  /* Compute workspace */
518  if (*info == 0)
519  {
520  iphi = 2;
521  /* Computing MAX */
522  i__1 = 1;
523  i__2 = *q - 1; // , expr subst
524  itaup1 = iphi + max(i__1,i__2);
525  itaup2 = itaup1 + max(1,*p);
526  /* Computing MAX */
527  i__1 = 1;
528  i__2 = *m - *p; // , expr subst
529  itauq1 = itaup2 + max(i__1,i__2);
530  itauq2 = itauq1 + max(1,*q);
531  /* Computing MAX */
532  i__1 = 1;
533  i__2 = *m - *q; // , expr subst
534  iorgqr = itauq2 + max(i__1,i__2);
535  i__1 = *m - *q;
536  i__2 = *m - *q;
537  i__3 = *m - *q;
538  /* Computing MAX */
539  i__5 = 1;
540  i__6 = *m - *q; // , expr subst
541  i__4 = max(i__5,i__6);
542  sorgqr_fla(&i__1, &i__2, &i__3, dummy, &i__4, dummy, &work[1], &c_n1, & childinfo);
543  lorgqrworkopt = (integer) work[1];
544  /* Computing MAX */
545  i__1 = 1;
546  i__2 = *m - *q; // , expr subst
547  lorgqrworkmin = max(i__1,i__2);
548  /* Computing MAX */
549  i__1 = 1;
550  i__2 = *m - *q; // , expr subst
551  iorglq = itauq2 + max(i__1,i__2);
552  i__1 = *m - *q;
553  i__2 = *m - *q;
554  i__3 = *m - *q;
555  /* Computing MAX */
556  i__5 = 1;
557  i__6 = *m - *q; // , expr subst
558  i__4 = max(i__5,i__6);
559  sorglq_fla(&i__1, &i__2, &i__3, dummy, &i__4, dummy, &work[1], &c_n1, & childinfo);
560  lorglqworkopt = (integer) work[1];
561  /* Computing MAX */
562  i__1 = 1;
563  i__2 = *m - *q; // , expr subst
564  lorglqworkmin = max(i__1,i__2);
565  /* Computing MAX */
566  i__1 = 1;
567  i__2 = *m - *q; // , expr subst
568  iorbdb = itauq2 + max(i__1,i__2);
569  sorbdb_(trans, signs, m, p, q, &x11[x11_offset], ldx11, &x12[ x12_offset], ldx12, &x21[x21_offset], ldx21, &x22[x22_offset], ldx22, dummy, dummy, dummy, dummy, dummy, dummy, &work[1], & c_n1, &childinfo);
570  lorbdbworkopt = (integer) work[1];
571  lorbdbworkmin = lorbdbworkopt;
572  /* Computing MAX */
573  i__1 = 1;
574  i__2 = *m - *q; // , expr subst
575  ib11d = itauq2 + max(i__1,i__2);
576  ib11e = ib11d + max(1,*q);
577  /* Computing MAX */
578  i__1 = 1;
579  i__2 = *q - 1; // , expr subst
580  ib12d = ib11e + max(i__1,i__2);
581  ib12e = ib12d + max(1,*q);
582  /* Computing MAX */
583  i__1 = 1;
584  i__2 = *q - 1; // , expr subst
585  ib21d = ib12e + max(i__1,i__2);
586  ib21e = ib21d + max(1,*q);
587  /* Computing MAX */
588  i__1 = 1;
589  i__2 = *q - 1; // , expr subst
590  ib22d = ib21e + max(i__1,i__2);
591  ib22e = ib22d + max(1,*q);
592  /* Computing MAX */
593  i__1 = 1;
594  i__2 = *q - 1; // , expr subst
595  ibbcsd = ib22e + max(i__1,i__2);
596  sbbcsd_(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, dummy, dummy, & u1[u1_offset], ldu1, &u2[u2_offset], ldu2, &v1t[v1t_offset], ldv1t, &v2t[v2t_offset], ldv2t, dummy, dummy, dummy, dummy, dummy, dummy, dummy, dummy, &work[1], &c_n1, &childinfo);
597  lbbcsdworkopt = (integer) work[1];
598  lbbcsdworkmin = lbbcsdworkopt;
599  /* Computing MAX */
600  i__1 = iorgqr + lorgqrworkopt, i__2 = iorglq + lorglqworkopt, i__1 = max(i__1,i__2), i__2 = iorbdb + lorbdbworkopt;
601  i__1 = max( i__1,i__2);
602  i__2 = ibbcsd + lbbcsdworkopt; // ; expr subst
603  lworkopt = max(i__1,i__2) - 1;
604  /* Computing MAX */
605  i__1 = iorgqr + lorgqrworkmin, i__2 = iorglq + lorglqworkmin, i__1 = max(i__1,i__2), i__2 = iorbdb + lorbdbworkopt;
606  i__1 = max( i__1,i__2);
607  i__2 = ibbcsd + lbbcsdworkmin; // ; expr subst
608  lworkmin = max(i__1,i__2) - 1;
609  work[1] = (real) max(lworkopt,lworkmin);
610  if (*lwork < lworkmin && ! lquery)
611  {
612  *info = -22;
613  }
614  else
615  {
616  lorgqrwork = *lwork - iorgqr + 1;
617  lorglqwork = *lwork - iorglq + 1;
618  lorbdbwork = *lwork - iorbdb + 1;
619  lbbcsdwork = *lwork - ibbcsd + 1;
620  }
621  }
622  /* Abort if any illegal arguments */
623  if (*info != 0)
624  {
625  i__1 = -(*info);
626  xerbla_("SORCSD", &i__1);
627  return 0;
628  }
629  else if (lquery)
630  {
631  return 0;
632  }
633  /* Transform to bidiagonal block form */
634  sorbdb_(trans, signs, m, p, q, &x11[x11_offset], ldx11, &x12[x12_offset], ldx12, &x21[x21_offset], ldx21, &x22[x22_offset], ldx22, &theta[1] , &work[iphi], &work[itaup1], &work[itaup2], &work[itauq1], &work[ itauq2], &work[iorbdb], &lorbdbwork, &childinfo);
635  /* Accumulate Householder reflectors */
636  if (colmajor)
637  {
638  if (wantu1 && *p > 0)
639  {
640  slacpy_("L", p, q, &x11[x11_offset], ldx11, &u1[u1_offset], ldu1);
641  sorgqr_fla(p, p, q, &u1[u1_offset], ldu1, &work[itaup1], &work[ iorgqr], &lorgqrwork, info);
642  }
643  if (wantu2 && *m - *p > 0)
644  {
645  i__1 = *m - *p;
646  slacpy_("L", &i__1, q, &x21[x21_offset], ldx21, &u2[u2_offset], ldu2);
647  i__1 = *m - *p;
648  i__2 = *m - *p;
649  sorgqr_fla(&i__1, &i__2, q, &u2[u2_offset], ldu2, &work[itaup2], & work[iorgqr], &lorgqrwork, info);
650  }
651  if (wantv1t && *q > 0)
652  {
653  i__1 = *q - 1;
654  i__2 = *q - 1;
655  slacpy_("U", &i__1, &i__2, &x11[(x11_dim1 << 1) + 1], ldx11, &v1t[ (v1t_dim1 << 1) + 2], ldv1t);
656  v1t[v1t_dim1 + 1] = 1.f;
657  i__1 = *q;
658  for (j = 2;
659  j <= i__1;
660  ++j)
661  {
662  v1t[j * v1t_dim1 + 1] = 0.f;
663  v1t[j + v1t_dim1] = 0.f;
664  }
665  i__1 = *q - 1;
666  i__2 = *q - 1;
667  i__3 = *q - 1;
668  sorglq_fla(&i__1, &i__2, &i__3, &v1t[(v1t_dim1 << 1) + 2], ldv1t, & work[itauq1], &work[iorglq], &lorglqwork, info);
669  }
670  if (wantv2t && *m - *q > 0)
671  {
672  i__1 = *m - *q;
673  slacpy_("U", p, &i__1, &x12[x12_offset], ldx12, &v2t[v2t_offset], ldv2t);
674  i__1 = *m - *p - *q;
675  i__2 = *m - *p - *q;
676  slacpy_("U", &i__1, &i__2, &x22[*q + 1 + (*p + 1) * x22_dim1], ldx22, &v2t[*p + 1 + (*p + 1) * v2t_dim1], ldv2t);
677  i__1 = *m - *q;
678  i__2 = *m - *q;
679  i__3 = *m - *q;
680  sorglq_fla(&i__1, &i__2, &i__3, &v2t[v2t_offset], ldv2t, &work[ itauq2], &work[iorglq], &lorglqwork, info);
681  }
682  }
683  else
684  {
685  if (wantu1 && *p > 0)
686  {
687  slacpy_("U", q, p, &x11[x11_offset], ldx11, &u1[u1_offset], ldu1);
688  sorglq_fla(p, p, q, &u1[u1_offset], ldu1, &work[itaup1], &work[ iorglq], &lorglqwork, info);
689  }
690  if (wantu2 && *m - *p > 0)
691  {
692  i__1 = *m - *p;
693  slacpy_("U", q, &i__1, &x21[x21_offset], ldx21, &u2[u2_offset], ldu2);
694  i__1 = *m - *p;
695  i__2 = *m - *p;
696  sorglq_fla(&i__1, &i__2, q, &u2[u2_offset], ldu2, &work[itaup2], & work[iorglq], &lorglqwork, info);
697  }
698  if (wantv1t && *q > 0)
699  {
700  i__1 = *q - 1;
701  i__2 = *q - 1;
702  slacpy_("L", &i__1, &i__2, &x11[x11_dim1 + 2], ldx11, &v1t[( v1t_dim1 << 1) + 2], ldv1t);
703  v1t[v1t_dim1 + 1] = 1.f;
704  i__1 = *q;
705  for (j = 2;
706  j <= i__1;
707  ++j)
708  {
709  v1t[j * v1t_dim1 + 1] = 0.f;
710  v1t[j + v1t_dim1] = 0.f;
711  }
712  i__1 = *q - 1;
713  i__2 = *q - 1;
714  i__3 = *q - 1;
715  sorgqr_fla(&i__1, &i__2, &i__3, &v1t[(v1t_dim1 << 1) + 2], ldv1t, & work[itauq1], &work[iorgqr], &lorgqrwork, info);
716  }
717  if (wantv2t && *m - *q > 0)
718  {
719  i__1 = *m - *q;
720  slacpy_("L", &i__1, p, &x12[x12_offset], ldx12, &v2t[v2t_offset], ldv2t);
721  i__1 = *m - *p - *q;
722  i__2 = *m - *p - *q;
723  slacpy_("L", &i__1, &i__2, &x22[*p + 1 + (*q + 1) * x22_dim1], ldx22, &v2t[*p + 1 + (*p + 1) * v2t_dim1], ldv2t);
724  i__1 = *m - *q;
725  i__2 = *m - *q;
726  i__3 = *m - *q;
727  sorgqr_fla(&i__1, &i__2, &i__3, &v2t[v2t_offset], ldv2t, &work[ itauq2], &work[iorgqr], &lorgqrwork, info);
728  }
729  }
730  /* Compute the CSD of the matrix in bidiagonal-block form */
731  sbbcsd_(jobu1, jobu2, jobv1t, jobv2t, trans, m, p, q, &theta[1], &work[ iphi], &u1[u1_offset], ldu1, &u2[u2_offset], ldu2, &v1t[ v1t_offset], ldv1t, &v2t[v2t_offset], ldv2t, &work[ib11d], &work[ ib11e], &work[ib12d], &work[ib12e], &work[ib21d], &work[ib21e], & work[ib22d], &work[ib22e], &work[ibbcsd], &lbbcsdwork, info);
732  /* Permute rows and columns to place identity submatrices in top- */
733  /* left corner of (1,1)-block and/or bottom-right corner of (1,2)- */
734  /* block and/or bottom-right corner of (2,1)-block and/or top-left */
735  /* corner of (2,2)-block */
736  if (*q > 0 && wantu2)
737  {
738  i__1 = *q;
739  for (i__ = 1;
740  i__ <= i__1;
741  ++i__)
742  {
743  iwork[i__] = *m - *p - *q + i__;
744  }
745  i__1 = *m - *p;
746  for (i__ = *q + 1;
747  i__ <= i__1;
748  ++i__)
749  {
750  iwork[i__] = i__ - *q;
751  }
752  if (colmajor)
753  {
754  i__1 = *m - *p;
755  i__2 = *m - *p;
756  slapmt_(&c_false, &i__1, &i__2, &u2[u2_offset], ldu2, &iwork[1]);
757  }
758  else
759  {
760  i__1 = *m - *p;
761  i__2 = *m - *p;
762  slapmr_(&c_false, &i__1, &i__2, &u2[u2_offset], ldu2, &iwork[1]);
763  }
764  }
765  if (*m > 0 && wantv2t)
766  {
767  i__1 = *p;
768  for (i__ = 1;
769  i__ <= i__1;
770  ++i__)
771  {
772  iwork[i__] = *m - *p - *q + i__;
773  }
774  i__1 = *m - *q;
775  for (i__ = *p + 1;
776  i__ <= i__1;
777  ++i__)
778  {
779  iwork[i__] = i__ - *p;
780  }
781  if (! colmajor)
782  {
783  i__1 = *m - *q;
784  i__2 = *m - *q;
785  slapmt_(&c_false, &i__1, &i__2, &v2t[v2t_offset], ldv2t, &iwork[1] );
786  }
787  else
788  {
789  i__1 = *m - *q;
790  i__2 = *m - *q;
791  slapmr_(&c_false, &i__1, &i__2, &v2t[v2t_offset], ldv2t, &iwork[1] );
792  }
793  }
794  return 0;
795  /* End SORCSD */
796 }
int sorcsd_(char *jobu1, char *jobu2, char *jobv1t, char *jobv2t, char *trans, char *signs, integer *m, integer *p, integer *q, real *x11, integer *ldx11, real *x12, integer *ldx12, real *x21, integer *ldx21, real *x22, integer *ldx22, real *theta, real *u1, integer *ldu1, real *u2, integer *ldu2, real *v1t, integer *ldv1t, real *v2t, integer *ldv2t, real *work, integer *lwork, integer *iwork, integer *info)
Definition: sorcsd.c:294
int sorglq_fla(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info)
Definition: sorglq.c:122
float real
Definition: FLA_f2c.h:30
int logical
Definition: FLA_f2c.h:36
int integer
Definition: FLA_f2c.h:25
int sorgqr_fla(integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *work, integer *lwork, integer *info)
Definition: sorgqr.c:123