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 
)
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}
integer
int integer
Definition FLA_f2c.h:25
logical
int logical
Definition FLA_f2c.h:36
real
float real
Definition FLA_f2c.h:30
i
int i
Definition bl1_axmyv2.c:145
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)
Definition sorcsd.c:294
sorglq_fla
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
sorgqr_fla
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

References i, sorcsd_(), sorglq_fla(), and sorgqr_fla().

Referenced by sorcsd_().

Generated on Thu Sep 23 2021 17:46:17 for libflame by doxygen 1.9.8