OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
cblat3.f File Reference

Go to the source code of this file.

Functions/Subroutines

program cblat3
 CBLAT3
subroutine cchk1 (sname, eps, thresh, nout, ntra, trace, rewi, fatal, nidim, idim, nalf, alf, nbet, bet, nmax, a, aa, as, b, bb, bs, c, cc, cs, ct, g)
subroutine cchk2 (sname, eps, thresh, nout, ntra, trace, rewi, fatal, nidim, idim, nalf, alf, nbet, bet, nmax, a, aa, as, b, bb, bs, c, cc, cs, ct, g)
subroutine cchk3 (sname, eps, thresh, nout, ntra, trace, rewi, fatal, nidim, idim, nalf, alf, nmax, a, aa, as, b, bb, bs, ct, g, c)
subroutine cchk4 (sname, eps, thresh, nout, ntra, trace, rewi, fatal, nidim, idim, nalf, alf, nbet, bet, nmax, a, aa, as, b, bb, bs, c, cc, cs, ct, g)
subroutine cchk5 (sname, eps, thresh, nout, ntra, trace, rewi, fatal, nidim, idim, nalf, alf, nbet, bet, nmax, ab, aa, as, bb, bs, c, cc, cs, ct, g, w)
subroutine cchke (isnum, srnamt, nout)
subroutine cmake (type, uplo, diag, m, n, a, nmax, aa, lda, reset, transl)
subroutine cmmch (transa, transb, m, n, kk, alpha, a, lda, b, ldb, beta, c, ldc, ct, g, cc, ldcc, eps, err, fatal, nout, mv)
logical function lce (ri, rj, lr)
logical function lceres (type, uplo, m, n, aa, as, lda)
complex function cbeg (reset)
real function sdiff (x, y)
subroutine chkxer (srnamt, infot, nout, lerr, ok)
subroutine xerbla (srname, info)

Function/Subroutine Documentation

◆ cbeg()

complex function cbeg ( logical reset)

Definition at line 3331 of file cblat3.f.

3332*
3333* Generates complex numbers as pairs of random numbers uniformly
3334* distributed between -0.5 and 0.5.
3335*
3336* Auxiliary routine for test program for Level 3 Blas.
3337*
3338* -- Written on 8-February-1989.
3339* Jack Dongarra, Argonne National Laboratory.
3340* Iain Duff, AERE Harwell.
3341* Jeremy Du Croz, Numerical Algorithms Group Ltd.
3342* Sven Hammarling, Numerical Algorithms Group Ltd.
3343*
3344* .. Scalar Arguments ..
3345 LOGICAL RESET
3346* .. Local Scalars ..
3347 INTEGER I, IC, J, MI, MJ
3348* .. Save statement ..
3349 SAVE i, ic, j, mi, mj
3350* .. Intrinsic Functions ..
3351 INTRINSIC cmplx
3352* .. Executable Statements ..
3353 IF( reset )THEN
3354* Initialize local variables.
3355 mi = 891
3356 mj = 457
3357 i = 7
3358 j = 7
3359 ic = 0
3360 reset = .false.
3361 END IF
3362*
3363* The sequence of values of I or J is bounded between 1 and 999.
3364* If initial I or J = 1,2,3,6,7 or 9, the period will be 50.
3365* If initial I or J = 4 or 8, the period will be 25.
3366* If initial I or J = 5, the period will be 10.
3367* IC is used to break up the period by skipping 1 value of I or J
3368* in 6.
3369*
3370 ic = ic + 1
3371 10 i = i*mi
3372 j = j*mj
3373 i = i - 1000*( i/1000 )
3374 j = j - 1000*( j/1000 )
3375 IF( ic.GE.5 )THEN
3376 ic = 0
3377 GO TO 10
3378 END IF
3379 cbeg = cmplx( ( i - 500 )/1001.0, ( j - 500 )/1001.0 )
3380 RETURN
3381*
3382* End of CBEG
3383*
cmplx
float cmplx[2]
Definition pblas.h:136
cbeg
complex function cbeg(reset)
Definition cblat3.f:3332

◆ cchk1()

subroutine cchk1 ( character*6 sname,
real eps,
real thresh,
integer nout,
integer ntra,
logical trace,
logical rewi,
logical fatal,
integer nidim,
integer, dimension( nidim ) idim,
integer nalf,
complex, dimension( nalf ) alf,
integer nbet,
complex, dimension( nbet ) bet,
integer nmax,
complex, dimension( nmax, nmax ) a,
complex, dimension( nmax*nmax ) aa,
complex, dimension( nmax*nmax ) as,
complex, dimension( nmax, nmax ) b,
complex, dimension( nmax*nmax ) bb,
complex, dimension( nmax*nmax ) bs,
complex, dimension( nmax, nmax ) c,
complex, dimension( nmax*nmax ) cc,
complex, dimension( nmax*nmax ) cs,
complex, dimension( nmax ) ct,
real, dimension( nmax ) g )

Definition at line 402 of file cblat3.f.

405*
406* Tests CGEMM.
407*
408* Auxiliary routine for test program for Level 3 Blas.
409*
410* -- Written on 8-February-1989.
411* Jack Dongarra, Argonne National Laboratory.
412* Iain Duff, AERE Harwell.
413* Jeremy Du Croz, Numerical Algorithms Group Ltd.
414* Sven Hammarling, Numerical Algorithms Group Ltd.
415*
416* .. Parameters ..
417 COMPLEX ZERO
418 parameter( zero = ( 0.0, 0.0 ) )
419 REAL RZERO
420 parameter( rzero = 0.0 )
421* .. Scalar Arguments ..
422 REAL EPS, THRESH
423 INTEGER NALF, NBET, NIDIM, NMAX, NOUT, NTRA
424 LOGICAL FATAL, REWI, TRACE
425 CHARACTER*6 SNAME
426* .. Array Arguments ..
427 COMPLEX A( NMAX, NMAX ), AA( NMAX*NMAX ), ALF( NALF ),
428 $ AS( NMAX*NMAX ), B( NMAX, NMAX ),
429 $ BB( NMAX*NMAX ), BET( NBET ), BS( NMAX*NMAX ),
430 $ C( NMAX, NMAX ), CC( NMAX*NMAX ),
431 $ CS( NMAX*NMAX ), CT( NMAX )
432 REAL G( NMAX )
433 INTEGER IDIM( NIDIM )
434* .. Local Scalars ..
435 COMPLEX ALPHA, ALS, BETA, BLS
436 REAL ERR, ERRMAX
437 INTEGER I, IA, IB, ICA, ICB, IK, IM, IN, K, KS, LAA,
438 $ LBB, LCC, LDA, LDAS, LDB, LDBS, LDC, LDCS, M,
439 $ MA, MB, MS, N, NA, NARGS, NB, NC, NS
440 LOGICAL NULL, RESET, SAME, TRANA, TRANB
441 CHARACTER*1 TRANAS, TRANBS, TRANSA, TRANSB
442 CHARACTER*3 ICH
443* .. Local Arrays ..
444 LOGICAL ISAME( 13 )
445* .. External Functions ..
446 LOGICAL LCE, LCERES
447 EXTERNAL lce, lceres
448* .. External Subroutines ..
449 EXTERNAL cgemm, cmake, cmmch
450* .. Intrinsic Functions ..
451 INTRINSIC max
452* .. Scalars in Common ..
453 INTEGER INFOT, NOUTC
454 LOGICAL LERR, OK
455* .. Common blocks ..
456 COMMON /infoc/infot, noutc, ok, lerr
457* .. Data statements ..
458 DATA ich/'NTC'/
459* .. Executable Statements ..
460*
461 nargs = 13
462 nc = 0
463 reset = .true.
464 errmax = rzero
465*
466 DO 110 im = 1, nidim
467 m = idim( im )
468*
469 DO 100 in = 1, nidim
470 n = idim( in )
471* Set LDC to 1 more than minimum value if room.
472 ldc = m
473 IF( ldc.LT.nmax )
474 $ ldc = ldc + 1
475* Skip tests if not enough room.
476 IF( ldc.GT.nmax )
477 $ GO TO 100
478 lcc = ldc*n
479 null = n.LE.0.OR.m.LE.0
480*
481 DO 90 ik = 1, nidim
482 k = idim( ik )
483*
484 DO 80 ica = 1, 3
485 transa = ich( ica: ica )
486 trana = transa.EQ.'T'.OR.transa.EQ.'C'
487*
488 IF( trana )THEN
489 ma = k
490 na = m
491 ELSE
492 ma = m
493 na = k
494 END IF
495* Set LDA to 1 more than minimum value if room.
496 lda = ma
497 IF( lda.LT.nmax )
498 $ lda = lda + 1
499* Skip tests if not enough room.
500 IF( lda.GT.nmax )
501 $ GO TO 80
502 laa = lda*na
503*
504* Generate the matrix A.
505*
506 CALL cmake( 'GE', ' ', ' ', ma, na, a, nmax, aa, lda,
507 $ reset, zero )
508*
509 DO 70 icb = 1, 3
510 transb = ich( icb: icb )
511 tranb = transb.EQ.'T'.OR.transb.EQ.'C'
512*
513 IF( tranb )THEN
514 mb = n
515 nb = k
516 ELSE
517 mb = k
518 nb = n
519 END IF
520* Set LDB to 1 more than minimum value if room.
521 ldb = mb
522 IF( ldb.LT.nmax )
523 $ ldb = ldb + 1
524* Skip tests if not enough room.
525 IF( ldb.GT.nmax )
526 $ GO TO 70
527 lbb = ldb*nb
528*
529* Generate the matrix B.
530*
531 CALL cmake( 'GE', ' ', ' ', mb, nb, b, nmax, bb,
532 $ ldb, reset, zero )
533*
534 DO 60 ia = 1, nalf
535 alpha = alf( ia )
536*
537 DO 50 ib = 1, nbet
538 beta = bet( ib )
539*
540* Generate the matrix C.
541*
542 CALL cmake( 'GE', ' ', ' ', m, n, c, nmax,
543 $ cc, ldc, reset, zero )
544*
545 nc = nc + 1
546*
547* Save every datum before calling the
548* subroutine.
549*
550 tranas = transa
551 tranbs = transb
552 ms = m
553 ns = n
554 ks = k
555 als = alpha
556 DO 10 i = 1, laa
557 as( i ) = aa( i )
558 10 CONTINUE
559 ldas = lda
560 DO 20 i = 1, lbb
561 bs( i ) = bb( i )
562 20 CONTINUE
563 ldbs = ldb
564 bls = beta
565 DO 30 i = 1, lcc
566 cs( i ) = cc( i )
567 30 CONTINUE
568 ldcs = ldc
569*
570* Call the subroutine.
571*
572 IF( trace )
573 $ WRITE( ntra, fmt = 9995 )nc, sname,
574 $ transa, transb, m, n, k, alpha, lda, ldb,
575 $ beta, ldc
576 IF( rewi )
577 $ rewind ntra
578 CALL cgemm( transa, transb, m, n, k, alpha,
579 $ aa, lda, bb, ldb, beta, cc, ldc )
580*
581* Check if error-exit was taken incorrectly.
582*
583 IF( .NOT.ok )THEN
584 WRITE( nout, fmt = 9994 )
585 fatal = .true.
586 GO TO 120
587 END IF
588*
589* See what data changed inside subroutines.
590*
591 isame( 1 ) = transa.EQ.tranas
592 isame( 2 ) = transb.EQ.tranbs
593 isame( 3 ) = ms.EQ.m
594 isame( 4 ) = ns.EQ.n
595 isame( 5 ) = ks.EQ.k
596 isame( 6 ) = als.EQ.alpha
597 isame( 7 ) = lce( as, aa, laa )
598 isame( 8 ) = ldas.EQ.lda
599 isame( 9 ) = lce( bs, bb, lbb )
600 isame( 10 ) = ldbs.EQ.ldb
601 isame( 11 ) = bls.EQ.beta
602 IF( null )THEN
603 isame( 12 ) = lce( cs, cc, lcc )
604 ELSE
605 isame( 12 ) = lceres( 'GE', ' ', m, n, cs,
606 $ cc, ldc )
607 END IF
608 isame( 13 ) = ldcs.EQ.ldc
609*
610* If data was incorrectly changed, report
611* and return.
612*
613 same = .true.
614 DO 40 i = 1, nargs
615 same = same.AND.isame( i )
616 IF( .NOT.isame( i ) )
617 $ WRITE( nout, fmt = 9998 )i
618 40 CONTINUE
619 IF( .NOT.same )THEN
620 fatal = .true.
621 GO TO 120
622 END IF
623*
624 IF( .NOT.null )THEN
625*
626* Check the result.
627*
628 CALL cmmch( transa, transb, m, n, k,
629 $ alpha, a, nmax, b, nmax, beta,
630 $ c, nmax, ct, g, cc, ldc, eps,
631 $ err, fatal, nout, .true. )
632 errmax = max( errmax, err )
633* If got really bad answer, report and
634* return.
635 IF( fatal )
636 $ GO TO 120
637 END IF
638*
639 50 CONTINUE
640*
641 60 CONTINUE
642*
643 70 CONTINUE
644*
645 80 CONTINUE
646*
647 90 CONTINUE
648*
649 100 CONTINUE
650*
651 110 CONTINUE
652*
653* Report result.
654*
655 IF( errmax.LT.thresh )THEN
656 WRITE( nout, fmt = 9999 )sname, nc
657 ELSE
658 WRITE( nout, fmt = 9997 )sname, nc, errmax
659 END IF
660 GO TO 130
661*
662 120 CONTINUE
663 WRITE( nout, fmt = 9996 )sname
664 WRITE( nout, fmt = 9995 )nc, sname, transa, transb, m, n, k,
665 $ alpha, lda, ldb, beta, ldc
666*
667 130 CONTINUE
668 RETURN
669*
670 9999 FORMAT( ' ', a6, ' PASSED THE COMPUTATIONAL TESTS (', i6, ' CALL',
671 $ 'S)' )
672 9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', i2, ' WAS CH',
673 $ 'ANGED INCORRECTLY *******' )
674 9997 FORMAT( ' ', a6, ' COMPLETED THE COMPUTATIONAL TESTS (', i6, ' C',
675 $ 'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', f8.2,
676 $ ' - SUSPECT *******' )
677 9996 FORMAT( ' ******* ', a6, ' FAILED ON CALL NUMBER:' )
678 9995 FORMAT( 1x, i6, ': ', a6, '(''', a1, ''',''', a1, ''',',
679 $ 3( i3, ',' ), '(', f4.1, ',', f4.1, '), A,', i3, ', B,', i3,
680 $ ',(', f4.1, ',', f4.1, '), C,', i3, ').' )
681 9994 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *',
682 $ '******' )
683*
684* End of CCHK1
685*
cmmch
subroutine cmmch(transa, transb, m, n, kk, alpha, a, lda, b, ldb, beta, c, ldc, ct, g, cc, ldcc, eps, err, fatal, nout, mv)
Definition cblat3.f:3053
lceres
logical function lceres(type, uplo, m, n, aa, as, lda)
Definition cblat3.f:3271
lce
logical function lce(ri, rj, lr)
Definition cblat3.f:3239
cmake
subroutine cmake(type, uplo, diag, m, n, a, nmax, aa, lda, reset, transl)
Definition cblat3.f:2924
alpha
#define alpha
Definition eval.h:35
cgemm
subroutine cgemm(transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
CGEMM
Definition cgemm.f:187
max
#define max(a, b)
Definition macros.h:21
fatal
void fatal(char *msg)
Definition sys_pipes_c.c:76

◆ cchk2()

subroutine cchk2 ( character*6 sname,
real eps,
real thresh,
integer nout,
integer ntra,
logical trace,
logical rewi,
logical fatal,
integer nidim,
integer, dimension( nidim ) idim,
integer nalf,
complex, dimension( nalf ) alf,
integer nbet,
complex, dimension( nbet ) bet,
integer nmax,
complex, dimension( nmax, nmax ) a,
complex, dimension( nmax*nmax ) aa,
complex, dimension( nmax*nmax ) as,
complex, dimension( nmax, nmax ) b,
complex, dimension( nmax*nmax ) bb,
complex, dimension( nmax*nmax ) bs,
complex, dimension( nmax, nmax ) c,
complex, dimension( nmax*nmax ) cc,
complex, dimension( nmax*nmax ) cs,
complex, dimension( nmax ) ct,
real, dimension( nmax ) g )

Definition at line 687 of file cblat3.f.

690*
691* Tests CHEMM and CSYMM.
692*
693* Auxiliary routine for test program for Level 3 Blas.
694*
695* -- Written on 8-February-1989.
696* Jack Dongarra, Argonne National Laboratory.
697* Iain Duff, AERE Harwell.
698* Jeremy Du Croz, Numerical Algorithms Group Ltd.
699* Sven Hammarling, Numerical Algorithms Group Ltd.
700*
701* .. Parameters ..
702 COMPLEX ZERO
703 parameter( zero = ( 0.0, 0.0 ) )
704 REAL RZERO
705 parameter( rzero = 0.0 )
706* .. Scalar Arguments ..
707 REAL EPS, THRESH
708 INTEGER NALF, NBET, NIDIM, NMAX, NOUT, NTRA
709 LOGICAL FATAL, REWI, TRACE
710 CHARACTER*6 SNAME
711* .. Array Arguments ..
712 COMPLEX A( NMAX, NMAX ), AA( NMAX*NMAX ), ALF( NALF ),
713 $ AS( NMAX*NMAX ), B( NMAX, NMAX ),
714 $ BB( NMAX*NMAX ), BET( NBET ), BS( NMAX*NMAX ),
715 $ C( NMAX, NMAX ), CC( NMAX*NMAX ),
716 $ CS( NMAX*NMAX ), CT( NMAX )
717 REAL G( NMAX )
718 INTEGER IDIM( NIDIM )
719* .. Local Scalars ..
720 COMPLEX ALPHA, ALS, BETA, BLS
721 REAL ERR, ERRMAX
722 INTEGER I, IA, IB, ICS, ICU, IM, IN, LAA, LBB, LCC,
723 $ LDA, LDAS, LDB, LDBS, LDC, LDCS, M, MS, N, NA,
724 $ NARGS, NC, NS
725 LOGICAL CONJ, LEFT, NULL, RESET, SAME
726 CHARACTER*1 SIDE, SIDES, UPLO, UPLOS
727 CHARACTER*2 ICHS, ICHU
728* .. Local Arrays ..
729 LOGICAL ISAME( 13 )
730* .. External Functions ..
731 LOGICAL LCE, LCERES
732 EXTERNAL lce, lceres
733* .. External Subroutines ..
734 EXTERNAL chemm, cmake, cmmch, csymm
735* .. Intrinsic Functions ..
736 INTRINSIC max
737* .. Scalars in Common ..
738 INTEGER INFOT, NOUTC
739 LOGICAL LERR, OK
740* .. Common blocks ..
741 COMMON /infoc/infot, noutc, ok, lerr
742* .. Data statements ..
743 DATA ichs/'LR'/, ichu/'UL'/
744* .. Executable Statements ..
745 conj = sname( 2: 3 ).EQ.'HE'
746*
747 nargs = 12
748 nc = 0
749 reset = .true.
750 errmax = rzero
751*
752 DO 100 im = 1, nidim
753 m = idim( im )
754*
755 DO 90 in = 1, nidim
756 n = idim( in )
757* Set LDC to 1 more than minimum value if room.
758 ldc = m
759 IF( ldc.LT.nmax )
760 $ ldc = ldc + 1
761* Skip tests if not enough room.
762 IF( ldc.GT.nmax )
763 $ GO TO 90
764 lcc = ldc*n
765 null = n.LE.0.OR.m.LE.0
766* Set LDB to 1 more than minimum value if room.
767 ldb = m
768 IF( ldb.LT.nmax )
769 $ ldb = ldb + 1
770* Skip tests if not enough room.
771 IF( ldb.GT.nmax )
772 $ GO TO 90
773 lbb = ldb*n
774*
775* Generate the matrix B.
776*
777 CALL cmake( 'GE', ' ', ' ', m, n, b, nmax, bb, ldb, reset,
778 $ zero )
779*
780 DO 80 ics = 1, 2
781 side = ichs( ics: ics )
782 left = side.EQ.'L'
783*
784 IF( left )THEN
785 na = m
786 ELSE
787 na = n
788 END IF
789* Set LDA to 1 more than minimum value if room.
790 lda = na
791 IF( lda.LT.nmax )
792 $ lda = lda + 1
793* Skip tests if not enough room.
794 IF( lda.GT.nmax )
795 $ GO TO 80
796 laa = lda*na
797*
798 DO 70 icu = 1, 2
799 uplo = ichu( icu: icu )
800*
801* Generate the hermitian or symmetric matrix A.
802*
803 CALL cmake( sname( 2: 3 ), uplo, ' ', na, na, a, nmax,
804 $ aa, lda, reset, zero )
805*
806 DO 60 ia = 1, nalf
807 alpha = alf( ia )
808*
809 DO 50 ib = 1, nbet
810 beta = bet( ib )
811*
812* Generate the matrix C.
813*
814 CALL cmake( 'GE', ' ', ' ', m, n, c, nmax, cc,
815 $ ldc, reset, zero )
816*
817 nc = nc + 1
818*
819* Save every datum before calling the
820* subroutine.
821*
822 sides = side
823 uplos = uplo
824 ms = m
825 ns = n
826 als = alpha
827 DO 10 i = 1, laa
828 as( i ) = aa( i )
829 10 CONTINUE
830 ldas = lda
831 DO 20 i = 1, lbb
832 bs( i ) = bb( i )
833 20 CONTINUE
834 ldbs = ldb
835 bls = beta
836 DO 30 i = 1, lcc
837 cs( i ) = cc( i )
838 30 CONTINUE
839 ldcs = ldc
840*
841* Call the subroutine.
842*
843 IF( trace )
844 $ WRITE( ntra, fmt = 9995 )nc, sname, side,
845 $ uplo, m, n, alpha, lda, ldb, beta, ldc
846 IF( rewi )
847 $ rewind ntra
848 IF( conj )THEN
849 CALL chemm( side, uplo, m, n, alpha, aa, lda,
850 $ bb, ldb, beta, cc, ldc )
851 ELSE
852 CALL csymm( side, uplo, m, n, alpha, aa, lda,
853 $ bb, ldb, beta, cc, ldc )
854 END IF
855*
856* Check if error-exit was taken incorrectly.
857*
858 IF( .NOT.ok )THEN
859 WRITE( nout, fmt = 9994 )
860 fatal = .true.
861 GO TO 110
862 END IF
863*
864* See what data changed inside subroutines.
865*
866 isame( 1 ) = sides.EQ.side
867 isame( 2 ) = uplos.EQ.uplo
868 isame( 3 ) = ms.EQ.m
869 isame( 4 ) = ns.EQ.n
870 isame( 5 ) = als.EQ.alpha
871 isame( 6 ) = lce( as, aa, laa )
872 isame( 7 ) = ldas.EQ.lda
873 isame( 8 ) = lce( bs, bb, lbb )
874 isame( 9 ) = ldbs.EQ.ldb
875 isame( 10 ) = bls.EQ.beta
876 IF( null )THEN
877 isame( 11 ) = lce( cs, cc, lcc )
878 ELSE
879 isame( 11 ) = lceres( 'GE', ' ', m, n, cs,
880 $ cc, ldc )
881 END IF
882 isame( 12 ) = ldcs.EQ.ldc
883*
884* If data was incorrectly changed, report and
885* return.
886*
887 same = .true.
888 DO 40 i = 1, nargs
889 same = same.AND.isame( i )
890 IF( .NOT.isame( i ) )
891 $ WRITE( nout, fmt = 9998 )i
892 40 CONTINUE
893 IF( .NOT.same )THEN
894 fatal = .true.
895 GO TO 110
896 END IF
897*
898 IF( .NOT.null )THEN
899*
900* Check the result.
901*
902 IF( left )THEN
903 CALL cmmch( 'N', 'N', m, n, m, alpha, a,
904 $ nmax, b, nmax, beta, c, nmax,
905 $ ct, g, cc, ldc, eps, err,
906 $ fatal, nout, .true. )
907 ELSE
908 CALL cmmch( 'N', 'N', m, n, n, alpha, b,
909 $ nmax, a, nmax, beta, c, nmax,
910 $ ct, g, cc, ldc, eps, err,
911 $ fatal, nout, .true. )
912 END IF
913 errmax = max( errmax, err )
914* If got really bad answer, report and
915* return.
916 IF( fatal )
917 $ GO TO 110
918 END IF
919*
920 50 CONTINUE
921*
922 60 CONTINUE
923*
924 70 CONTINUE
925*
926 80 CONTINUE
927*
928 90 CONTINUE
929*
930 100 CONTINUE
931*
932* Report result.
933*
934 IF( errmax.LT.thresh )THEN
935 WRITE( nout, fmt = 9999 )sname, nc
936 ELSE
937 WRITE( nout, fmt = 9997 )sname, nc, errmax
938 END IF
939 GO TO 120
940*
941 110 CONTINUE
942 WRITE( nout, fmt = 9996 )sname
943 WRITE( nout, fmt = 9995 )nc, sname, side, uplo, m, n, alpha, lda,
944 $ ldb, beta, ldc
945*
946 120 CONTINUE
947 RETURN
948*
949 9999 FORMAT( ' ', a6, ' PASSED THE COMPUTATIONAL TESTS (', i6, ' CALL',
950 $ 'S)' )
951 9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', i2, ' WAS CH',
952 $ 'ANGED INCORRECTLY *******' )
953 9997 FORMAT( ' ', a6, ' COMPLETED THE COMPUTATIONAL TESTS (', i6, ' C',
954 $ 'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', f8.2,
955 $ ' - SUSPECT *******' )
956 9996 FORMAT( ' ******* ', a6, ' FAILED ON CALL NUMBER:' )
957 9995 FORMAT( 1x, i6, ': ', a6, '(', 2( '''', a1, ''',' ), 2( i3, ',' ),
958 $ '(', f4.1, ',', f4.1, '), A,', i3, ', B,', i3, ',(', f4.1,
959 $ ',', f4.1, '), C,', i3, ') .' )
960 9994 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *',
961 $ '******' )
962*
963* End of CCHK2
964*
chemm
subroutine chemm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
CHEMM
Definition chemm.f:191
csymm
subroutine csymm(side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
CSYMM
Definition csymm.f:189

◆ cchk3()

subroutine cchk3 ( character*6 sname,
real eps,
real thresh,
integer nout,
integer ntra,
logical trace,
logical rewi,
logical fatal,
integer nidim,
integer, dimension( nidim ) idim,
integer nalf,
complex, dimension( nalf ) alf,
integer nmax,
complex, dimension( nmax, nmax ) a,
complex, dimension( nmax*nmax ) aa,
complex, dimension( nmax*nmax ) as,
complex, dimension( nmax, nmax ) b,
complex, dimension( nmax*nmax ) bb,
complex, dimension( nmax*nmax ) bs,
complex, dimension( nmax ) ct,
real, dimension( nmax ) g,
complex, dimension( nmax, nmax ) c )

Definition at line 966 of file cblat3.f.

969*
970* Tests CTRMM and CTRSM.
971*
972* Auxiliary routine for test program for Level 3 Blas.
973*
974* -- Written on 8-February-1989.
975* Jack Dongarra, Argonne National Laboratory.
976* Iain Duff, AERE Harwell.
977* Jeremy Du Croz, Numerical Algorithms Group Ltd.
978* Sven Hammarling, Numerical Algorithms Group Ltd.
979*
980* .. Parameters ..
981 COMPLEX ZERO, ONE
982 parameter( zero = ( 0.0, 0.0 ), one = ( 1.0, 0.0 ) )
983 REAL RZERO
984 parameter( rzero = 0.0 )
985* .. Scalar Arguments ..
986 REAL EPS, THRESH
987 INTEGER NALF, NIDIM, NMAX, NOUT, NTRA
988 LOGICAL FATAL, REWI, TRACE
989 CHARACTER*6 SNAME
990* .. Array Arguments ..
991 COMPLEX A( NMAX, NMAX ), AA( NMAX*NMAX ), ALF( NALF ),
992 $ AS( NMAX*NMAX ), B( NMAX, NMAX ),
993 $ BB( NMAX*NMAX ), BS( NMAX*NMAX ),
994 $ C( NMAX, NMAX ), CT( NMAX )
995 REAL G( NMAX )
996 INTEGER IDIM( NIDIM )
997* .. Local Scalars ..
998 COMPLEX ALPHA, ALS
999 REAL ERR, ERRMAX
1000 INTEGER I, IA, ICD, ICS, ICT, ICU, IM, IN, J, LAA, LBB,
1001 $ LDA, LDAS, LDB, LDBS, M, MS, N, NA, NARGS, NC,
1002 $ NS
1003 LOGICAL LEFT, NULL, RESET, SAME
1004 CHARACTER*1 DIAG, DIAGS, SIDE, SIDES, TRANAS, TRANSA, UPLO,
1005 $ UPLOS
1006 CHARACTER*2 ICHD, ICHS, ICHU
1007 CHARACTER*3 ICHT
1008* .. Local Arrays ..
1009 LOGICAL ISAME( 13 )
1010* .. External Functions ..
1011 LOGICAL LCE, LCERES
1012 EXTERNAL lce, lceres
1013* .. External Subroutines ..
1014 EXTERNAL cmake, cmmch, ctrmm, ctrsm
1015* .. Intrinsic Functions ..
1016 INTRINSIC max
1017* .. Scalars in Common ..
1018 INTEGER INFOT, NOUTC
1019 LOGICAL LERR, OK
1020* .. Common blocks ..
1021 COMMON /infoc/infot, noutc, ok, lerr
1022* .. Data statements ..
1023 DATA ichu/'UL'/, icht/'NTC'/, ichd/'UN'/, ichs/'LR'/
1024* .. Executable Statements ..
1025*
1026 nargs = 11
1027 nc = 0
1028 reset = .true.
1029 errmax = rzero
1030* Set up zero matrix for CMMCH.
1031 DO 20 j = 1, nmax
1032 DO 10 i = 1, nmax
1033 c( i, j ) = zero
1034 10 CONTINUE
1035 20 CONTINUE
1036*
1037 DO 140 im = 1, nidim
1038 m = idim( im )
1039*
1040 DO 130 in = 1, nidim
1041 n = idim( in )
1042* Set LDB to 1 more than minimum value if room.
1043 ldb = m
1044 IF( ldb.LT.nmax )
1045 $ ldb = ldb + 1
1046* Skip tests if not enough room.
1047 IF( ldb.GT.nmax )
1048 $ GO TO 130
1049 lbb = ldb*n
1050 null = m.LE.0.OR.n.LE.0
1051*
1052 DO 120 ics = 1, 2
1053 side = ichs( ics: ics )
1054 left = side.EQ.'L'
1055 IF( left )THEN
1056 na = m
1057 ELSE
1058 na = n
1059 END IF
1060* Set LDA to 1 more than minimum value if room.
1061 lda = na
1062 IF( lda.LT.nmax )
1063 $ lda = lda + 1
1064* Skip tests if not enough room.
1065 IF( lda.GT.nmax )
1066 $ GO TO 130
1067 laa = lda*na
1068*
1069 DO 110 icu = 1, 2
1070 uplo = ichu( icu: icu )
1071*
1072 DO 100 ict = 1, 3
1073 transa = icht( ict: ict )
1074*
1075 DO 90 icd = 1, 2
1076 diag = ichd( icd: icd )
1077*
1078 DO 80 ia = 1, nalf
1079 alpha = alf( ia )
1080*
1081* Generate the matrix A.
1082*
1083 CALL cmake( 'TR', uplo, diag, na, na, a,
1084 $ nmax, aa, lda, reset, zero )
1085*
1086* Generate the matrix B.
1087*
1088 CALL cmake( 'GE', ' ', ' ', m, n, b, nmax,
1089 $ bb, ldb, reset, zero )
1090*
1091 nc = nc + 1
1092*
1093* Save every datum before calling the
1094* subroutine.
1095*
1096 sides = side
1097 uplos = uplo
1098 tranas = transa
1099 diags = diag
1100 ms = m
1101 ns = n
1102 als = alpha
1103 DO 30 i = 1, laa
1104 as( i ) = aa( i )
1105 30 CONTINUE
1106 ldas = lda
1107 DO 40 i = 1, lbb
1108 bs( i ) = bb( i )
1109 40 CONTINUE
1110 ldbs = ldb
1111*
1112* Call the subroutine.
1113*
1114 IF( sname( 4: 5 ).EQ.'MM' )THEN
1115 IF( trace )
1116 $ WRITE( ntra, fmt = 9995 )nc, sname,
1117 $ side, uplo, transa, diag, m, n, alpha,
1118 $ lda, ldb
1119 IF( rewi )
1120 $ rewind ntra
1121 CALL ctrmm( side, uplo, transa, diag, m,
1122 $ n, alpha, aa, lda, bb, ldb )
1123 ELSE IF( sname( 4: 5 ).EQ.'SM' )THEN
1124 IF( trace )
1125 $ WRITE( ntra, fmt = 9995 )nc, sname,
1126 $ side, uplo, transa, diag, m, n, alpha,
1127 $ lda, ldb
1128 IF( rewi )
1129 $ rewind ntra
1130 CALL ctrsm( side, uplo, transa, diag, m,
1131 $ n, alpha, aa, lda, bb, ldb )
1132 END IF
1133*
1134* Check if error-exit was taken incorrectly.
1135*
1136 IF( .NOT.ok )THEN
1137 WRITE( nout, fmt = 9994 )
1138 fatal = .true.
1139 GO TO 150
1140 END IF
1141*
1142* See what data changed inside subroutines.
1143*
1144 isame( 1 ) = sides.EQ.side
1145 isame( 2 ) = uplos.EQ.uplo
1146 isame( 3 ) = tranas.EQ.transa
1147 isame( 4 ) = diags.EQ.diag
1148 isame( 5 ) = ms.EQ.m
1149 isame( 6 ) = ns.EQ.n
1150 isame( 7 ) = als.EQ.alpha
1151 isame( 8 ) = lce( as, aa, laa )
1152 isame( 9 ) = ldas.EQ.lda
1153 IF( null )THEN
1154 isame( 10 ) = lce( bs, bb, lbb )
1155 ELSE
1156 isame( 10 ) = lceres( 'GE', ' ', m, n, bs,
1157 $ bb, ldb )
1158 END IF
1159 isame( 11 ) = ldbs.EQ.ldb
1160*
1161* If data was incorrectly changed, report and
1162* return.
1163*
1164 same = .true.
1165 DO 50 i = 1, nargs
1166 same = same.AND.isame( i )
1167 IF( .NOT.isame( i ) )
1168 $ WRITE( nout, fmt = 9998 )i
1169 50 CONTINUE
1170 IF( .NOT.same )THEN
1171 fatal = .true.
1172 GO TO 150
1173 END IF
1174*
1175 IF( .NOT.null )THEN
1176 IF( sname( 4: 5 ).EQ.'MM' )THEN
1177*
1178* Check the result.
1179*
1180 IF( left )THEN
1181 CALL cmmch( transa, 'N', m, n, m,
1182 $ alpha, a, nmax, b, nmax,
1183 $ zero, c, nmax, ct, g,
1184 $ bb, ldb, eps, err,
1185 $ fatal, nout, .true. )
1186 ELSE
1187 CALL cmmch( 'N', transa, m, n, n,
1188 $ alpha, b, nmax, a, nmax,
1189 $ zero, c, nmax, ct, g,
1190 $ bb, ldb, eps, err,
1191 $ fatal, nout, .true. )
1192 END IF
1193 ELSE IF( sname( 4: 5 ).EQ.'SM' )THEN
1194*
1195* Compute approximation to original
1196* matrix.
1197*
1198 DO 70 j = 1, n
1199 DO 60 i = 1, m
1200 c( i, j ) = bb( i + ( j - 1 )*
1201 $ ldb )
1202 bb( i + ( j - 1 )*ldb ) = alpha*
1203 $ b( i, j )
1204 60 CONTINUE
1205 70 CONTINUE
1206*
1207 IF( left )THEN
1208 CALL cmmch( transa, 'N', m, n, m,
1209 $ one, a, nmax, c, nmax,
1210 $ zero, b, nmax, ct, g,
1211 $ bb, ldb, eps, err,
1212 $ fatal, nout, .false. )
1213 ELSE
1214 CALL cmmch( 'N', transa, m, n, n,
1215 $ one, c, nmax, a, nmax,
1216 $ zero, b, nmax, ct, g,
1217 $ bb, ldb, eps, err,
1218 $ fatal, nout, .false. )
1219 END IF
1220 END IF
1221 errmax = max( errmax, err )
1222* If got really bad answer, report and
1223* return.
1224 IF( fatal )
1225 $ GO TO 150
1226 END IF
1227*
1228 80 CONTINUE
1229*
1230 90 CONTINUE
1231*
1232 100 CONTINUE
1233*
1234 110 CONTINUE
1235*
1236 120 CONTINUE
1237*
1238 130 CONTINUE
1239*
1240 140 CONTINUE
1241*
1242* Report result.
1243*
1244 IF( errmax.LT.thresh )THEN
1245 WRITE( nout, fmt = 9999 )sname, nc
1246 ELSE
1247 WRITE( nout, fmt = 9997 )sname, nc, errmax
1248 END IF
1249 GO TO 160
1250*
1251 150 CONTINUE
1252 WRITE( nout, fmt = 9996 )sname
1253 WRITE( nout, fmt = 9995 )nc, sname, side, uplo, transa, diag, m,
1254 $ n, alpha, lda, ldb
1255*
1256 160 CONTINUE
1257 RETURN
1258*
1259 9999 FORMAT( ' ', a6, ' PASSED THE COMPUTATIONAL TESTS (', i6, ' CALL',
1260 $ 'S)' )
1261 9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', i2, ' WAS CH',
1262 $ 'ANGED INCORRECTLY *******' )
1263 9997 FORMAT( ' ', a6, ' COMPLETED THE COMPUTATIONAL TESTS (', i6, ' C',
1264 $ 'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', f8.2,
1265 $ ' - SUSPECT *******' )
1266 9996 FORMAT( ' ******* ', a6, ' FAILED ON CALL NUMBER:' )
1267 9995 FORMAT( 1x, i6, ': ', a6, '(', 4( '''', a1, ''',' ), 2( i3, ',' ),
1268 $ '(', f4.1, ',', f4.1, '), A,', i3, ', B,', i3, ') ',
1269 $ ' .' )
1270 9994 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *',
1271 $ '******' )
1272*
1273* End of CCHK3
1274*
ctrmm
subroutine ctrmm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
CTRMM
Definition ctrmm.f:177
ctrsm
subroutine ctrsm(side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
CTRSM
Definition ctrsm.f:180

◆ cchk4()

subroutine cchk4 ( character*6 sname,
real eps,
real thresh,
integer nout,
integer ntra,
logical trace,
logical rewi,
logical fatal,
integer nidim,
integer, dimension( nidim ) idim,
integer nalf,
complex, dimension( nalf ) alf,
integer nbet,
complex, dimension( nbet ) bet,
integer nmax,
complex, dimension( nmax, nmax ) a,
complex, dimension( nmax*nmax ) aa,
complex, dimension( nmax*nmax ) as,
complex, dimension( nmax, nmax ) b,
complex, dimension( nmax*nmax ) bb,
complex, dimension( nmax*nmax ) bs,
complex, dimension( nmax, nmax ) c,
complex, dimension( nmax*nmax ) cc,
complex, dimension( nmax*nmax ) cs,
complex, dimension( nmax ) ct,
real, dimension( nmax ) g )

Definition at line 1276 of file cblat3.f.

1279*
1280* Tests CHERK and CSYRK.
1281*
1282* Auxiliary routine for test program for Level 3 Blas.
1283*
1284* -- Written on 8-February-1989.
1285* Jack Dongarra, Argonne National Laboratory.
1286* Iain Duff, AERE Harwell.
1287* Jeremy Du Croz, Numerical Algorithms Group Ltd.
1288* Sven Hammarling, Numerical Algorithms Group Ltd.
1289*
1290* .. Parameters ..
1291 COMPLEX ZERO
1292 parameter( zero = ( 0.0, 0.0 ) )
1293 REAL RONE, RZERO
1294 parameter( rone = 1.0, rzero = 0.0 )
1295* .. Scalar Arguments ..
1296 REAL EPS, THRESH
1297 INTEGER NALF, NBET, NIDIM, NMAX, NOUT, NTRA
1298 LOGICAL FATAL, REWI, TRACE
1299 CHARACTER*6 SNAME
1300* .. Array Arguments ..
1301 COMPLEX A( NMAX, NMAX ), AA( NMAX*NMAX ), ALF( NALF ),
1302 $ AS( NMAX*NMAX ), B( NMAX, NMAX ),
1303 $ BB( NMAX*NMAX ), BET( NBET ), BS( NMAX*NMAX ),
1304 $ C( NMAX, NMAX ), CC( NMAX*NMAX ),
1305 $ CS( NMAX*NMAX ), CT( NMAX )
1306 REAL G( NMAX )
1307 INTEGER IDIM( NIDIM )
1308* .. Local Scalars ..
1309 COMPLEX ALPHA, ALS, BETA, BETS
1310 REAL ERR, ERRMAX, RALPHA, RALS, RBETA, RBETS
1311 INTEGER I, IA, IB, ICT, ICU, IK, IN, J, JC, JJ, K, KS,
1312 $ LAA, LCC, LDA, LDAS, LDC, LDCS, LJ, MA, N, NA,
1313 $ NARGS, NC, NS
1314 LOGICAL CONJ, NULL, RESET, SAME, TRAN, UPPER
1315 CHARACTER*1 TRANS, TRANSS, TRANST, UPLO, UPLOS
1316 CHARACTER*2 ICHT, ICHU
1317* .. Local Arrays ..
1318 LOGICAL ISAME( 13 )
1319* .. External Functions ..
1320 LOGICAL LCE, LCERES
1321 EXTERNAL lce, lceres
1322* .. External Subroutines ..
1323 EXTERNAL cherk, cmake, cmmch, csyrk
1324* .. Intrinsic Functions ..
1325 INTRINSIC cmplx, max, real
1326* .. Scalars in Common ..
1327 INTEGER INFOT, NOUTC
1328 LOGICAL LERR, OK
1329* .. Common blocks ..
1330 COMMON /infoc/infot, noutc, ok, lerr
1331* .. Data statements ..
1332 DATA icht/'NC'/, ichu/'UL'/
1333* .. Executable Statements ..
1334 conj = sname( 2: 3 ).EQ.'HE'
1335*
1336 nargs = 10
1337 nc = 0
1338 reset = .true.
1339 errmax = rzero
1340*
1341 DO 100 in = 1, nidim
1342 n = idim( in )
1343* Set LDC to 1 more than minimum value if room.
1344 ldc = n
1345 IF( ldc.LT.nmax )
1346 $ ldc = ldc + 1
1347* Skip tests if not enough room.
1348 IF( ldc.GT.nmax )
1349 $ GO TO 100
1350 lcc = ldc*n
1351*
1352 DO 90 ik = 1, nidim
1353 k = idim( ik )
1354*
1355 DO 80 ict = 1, 2
1356 trans = icht( ict: ict )
1357 tran = trans.EQ.'C'
1358 IF( tran.AND..NOT.conj )
1359 $ trans = 'T'
1360 IF( tran )THEN
1361 ma = k
1362 na = n
1363 ELSE
1364 ma = n
1365 na = k
1366 END IF
1367* Set LDA to 1 more than minimum value if room.
1368 lda = ma
1369 IF( lda.LT.nmax )
1370 $ lda = lda + 1
1371* Skip tests if not enough room.
1372 IF( lda.GT.nmax )
1373 $ GO TO 80
1374 laa = lda*na
1375*
1376* Generate the matrix A.
1377*
1378 CALL cmake( 'GE', ' ', ' ', ma, na, a, nmax, aa, lda,
1379 $ reset, zero )
1380*
1381 DO 70 icu = 1, 2
1382 uplo = ichu( icu: icu )
1383 upper = uplo.EQ.'U'
1384*
1385 DO 60 ia = 1, nalf
1386 alpha = alf( ia )
1387 IF( conj )THEN
1388 ralpha = real( alpha )
1389 alpha = cmplx( ralpha, rzero )
1390 END IF
1391*
1392 DO 50 ib = 1, nbet
1393 beta = bet( ib )
1394 IF( conj )THEN
1395 rbeta = real( beta )
1396 beta = cmplx( rbeta, rzero )
1397 END IF
1398 null = n.LE.0
1399 IF( conj )
1400 $ null = null.OR.( ( k.LE.0.OR.ralpha.EQ.
1401 $ rzero ).AND.rbeta.EQ.rone )
1402*
1403* Generate the matrix C.
1404*
1405 CALL cmake( sname( 2: 3 ), uplo, ' ', n, n, c,
1406 $ nmax, cc, ldc, reset, zero )
1407*
1408 nc = nc + 1
1409*
1410* Save every datum before calling the subroutine.
1411*
1412 uplos = uplo
1413 transs = trans
1414 ns = n
1415 ks = k
1416 IF( conj )THEN
1417 rals = ralpha
1418 ELSE
1419 als = alpha
1420 END IF
1421 DO 10 i = 1, laa
1422 as( i ) = aa( i )
1423 10 CONTINUE
1424 ldas = lda
1425 IF( conj )THEN
1426 rbets = rbeta
1427 ELSE
1428 bets = beta
1429 END IF
1430 DO 20 i = 1, lcc
1431 cs( i ) = cc( i )
1432 20 CONTINUE
1433 ldcs = ldc
1434*
1435* Call the subroutine.
1436*
1437 IF( conj )THEN
1438 IF( trace )
1439 $ WRITE( ntra, fmt = 9994 )nc, sname, uplo,
1440 $ trans, n, k, ralpha, lda, rbeta, ldc
1441 IF( rewi )
1442 $ rewind ntra
1443 CALL cherk( uplo, trans, n, k, ralpha, aa,
1444 $ lda, rbeta, cc, ldc )
1445 ELSE
1446 IF( trace )
1447 $ WRITE( ntra, fmt = 9993 )nc, sname, uplo,
1448 $ trans, n, k, alpha, lda, beta, ldc
1449 IF( rewi )
1450 $ rewind ntra
1451 CALL csyrk( uplo, trans, n, k, alpha, aa,
1452 $ lda, beta, cc, ldc )
1453 END IF
1454*
1455* Check if error-exit was taken incorrectly.
1456*
1457 IF( .NOT.ok )THEN
1458 WRITE( nout, fmt = 9992 )
1459 fatal = .true.
1460 GO TO 120
1461 END IF
1462*
1463* See what data changed inside subroutines.
1464*
1465 isame( 1 ) = uplos.EQ.uplo
1466 isame( 2 ) = transs.EQ.trans
1467 isame( 3 ) = ns.EQ.n
1468 isame( 4 ) = ks.EQ.k
1469 IF( conj )THEN
1470 isame( 5 ) = rals.EQ.ralpha
1471 ELSE
1472 isame( 5 ) = als.EQ.alpha
1473 END IF
1474 isame( 6 ) = lce( as, aa, laa )
1475 isame( 7 ) = ldas.EQ.lda
1476 IF( conj )THEN
1477 isame( 8 ) = rbets.EQ.rbeta
1478 ELSE
1479 isame( 8 ) = bets.EQ.beta
1480 END IF
1481 IF( null )THEN
1482 isame( 9 ) = lce( cs, cc, lcc )
1483 ELSE
1484 isame( 9 ) = lceres( sname( 2: 3 ), uplo, n,
1485 $ n, cs, cc, ldc )
1486 END IF
1487 isame( 10 ) = ldcs.EQ.ldc
1488*
1489* If data was incorrectly changed, report and
1490* return.
1491*
1492 same = .true.
1493 DO 30 i = 1, nargs
1494 same = same.AND.isame( i )
1495 IF( .NOT.isame( i ) )
1496 $ WRITE( nout, fmt = 9998 )i
1497 30 CONTINUE
1498 IF( .NOT.same )THEN
1499 fatal = .true.
1500 GO TO 120
1501 END IF
1502*
1503 IF( .NOT.null )THEN
1504*
1505* Check the result column by column.
1506*
1507 IF( conj )THEN
1508 transt = 'C'
1509 ELSE
1510 transt = 'T'
1511 END IF
1512 jc = 1
1513 DO 40 j = 1, n
1514 IF( upper )THEN
1515 jj = 1
1516 lj = j
1517 ELSE
1518 jj = j
1519 lj = n - j + 1
1520 END IF
1521 IF( tran )THEN
1522 CALL cmmch( transt, 'N', lj, 1, k,
1523 $ alpha, a( 1, jj ), nmax,
1524 $ a( 1, j ), nmax, beta,
1525 $ c( jj, j ), nmax, ct, g,
1526 $ cc( jc ), ldc, eps, err,
1527 $ fatal, nout, .true. )
1528 ELSE
1529 CALL cmmch( 'N', transt, lj, 1, k,
1530 $ alpha, a( jj, 1 ), nmax,
1531 $ a( j, 1 ), nmax, beta,
1532 $ c( jj, j ), nmax, ct, g,
1533 $ cc( jc ), ldc, eps, err,
1534 $ fatal, nout, .true. )
1535 END IF
1536 IF( upper )THEN
1537 jc = jc + ldc
1538 ELSE
1539 jc = jc + ldc + 1
1540 END IF
1541 errmax = max( errmax, err )
1542* If got really bad answer, report and
1543* return.
1544 IF( fatal )
1545 $ GO TO 110
1546 40 CONTINUE
1547 END IF
1548*
1549 50 CONTINUE
1550*
1551 60 CONTINUE
1552*
1553 70 CONTINUE
1554*
1555 80 CONTINUE
1556*
1557 90 CONTINUE
1558*
1559 100 CONTINUE
1560*
1561* Report result.
1562*
1563 IF( errmax.LT.thresh )THEN
1564 WRITE( nout, fmt = 9999 )sname, nc
1565 ELSE
1566 WRITE( nout, fmt = 9997 )sname, nc, errmax
1567 END IF
1568 GO TO 130
1569*
1570 110 CONTINUE
1571 IF( n.GT.1 )
1572 $ WRITE( nout, fmt = 9995 )j
1573*
1574 120 CONTINUE
1575 WRITE( nout, fmt = 9996 )sname
1576 IF( conj )THEN
1577 WRITE( nout, fmt = 9994 )nc, sname, uplo, trans, n, k, ralpha,
1578 $ lda, rbeta, ldc
1579 ELSE
1580 WRITE( nout, fmt = 9993 )nc, sname, uplo, trans, n, k, alpha,
1581 $ lda, beta, ldc
1582 END IF
1583*
1584 130 CONTINUE
1585 RETURN
1586*
1587 9999 FORMAT( ' ', a6, ' PASSED THE COMPUTATIONAL TESTS (', i6, ' CALL',
1588 $ 'S)' )
1589 9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', i2, ' WAS CH',
1590 $ 'ANGED INCORRECTLY *******' )
1591 9997 FORMAT( ' ', a6, ' COMPLETED THE COMPUTATIONAL TESTS (', i6, ' C',
1592 $ 'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', f8.2,
1593 $ ' - SUSPECT *******' )
1594 9996 FORMAT( ' ******* ', a6, ' failed on CALL number:' )
1595 9995 FORMAT( ' these are the results for column ', I3 )
1596 9994 FORMAT( 1X, I6, ': ', A6, '(', 2( '''', A1, ''',' ), 2( I3, ',' ),
1597 $ F4.1, ', a,', I3, ',', F4.1, ', c,', I3, ') ',
1598 $ ' .' )
1599 9993 FORMAT( 1X, I6, ': ', A6, '(', 2( '''', A1, ''',' ), 2( I3, ',' ),
1600 $ '(', F4.1, ',', F4.1, ') , a,', I3, ',(', F4.1, ',', F4.1,
1601 $ '), c,', I3, ') .' )
1602 9992 FORMAT( ' ******* fatal error - error-EXIT taken on valid CALL *',
1603 $ '******' )
1604*
1605* End of CCHK4
1606*
the
end diagonal values have been computed in the(sparse) matrix id.SOL
csyrk
subroutine csyrk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
CSYRK
Definition csyrk.f:167
cherk
subroutine cherk(uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
CHERK
Definition cherk.f:173
for
for(i8=*sizetab-1;i8 >=0;i8--)
Definition mumps_common.c:91
jc
subroutine jc(p, t, a, b, cm, cn, tref, tm, epsm, sigmam, jc_yield, tan_jc)
Definition sigeps106.F:339

◆ cchk5()

subroutine cchk5 ( character*6 sname,
real eps,
real thresh,
integer nout,
integer ntra,
logical trace,
logical rewi,
logical fatal,
integer nidim,
integer, dimension( nidim ) idim,
integer nalf,
complex, dimension( nalf ) alf,
integer nbet,
complex, dimension( nbet ) bet,
integer nmax,
complex, dimension( 2*nmax*nmax ) ab,
complex, dimension( nmax*nmax ) aa,
complex, dimension( nmax*nmax ) as,
complex, dimension( nmax*nmax ) bb,
complex, dimension( nmax*nmax ) bs,
complex, dimension( nmax, nmax ) c,
complex, dimension( nmax*nmax ) cc,
complex, dimension( nmax*nmax ) cs,
complex, dimension( nmax ) ct,
real, dimension( nmax ) g,
complex, dimension( 2*nmax ) w )

Definition at line 1608 of file cblat3.f.

1611*
1612* Tests CHER2K and CSYR2K.
1613*
1614* Auxiliary routine for test program for Level 3 Blas.
1615*
1616* -- Written on 8-February-1989.
1617* Jack Dongarra, Argonne National Laboratory.
1618* Iain Duff, AERE Harwell.
1619* Jeremy Du Croz, Numerical Algorithms Group Ltd.
1620* Sven Hammarling, Numerical Algorithms Group Ltd.
1621*
1622* .. Parameters ..
1623 COMPLEX ZERO, ONE
1624 parameter( zero = ( 0.0, 0.0 ), one = ( 1.0, 0.0 ) )
1625 REAL RONE, RZERO
1626 parameter( rone = 1.0, rzero = 0.0 )
1627* .. Scalar Arguments ..
1628 REAL EPS, THRESH
1629 INTEGER NALF, NBET, NIDIM, NMAX, NOUT, NTRA
1630 LOGICAL FATAL, REWI, TRACE
1631 CHARACTER*6 SNAME
1632* .. Array Arguments ..
1633 COMPLEX AA( NMAX*NMAX ), AB( 2*NMAX*NMAX ),
1634 $ ALF( NALF ), AS( NMAX*NMAX ), BB( NMAX*NMAX ),
1635 $ BET( NBET ), BS( NMAX*NMAX ), C( NMAX, NMAX ),
1636 $ CC( NMAX*NMAX ), CS( NMAX*NMAX ), CT( NMAX ),
1637 $ W( 2*NMAX )
1638 REAL G( NMAX )
1639 INTEGER IDIM( NIDIM )
1640* .. Local Scalars ..
1641 COMPLEX ALPHA, ALS, BETA, BETS
1642 REAL ERR, ERRMAX, RBETA, RBETS
1643 INTEGER I, IA, IB, ICT, ICU, IK, IN, J, JC, JJ, JJAB,
1644 $ K, KS, LAA, LBB, LCC, LDA, LDAS, LDB, LDBS,
1645 $ LDC, LDCS, LJ, MA, N, NA, NARGS, NC, NS
1646 LOGICAL CONJ, NULL, RESET, SAME, TRAN, UPPER
1647 CHARACTER*1 TRANS, TRANSS, TRANST, UPLO, UPLOS
1648 CHARACTER*2 ICHT, ICHU
1649* .. Local Arrays ..
1650 LOGICAL ISAME( 13 )
1651* .. External Functions ..
1652 LOGICAL LCE, LCERES
1653 EXTERNAL lce, lceres
1654* .. External Subroutines ..
1655 EXTERNAL cher2k, cmake, cmmch, csyr2k
1656* .. Intrinsic Functions ..
1657 INTRINSIC cmplx, conjg, max, real
1658* .. Scalars in Common ..
1659 INTEGER INFOT, NOUTC
1660 LOGICAL LERR, OK
1661* .. Common blocks ..
1662 COMMON /infoc/infot, noutc, ok, lerr
1663* .. Data statements ..
1664 DATA icht/'NC'/, ichu/'UL'/
1665* .. Executable Statements ..
1666 conj = sname( 2: 3 ).EQ.'HE'
1667*
1668 nargs = 12
1669 nc = 0
1670 reset = .true.
1671 errmax = rzero
1672*
1673 DO 130 in = 1, nidim
1674 n = idim( in )
1675* Set LDC to 1 more than minimum value if room.
1676 ldc = n
1677 IF( ldc.LT.nmax )
1678 $ ldc = ldc + 1
1679* Skip tests if not enough room.
1680 IF( ldc.GT.nmax )
1681 $ GO TO 130
1682 lcc = ldc*n
1683*
1684 DO 120 ik = 1, nidim
1685 k = idim( ik )
1686*
1687 DO 110 ict = 1, 2
1688 trans = icht( ict: ict )
1689 tran = trans.EQ.'C'
1690 IF( tran.AND..NOT.conj )
1691 $ trans = 'T'
1692 IF( tran )THEN
1693 ma = k
1694 na = n
1695 ELSE
1696 ma = n
1697 na = k
1698 END IF
1699* Set LDA to 1 more than minimum value if room.
1700 lda = ma
1701 IF( lda.LT.nmax )
1702 $ lda = lda + 1
1703* Skip tests if not enough room.
1704 IF( lda.GT.nmax )
1705 $ GO TO 110
1706 laa = lda*na
1707*
1708* Generate the matrix A.
1709*
1710 IF( tran )THEN
1711 CALL cmake( 'GE', ' ', ' ', ma, na, ab, 2*nmax, aa,
1712 $ lda, reset, zero )
1713 ELSE
1714 CALL cmake( 'GE', ' ', ' ', ma, na, ab, nmax, aa, lda,
1715 $ reset, zero )
1716 END IF
1717*
1718* Generate the matrix B.
1719*
1720 ldb = lda
1721 lbb = laa
1722 IF( tran )THEN
1723 CALL cmake( 'GE', ' ', ' ', ma, na, ab( k + 1 ),
1724 $ 2*nmax, bb, ldb, reset, zero )
1725 ELSE
1726 CALL cmake( 'GE', ' ', ' ', ma, na, ab( k*nmax + 1 ),
1727 $ nmax, bb, ldb, reset, zero )
1728 END IF
1729*
1730 DO 100 icu = 1, 2
1731 uplo = ichu( icu: icu )
1732 upper = uplo.EQ.'U'
1733*
1734 DO 90 ia = 1, nalf
1735 alpha = alf( ia )
1736*
1737 DO 80 ib = 1, nbet
1738 beta = bet( ib )
1739 IF( conj )THEN
1740 rbeta = real( beta )
1741 beta = cmplx( rbeta, rzero )
1742 END IF
1743 null = n.LE.0
1744 IF( conj )
1745 $ null = null.OR.( ( k.LE.0.OR.alpha.EQ.
1746 $ zero ).AND.rbeta.EQ.rone )
1747*
1748* Generate the matrix C.
1749*
1750 CALL cmake( sname( 2: 3 ), uplo, ' ', n, n, c,
1751 $ nmax, cc, ldc, reset, zero )
1752*
1753 nc = nc + 1
1754*
1755* Save every datum before calling the subroutine.
1756*
1757 uplos = uplo
1758 transs = trans
1759 ns = n
1760 ks = k
1761 als = alpha
1762 DO 10 i = 1, laa
1763 as( i ) = aa( i )
1764 10 CONTINUE
1765 ldas = lda
1766 DO 20 i = 1, lbb
1767 bs( i ) = bb( i )
1768 20 CONTINUE
1769 ldbs = ldb
1770 IF( conj )THEN
1771 rbets = rbeta
1772 ELSE
1773 bets = beta
1774 END IF
1775 DO 30 i = 1, lcc
1776 cs( i ) = cc( i )
1777 30 CONTINUE
1778 ldcs = ldc
1779*
1780* Call the subroutine.
1781*
1782 IF( conj )THEN
1783 IF( trace )
1784 $ WRITE( ntra, fmt = 9994 )nc, sname, uplo,
1785 $ trans, n, k, alpha, lda, ldb, rbeta, ldc
1786 IF( rewi )
1787 $ rewind ntra
1788 CALL cher2k( uplo, trans, n, k, alpha, aa,
1789 $ lda, bb, ldb, rbeta, cc, ldc )
1790 ELSE
1791 IF( trace )
1792 $ WRITE( ntra, fmt = 9993 )nc, sname, uplo,
1793 $ trans, n, k, alpha, lda, ldb, beta, ldc
1794 IF( rewi )
1795 $ rewind ntra
1796 CALL csyr2k( uplo, trans, n, k, alpha, aa,
1797 $ lda, bb, ldb, beta, cc, ldc )
1798 END IF
1799*
1800* Check if error-exit was taken incorrectly.
1801*
1802 IF( .NOT.ok )THEN
1803 WRITE( nout, fmt = 9992 )
1804 fatal = .true.
1805 GO TO 150
1806 END IF
1807*
1808* See what data changed inside subroutines.
1809*
1810 isame( 1 ) = uplos.EQ.uplo
1811 isame( 2 ) = transs.EQ.trans
1812 isame( 3 ) = ns.EQ.n
1813 isame( 4 ) = ks.EQ.k
1814 isame( 5 ) = als.EQ.alpha
1815 isame( 6 ) = lce( as, aa, laa )
1816 isame( 7 ) = ldas.EQ.lda
1817 isame( 8 ) = lce( bs, bb, lbb )
1818 isame( 9 ) = ldbs.EQ.ldb
1819 IF( conj )THEN
1820 isame( 10 ) = rbets.EQ.rbeta
1821 ELSE
1822 isame( 10 ) = bets.EQ.beta
1823 END IF
1824 IF( null )THEN
1825 isame( 11 ) = lce( cs, cc, lcc )
1826 ELSE
1827 isame( 11 ) = lceres( 'HE', uplo, n, n, cs,
1828 $ cc, ldc )
1829 END IF
1830 isame( 12 ) = ldcs.EQ.ldc
1831*
1832* If data was incorrectly changed, report and
1833* return.
1834*
1835 same = .true.
1836 DO 40 i = 1, nargs
1837 same = same.AND.isame( i )
1838 IF( .NOT.isame( i ) )
1839 $ WRITE( nout, fmt = 9998 )i
1840 40 CONTINUE
1841 IF( .NOT.same )THEN
1842 fatal = .true.
1843 GO TO 150
1844 END IF
1845*
1846 IF( .NOT.null )THEN
1847*
1848* Check the result column by column.
1849*
1850 IF( conj )THEN
1851 transt = 'C'
1852 ELSE
1853 transt = 'T'
1854 END IF
1855 jjab = 1
1856 jc = 1
1857 DO 70 j = 1, n
1858 IF( upper )THEN
1859 jj = 1
1860 lj = j
1861 ELSE
1862 jj = j
1863 lj = n - j + 1
1864 END IF
1865 IF( tran )THEN
1866 DO 50 i = 1, k
1867 w( i ) = alpha*ab( ( j - 1 )*2*
1868 $ nmax + k + i )
1869 IF( conj )THEN
1870 w( k + i ) = conjg( alpha )*
1871 $ ab( ( j - 1 )*2*
1872 $ nmax + i )
1873 ELSE
1874 w( k + i ) = alpha*
1875 $ ab( ( j - 1 )*2*
1876 $ nmax + i )
1877 END IF
1878 50 CONTINUE
1879 CALL cmmch( transt, 'N', lj, 1, 2*k,
1880 $ one, ab( jjab ), 2*nmax, w,
1881 $ 2*nmax, beta, c( jj, j ),
1882 $ nmax, ct, g, cc( jc ), ldc,
1883 $ eps, err, fatal, nout,
1884 $ .true. )
1885 ELSE
1886 DO 60 i = 1, k
1887 IF( conj )THEN
1888 w( i ) = alpha*conjg( ab( ( k +
1889 $ i - 1 )*nmax + j ) )
1890 w( k + i ) = conjg( alpha*
1891 $ ab( ( i - 1 )*nmax +
1892 $ j ) )
1893 ELSE
1894 w( i ) = alpha*ab( ( k + i - 1 )*
1895 $ nmax + j )
1896 w( k + i ) = alpha*
1897 $ ab( ( i - 1 )*nmax +
1898 $ j )
1899 END IF
1900 60 CONTINUE
1901 CALL cmmch( 'N', 'N', lj, 1, 2*k, one,
1902 $ ab( jj ), nmax, w, 2*nmax,
1903 $ beta, c( jj, j ), nmax, ct,
1904 $ g, cc( jc ), ldc, eps, err,
1905 $ fatal, nout, .true. )
1906 END IF
1907 IF( upper )THEN
1908 jc = jc + ldc
1909 ELSE
1910 jc = jc + ldc + 1
1911 IF( tran )
1912 $ jjab = jjab + 2*nmax
1913 END IF
1914 errmax = max( errmax, err )
1915* If got really bad answer, report and
1916* return.
1917 IF( fatal )
1918 $ GO TO 140
1919 70 CONTINUE
1920 END IF
1921*
1922 80 CONTINUE
1923*
1924 90 CONTINUE
1925*
1926 100 CONTINUE
1927*
1928 110 CONTINUE
1929*
1930 120 CONTINUE
1931*
1932 130 CONTINUE
1933*
1934* Report result.
1935*
1936 IF( errmax.LT.thresh )THEN
1937 WRITE( nout, fmt = 9999 )sname, nc
1938 ELSE
1939 WRITE( nout, fmt = 9997 )sname, nc, errmax
1940 END IF
1941 GO TO 160
1942*
1943 140 CONTINUE
1944 IF( n.GT.1 )
1945 $ WRITE( nout, fmt = 9995 )j
1946*
1947 150 CONTINUE
1948 WRITE( nout, fmt = 9996 )sname
1949 IF( conj )THEN
1950 WRITE( nout, fmt = 9994 )nc, sname, uplo, trans, n, k, alpha,
1951 $ lda, ldb, rbeta, ldc
1952 ELSE
1953 WRITE( nout, fmt = 9993 )nc, sname, uplo, trans, n, k, alpha,
1954 $ lda, ldb, beta, ldc
1955 END IF
1956*
1957 160 CONTINUE
1958 RETURN
1959*
1960 9999 FORMAT( ' ', a6, ' PASSED THE COMPUTATIONAL TESTS (', i6, ' CALL',
1961 $ 'S)' )
1962 9998 FORMAT( ' ******* FATAL ERROR - PARAMETER NUMBER ', i2, ' WAS CH',
1963 $ 'ANGED INCORRECTLY *******' )
1964 9997 FORMAT( ' ', a6, ' COMPLETED THE COMPUTATIONAL TESTS (', i6, ' C',
1965 $ 'ALLS)', /' ******* BUT WITH MAXIMUM TEST RATIO', f8.2,
1966 $ ' - SUSPECT *******' )
1967 9996 FORMAT( ' ******* ', a6, ' FAILED ON CALL NUMBER:' )
1968 9995 FORMAT( ' THESE ARE THE RESULTS FOR COLUMN ', i3 )
1969 9994 FORMAT( 1x, i6, ': ', a6, '(', 2( '''', a1, ''',' ), 2( i3, ',' ),
1970 $ '(', f4.1, ',', f4.1, '), A,', i3, ', B,', i3, ',', f4.1,
1971 $ ', C,', i3, ') .' )
1972 9993 FORMAT( 1x, i6, ': ', a6, '(', 2( '''', a1, ''',' ), 2( i3, ',' ),
1973 $ '(', f4.1, ',', f4.1, '), A,', i3, ', B,', i3, ',(', f4.1,
1974 $ ',', f4.1, '), C,', i3, ') .' )
1975 9992 FORMAT( ' ******* FATAL ERROR - ERROR-EXIT TAKEN ON VALID CALL *',
1976 $ '******' )
1977*
1978* End of CCHK5
1979*
csyr2k
subroutine csyr2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
CSYR2K
Definition csyr2k.f:188
cher2k
subroutine cher2k(uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
CHER2K
Definition cher2k.f:197

◆ cchke()

subroutine cchke ( integer isnum,
character*6 srnamt,
integer nout )

Definition at line 1981 of file cblat3.f.

1982*
1983* Tests the error exits from the Level 3 Blas.
1984* Requires a special version of the error-handling routine XERBLA.
1985* A, B and C should not need to be defined.
1986*
1987* Auxiliary routine for test program for Level 3 Blas.
1988*
1989* -- Written on 8-February-1989.
1990* Jack Dongarra, Argonne National Laboratory.
1991* Iain Duff, AERE Harwell.
1992* Jeremy Du Croz, Numerical Algorithms Group Ltd.
1993* Sven Hammarling, Numerical Algorithms Group Ltd.
1994*
1995* 3-19-92: Initialize ALPHA, BETA, RALPHA, and RBETA (eca)
1996* 3-19-92: Fix argument 12 in calls to CSYMM and CHEMM
1997* with INFOT = 9 (eca)
1998*
1999* .. Scalar Arguments ..
2000 INTEGER ISNUM, NOUT
2001 CHARACTER*6 SRNAMT
2002* .. Scalars in Common ..
2003 INTEGER INFOT, NOUTC
2004 LOGICAL LERR, OK
2005* .. Parameters ..
2006 REAL ONE, TWO
2007 parameter( one = 1.0e0, two = 2.0e0 )
2008* .. Local Scalars ..
2009 COMPLEX ALPHA, BETA
2010 REAL RALPHA, RBETA
2011* .. Local Arrays ..
2012 COMPLEX A( 2, 1 ), B( 2, 1 ), C( 2, 1 )
2013* .. External Subroutines ..
2014 EXTERNAL cgemm, chemm, cher2k, cherk, chkxer, csymm,
2015 $ csyr2k, csyrk, ctrmm, ctrsm
2016* .. Common blocks ..
2017 COMMON /infoc/infot, noutc, ok, lerr
2018* .. Executable Statements ..
2019* OK is set to .FALSE. by the special version of XERBLA or by CHKXER
2020* if anything is wrong.
2021 ok = .true.
2022* LERR is set to .TRUE. by the special version of XERBLA each time
2023* it is called, and is then tested and re-set by CHKXER.
2024 lerr = .false.
2025*
2026* Initialize ALPHA, BETA, RALPHA, and RBETA.
2027*
2028 alpha = cmplx( one, -one )
2029 beta = cmplx( two, -two )
2030 ralpha = one
2031 rbeta = two
2032*
2033 GO TO ( 10, 20, 30, 40, 50, 60, 70, 80,
2034 $ 90 )isnum
2035 10 infot = 1
2036 CALL cgemm( '/', 'N', 0, 0, 0, alpha, a, 1, b, 1, beta, c, 1 )
2037 CALL chkxer( srnamt, infot, nout, lerr, ok )
2038 infot = 1
2039 CALL cgemm( '/', 'C', 0, 0, 0, alpha, a, 1, b, 1, beta, c, 1 )
2040 CALL chkxer( srnamt, infot, nout, lerr, ok )
2041 infot = 1
2042 CALL cgemm( '/', 'T', 0, 0, 0, alpha, a, 1, b, 1, beta, c, 1 )
2043 CALL chkxer( srnamt, infot, nout, lerr, ok )
2044 infot = 2
2045 CALL cgemm( 'N', '/', 0, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2046 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2047 INFOT = 2
2048 CALL CGEMM( 'c', '/', 0, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2049 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2050 INFOT = 2
2051 CALL CGEMM( 't', '/', 0, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2052 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2053 INFOT = 3
2054 CALL CGEMM( 'n', 'n', -1, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2055 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2056 INFOT = 3
2057 CALL CGEMM( 'n', 'c', -1, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2058 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2059 INFOT = 3
2060 CALL CGEMM( 'n', 't', -1, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2061 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2062 INFOT = 3
2063 CALL CGEMM( 'c', 'n', -1, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2064 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2065 INFOT = 3
2066 CALL CGEMM( 'c', 'c', -1, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2067 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2068 INFOT = 3
2069 CALL CGEMM( 'c', 't', -1, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2070 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2071 INFOT = 3
2072 CALL CGEMM( 't', 'n', -1, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2073 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2074 INFOT = 3
2075 CALL CGEMM( 't', 'c', -1, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2076 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2077 INFOT = 3
2078 CALL CGEMM( 't', 't', -1, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2079 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2080 INFOT = 4
2081 CALL CGEMM( 'n', 'n', 0, -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2082 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2083 INFOT = 4
2084 CALL CGEMM( 'n', 'c', 0, -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2085 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2086 INFOT = 4
2087 CALL CGEMM( 'n', 't', 0, -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2088 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2089 INFOT = 4
2090 CALL CGEMM( 'c', 'n', 0, -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2091 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2092 INFOT = 4
2093 CALL CGEMM( 'c', 'c', 0, -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2094 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2095 INFOT = 4
2096 CALL CGEMM( 'c', 't', 0, -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2097 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2098 INFOT = 4
2099 CALL CGEMM( 't', 'n', 0, -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2100 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2101 INFOT = 4
2102 CALL CGEMM( 't', 'c', 0, -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2103 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2104 INFOT = 4
2105 CALL CGEMM( 't', 't', 0, -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2106 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2107 INFOT = 5
2108 CALL CGEMM( 'n', 'n', 0, 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2109 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2110 INFOT = 5
2111 CALL CGEMM( 'n', 'c', 0, 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2112 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2113 INFOT = 5
2114 CALL CGEMM( 'n', 't', 0, 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2115 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2116 INFOT = 5
2117 CALL CGEMM( 'c', 'n', 0, 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2118 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2119 INFOT = 5
2120 CALL CGEMM( 'c', 'c', 0, 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2121 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2122 INFOT = 5
2123 CALL CGEMM( 'c', 't', 0, 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2124 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2125 INFOT = 5
2126 CALL CGEMM( 't', 'n', 0, 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2127 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2128 INFOT = 5
2129 CALL CGEMM( 't', 'c', 0, 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2130 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2131 INFOT = 5
2132 CALL CGEMM( 't', 't', 0, 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2133 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2134 INFOT = 8
2135 CALL CGEMM( 'n', 'n', 2, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 2 )
2136 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2137 INFOT = 8
2138 CALL CGEMM( 'n', 'c', 2, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 2 )
2139 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2140 INFOT = 8
2141 CALL CGEMM( 'n', 't', 2, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 2 )
2142 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2143 INFOT = 8
2144 CALL CGEMM( 'c', 'n', 0, 0, 2, ALPHA, A, 1, B, 2, BETA, C, 1 )
2145 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2146 INFOT = 8
2147 CALL CGEMM( 'c', 'c', 0, 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2148 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2149 INFOT = 8
2150 CALL CGEMM( 'c', 't', 0, 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2151 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2152 INFOT = 8
2153 CALL CGEMM( 't', 'n', 0, 0, 2, ALPHA, A, 1, B, 2, BETA, C, 1 )
2154 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2155 INFOT = 8
2156 CALL CGEMM( 't', 'c', 0, 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2157 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2158 INFOT = 8
2159 CALL CGEMM( 't', 't', 0, 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2160 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2161 INFOT = 10
2162 CALL CGEMM( 'n', 'n', 0, 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2163 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2164 INFOT = 10
2165 CALL CGEMM( 'c', 'n', 0, 0, 2, ALPHA, A, 2, B, 1, BETA, C, 1 )
2166 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2167 INFOT = 10
2168 CALL CGEMM( 't', 'n', 0, 0, 2, ALPHA, A, 2, B, 1, BETA, C, 1 )
2169 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2170 INFOT = 10
2171 CALL CGEMM( 'n', 'c', 0, 2, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2172 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2173 INFOT = 10
2174 CALL CGEMM( 'c', 'c', 0, 2, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2175 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2176 INFOT = 10
2177 CALL CGEMM( 't', 'c', 0, 2, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2178 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2179 INFOT = 10
2180 CALL CGEMM( 'n', 't', 0, 2, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2181 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2182 INFOT = 10
2183 CALL CGEMM( 'c', 't', 0, 2, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2184 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2185 INFOT = 10
2186 CALL CGEMM( 't', 't', 0, 2, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2187 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2188 INFOT = 13
2189 CALL CGEMM( 'n', 'n', 2, 0, 0, ALPHA, A, 2, B, 1, BETA, C, 1 )
2190 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2191 INFOT = 13
2192 CALL CGEMM( 'n', 'c', 2, 0, 0, ALPHA, A, 2, B, 1, BETA, C, 1 )
2193 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2194 INFOT = 13
2195 CALL CGEMM( 'n', 't', 2, 0, 0, ALPHA, A, 2, B, 1, BETA, C, 1 )
2196 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2197 INFOT = 13
2198 CALL CGEMM( 'c', 'n', 2, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2199 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2200 INFOT = 13
2201 CALL CGEMM( 'c', 'c', 2, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2202 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2203 INFOT = 13
2204 CALL CGEMM( 'c', 't', 2, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2205 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2206 INFOT = 13
2207 CALL CGEMM( 't', 'n', 2, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2208 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2209 INFOT = 13
2210 CALL CGEMM( 't', 'c', 2, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2211 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2212 INFOT = 13
2213 CALL CGEMM( 't', 't', 2, 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2214 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2215 GO TO 100
2216 20 INFOT = 1
2217 CALL CHEMM( '/', 'u', 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2218 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2219 INFOT = 2
2220 CALL CHEMM( 'l', '/', 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2221 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2222 INFOT = 3
2223 CALL CHEMM( 'l', 'u', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2224 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2225 INFOT = 3
2226 CALL CHEMM( 'r', 'u', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2227 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2228 INFOT = 3
2229 CALL CHEMM( 'l', 'l', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2230 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2231 INFOT = 3
2232 CALL CHEMM( 'r', 'l', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2233 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2234 INFOT = 4
2235 CALL CHEMM( 'l', 'u', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2236 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2237 INFOT = 4
2238 CALL CHEMM( 'r', 'u', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2239 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2240 INFOT = 4
2241 CALL CHEMM( 'l', 'l', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2242 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2243 INFOT = 4
2244 CALL CHEMM( 'r', 'l', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2245 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2246 INFOT = 7
2247 CALL CHEMM( 'l', 'u', 2, 0, ALPHA, A, 1, B, 2, BETA, C, 2 )
2248 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2249 INFOT = 7
2250 CALL CHEMM( 'r', 'u', 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2251 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2252 INFOT = 7
2253 CALL CHEMM( 'l', 'l', 2, 0, ALPHA, A, 1, B, 2, BETA, C, 2 )
2254 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2255 INFOT = 7
2256 CALL CHEMM( 'r', 'l', 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2257 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2258 INFOT = 9
2259 CALL CHEMM( 'l', 'u', 2, 0, ALPHA, A, 2, B, 1, BETA, C, 2 )
2260 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2261 INFOT = 9
2262 CALL CHEMM( 'r', 'u', 2, 0, ALPHA, A, 1, B, 1, BETA, C, 2 )
2263 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2264 INFOT = 9
2265 CALL CHEMM( 'l', 'l', 2, 0, ALPHA, A, 2, B, 1, BETA, C, 2 )
2266 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2267 INFOT = 9
2268 CALL CHEMM( 'r', 'l', 2, 0, ALPHA, A, 1, B, 1, BETA, C, 2 )
2269 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2270 INFOT = 12
2271 CALL CHEMM( 'l', 'u', 2, 0, ALPHA, A, 2, B, 2, BETA, C, 1 )
2272 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2273 INFOT = 12
2274 CALL CHEMM( 'r', 'u', 2, 0, ALPHA, A, 1, B, 2, BETA, C, 1 )
2275 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2276 INFOT = 12
2277 CALL CHEMM( 'l', 'l', 2, 0, ALPHA, A, 2, B, 2, BETA, C, 1 )
2278 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2279 INFOT = 12
2280 CALL CHEMM( 'r', 'l', 2, 0, ALPHA, A, 1, B, 2, BETA, C, 1 )
2281 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2282 GO TO 100
2283 30 INFOT = 1
2284 CALL CSYMM( '/', 'u', 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2285 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2286 INFOT = 2
2287 CALL CSYMM( 'l', '/', 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2288 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2289 INFOT = 3
2290 CALL CSYMM( 'l', 'u', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2291 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2292 INFOT = 3
2293 CALL CSYMM( 'r', 'u', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2294 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2295 INFOT = 3
2296 CALL CSYMM( 'l', 'l', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2297 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2298 INFOT = 3
2299 CALL CSYMM( 'r', 'l', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2300 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2301 INFOT = 4
2302 CALL CSYMM( 'l', 'u', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2303 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2304 INFOT = 4
2305 CALL CSYMM( 'r', 'u', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2306 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2307 INFOT = 4
2308 CALL CSYMM( 'l', 'l', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2309 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2310 INFOT = 4
2311 CALL CSYMM( 'r', 'l', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2312 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2313 INFOT = 7
2314 CALL CSYMM( 'l', 'u', 2, 0, ALPHA, A, 1, B, 2, BETA, C, 2 )
2315 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2316 INFOT = 7
2317 CALL CSYMM( 'r', 'u', 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2318 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2319 INFOT = 7
2320 CALL CSYMM( 'l', 'l', 2, 0, ALPHA, A, 1, B, 2, BETA, C, 2 )
2321 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2322 INFOT = 7
2323 CALL CSYMM( 'r', 'l', 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2324 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2325 INFOT = 9
2326 CALL CSYMM( 'l', 'u', 2, 0, ALPHA, A, 2, B, 1, BETA, C, 2 )
2327 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2328 INFOT = 9
2329 CALL CSYMM( 'r', 'u', 2, 0, ALPHA, A, 1, B, 1, BETA, C, 2 )
2330 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2331 INFOT = 9
2332 CALL CSYMM( 'l', 'l', 2, 0, ALPHA, A, 2, B, 1, BETA, C, 2 )
2333 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2334 INFOT = 9
2335 CALL CSYMM( 'r', 'l', 2, 0, ALPHA, A, 1, B, 1, BETA, C, 2 )
2336 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2337 INFOT = 12
2338 CALL CSYMM( 'l', 'u', 2, 0, ALPHA, A, 2, B, 2, BETA, C, 1 )
2339 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2340 INFOT = 12
2341 CALL CSYMM( 'r', 'u', 2, 0, ALPHA, A, 1, B, 2, BETA, C, 1 )
2342 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2343 INFOT = 12
2344 CALL CSYMM( 'l', 'l', 2, 0, ALPHA, A, 2, B, 2, BETA, C, 1 )
2345 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2346 INFOT = 12
2347 CALL CSYMM( 'r', 'l', 2, 0, ALPHA, A, 1, B, 2, BETA, C, 1 )
2348 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2349 GO TO 100
2350 40 INFOT = 1
2351 CALL CTRMM( '/', 'u', 'n', 'n', 0, 0, ALPHA, A, 1, B, 1 )
2352 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2353 INFOT = 2
2354 CALL CTRMM( 'l', '/', 'n', 'n', 0, 0, ALPHA, A, 1, B, 1 )
2355 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2356 INFOT = 3
2357 CALL CTRMM( 'l', 'u', '/', 'n', 0, 0, ALPHA, A, 1, B, 1 )
2358 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2359 INFOT = 4
2360 CALL CTRMM( 'l', 'u', 'n', '/', 0, 0, ALPHA, A, 1, B, 1 )
2361 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2362 INFOT = 5
2363 CALL CTRMM( 'l', 'u', 'n', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2364 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2365 INFOT = 5
2366 CALL CTRMM( 'l', 'u', 'c', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2367 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2368 INFOT = 5
2369 CALL CTRMM( 'l', 'u', 't', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2370 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2371 INFOT = 5
2372 CALL CTRMM( 'r', 'u', 'n', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2373 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2374 INFOT = 5
2375 CALL CTRMM( 'r', 'u', 'c', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2376 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2377 INFOT = 5
2378 CALL CTRMM( 'r', 'u', 't', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2379 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2380 INFOT = 5
2381 CALL CTRMM( 'l', 'l', 'n', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2382 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2383 INFOT = 5
2384 CALL CTRMM( 'l', 'l', 'c', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2385 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2386 INFOT = 5
2387 CALL CTRMM( 'l', 'l', 't', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2388 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2389 INFOT = 5
2390 CALL CTRMM( 'r', 'l', 'n', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2391 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2392 INFOT = 5
2393 CALL CTRMM( 'r', 'l', 'c', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2394 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2395 INFOT = 5
2396 CALL CTRMM( 'r', 'l', 't', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2397 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2398 INFOT = 6
2399 CALL CTRMM( 'l', 'u', 'n', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2400 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2401 INFOT = 6
2402 CALL CTRMM( 'l', 'u', 'c', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2403 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2404 INFOT = 6
2405 CALL CTRMM( 'l', 'u', 't', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2406 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2407 INFOT = 6
2408 CALL CTRMM( 'r', 'u', 'n', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2409 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2410 INFOT = 6
2411 CALL CTRMM( 'r', 'u', 'c', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2412 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2413 INFOT = 6
2414 CALL CTRMM( 'r', 'u', 't', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2415 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2416 INFOT = 6
2417 CALL CTRMM( 'l', 'l', 'n', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2418 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2419 INFOT = 6
2420 CALL CTRMM( 'l', 'l', 'c', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2421 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2422 INFOT = 6
2423 CALL CTRMM( 'l', 'l', 't', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2424 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2425 INFOT = 6
2426 CALL CTRMM( 'r', 'l', 'n', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2427 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2428 INFOT = 6
2429 CALL CTRMM( 'r', 'l', 'c', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2430 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2431 INFOT = 6
2432 CALL CTRMM( 'r', 'l', 't', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2433 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2434 INFOT = 9
2435 CALL CTRMM( 'l', 'u', 'n', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2436 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2437 INFOT = 9
2438 CALL CTRMM( 'l', 'u', 'c', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2439 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2440 INFOT = 9
2441 CALL CTRMM( 'l', 'u', 't', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2442 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2443 INFOT = 9
2444 CALL CTRMM( 'r', 'u', 'n', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2445 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2446 INFOT = 9
2447 CALL CTRMM( 'r', 'u', 'c', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2448 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2449 INFOT = 9
2450 CALL CTRMM( 'r', 'u', 't', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2451 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2452 INFOT = 9
2453 CALL CTRMM( 'l', 'l', 'n', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2454 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2455 INFOT = 9
2456 CALL CTRMM( 'l', 'l', 'c', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2457 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2458 INFOT = 9
2459 CALL CTRMM( 'l', 'l', 't', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2460 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2461 INFOT = 9
2462 CALL CTRMM( 'r', 'l', 'n', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2463 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2464 INFOT = 9
2465 CALL CTRMM( 'r', 'l', 'c', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2466 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2467 INFOT = 9
2468 CALL CTRMM( 'r', 'l', 't', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2469 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2470 INFOT = 11
2471 CALL CTRMM( 'l', 'u', 'n', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2472 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2473 INFOT = 11
2474 CALL CTRMM( 'l', 'u', 'c', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2475 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2476 INFOT = 11
2477 CALL CTRMM( 'l', 'u', 't', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2478 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2479 INFOT = 11
2480 CALL CTRMM( 'r', 'u', 'n', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2481 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2482 INFOT = 11
2483 CALL CTRMM( 'r', 'u', 'c', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2484 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2485 INFOT = 11
2486 CALL CTRMM( 'r', 'u', 't', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2487 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2488 INFOT = 11
2489 CALL CTRMM( 'l', 'l', 'n', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2490 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2491 INFOT = 11
2492 CALL CTRMM( 'l', 'l', 'c', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2493 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2494 INFOT = 11
2495 CALL CTRMM( 'l', 'l', 't', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2496 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2497 INFOT = 11
2498 CALL CTRMM( 'r', 'l', 'n', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2499 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2500 INFOT = 11
2501 CALL CTRMM( 'r', 'l', 'c', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2502 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2503 INFOT = 11
2504 CALL CTRMM( 'r', 'l', 't', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2505 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2506 GO TO 100
2507 50 INFOT = 1
2508 CALL CTRSM( '/', 'u', 'n', 'n', 0, 0, ALPHA, A, 1, B, 1 )
2509 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2510 INFOT = 2
2511 CALL CTRSM( 'l', '/', 'n', 'n', 0, 0, ALPHA, A, 1, B, 1 )
2512 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2513 INFOT = 3
2514 CALL CTRSM( 'l', 'u', '/', 'n', 0, 0, ALPHA, A, 1, B, 1 )
2515 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2516 INFOT = 4
2517 CALL CTRSM( 'l', 'u', 'n', '/', 0, 0, ALPHA, A, 1, B, 1 )
2518 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2519 INFOT = 5
2520 CALL CTRSM( 'l', 'u', 'n', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2521 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2522 INFOT = 5
2523 CALL CTRSM( 'l', 'u', 'c', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2524 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2525 INFOT = 5
2526 CALL CTRSM( 'l', 'u', 't', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2527 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2528 INFOT = 5
2529 CALL CTRSM( 'r', 'u', 'n', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2530 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2531 INFOT = 5
2532 CALL CTRSM( 'r', 'u', 'c', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2533 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2534 INFOT = 5
2535 CALL CTRSM( 'r', 'u', 't', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2536 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2537 INFOT = 5
2538 CALL CTRSM( 'l', 'l', 'n', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2539 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2540 INFOT = 5
2541 CALL CTRSM( 'l', 'l', 'c', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2542 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2543 INFOT = 5
2544 CALL CTRSM( 'l', 'l', 't', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2545 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2546 INFOT = 5
2547 CALL CTRSM( 'r', 'l', 'n', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2548 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2549 INFOT = 5
2550 CALL CTRSM( 'r', 'l', 'c', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2551 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2552 INFOT = 5
2553 CALL CTRSM( 'r', 'l', 't', 'n', -1, 0, ALPHA, A, 1, B, 1 )
2554 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2555 INFOT = 6
2556 CALL CTRSM( 'l', 'u', 'n', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2557 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2558 INFOT = 6
2559 CALL CTRSM( 'l', 'u', 'c', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2560 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2561 INFOT = 6
2562 CALL CTRSM( 'l', 'u', 't', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2563 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2564 INFOT = 6
2565 CALL CTRSM( 'r', 'u', 'n', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2566 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2567 INFOT = 6
2568 CALL CTRSM( 'r', 'u', 'c', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2569 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2570 INFOT = 6
2571 CALL CTRSM( 'r', 'u', 't', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2572 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2573 INFOT = 6
2574 CALL CTRSM( 'l', 'l', 'n', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2575 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2576 INFOT = 6
2577 CALL CTRSM( 'l', 'l', 'c', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2578 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2579 INFOT = 6
2580 CALL CTRSM( 'l', 'l', 't', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2581 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2582 INFOT = 6
2583 CALL CTRSM( 'r', 'l', 'n', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2584 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2585 INFOT = 6
2586 CALL CTRSM( 'r', 'l', 'c', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2587 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2588 INFOT = 6
2589 CALL CTRSM( 'r', 'l', 't', 'n', 0, -1, ALPHA, A, 1, B, 1 )
2590 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2591 INFOT = 9
2592 CALL CTRSM( 'l', 'u', 'n', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2593 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2594 INFOT = 9
2595 CALL CTRSM( 'l', 'u', 'c', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2596 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2597 INFOT = 9
2598 CALL CTRSM( 'l', 'u', 't', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2599 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2600 INFOT = 9
2601 CALL CTRSM( 'r', 'u', 'n', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2602 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2603 INFOT = 9
2604 CALL CTRSM( 'r', 'u', 'c', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2605 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2606 INFOT = 9
2607 CALL CTRSM( 'r', 'u', 't', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2608 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2609 INFOT = 9
2610 CALL CTRSM( 'l', 'l', 'n', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2611 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2612 INFOT = 9
2613 CALL CTRSM( 'l', 'l', 'c', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2614 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2615 INFOT = 9
2616 CALL CTRSM( 'l', 'l', 't', 'n', 2, 0, ALPHA, A, 1, B, 2 )
2617 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2618 INFOT = 9
2619 CALL CTRSM( 'r', 'l', 'n', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2620 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2621 INFOT = 9
2622 CALL CTRSM( 'r', 'l', 'c', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2623 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2624 INFOT = 9
2625 CALL CTRSM( 'r', 'l', 't', 'n', 0, 2, ALPHA, A, 1, B, 1 )
2626 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2627 INFOT = 11
2628 CALL CTRSM( 'l', 'u', 'n', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2629 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2630 INFOT = 11
2631 CALL CTRSM( 'l', 'u', 'c', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2632 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2633 INFOT = 11
2634 CALL CTRSM( 'l', 'u', 't', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2635 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2636 INFOT = 11
2637 CALL CTRSM( 'r', 'u', 'n', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2638 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2639 INFOT = 11
2640 CALL CTRSM( 'r', 'u', 'c', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2641 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2642 INFOT = 11
2643 CALL CTRSM( 'r', 'u', 't', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2644 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2645 INFOT = 11
2646 CALL CTRSM( 'l', 'l', 'n', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2647 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2648 INFOT = 11
2649 CALL CTRSM( 'l', 'l', 'c', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2650 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2651 INFOT = 11
2652 CALL CTRSM( 'l', 'l', 't', 'n', 2, 0, ALPHA, A, 2, B, 1 )
2653 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2654 INFOT = 11
2655 CALL CTRSM( 'r', 'l', 'n', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2656 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2657 INFOT = 11
2658 CALL CTRSM( 'r', 'l', 'c', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2659 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2660 INFOT = 11
2661 CALL CTRSM( 'r', 'l', 't', 'n', 2, 0, ALPHA, A, 1, B, 1 )
2662 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2663 GO TO 100
2664 60 INFOT = 1
2665 CALL CHERK( '/', 'n', 0, 0, RALPHA, A, 1, RBETA, C, 1 )
2666 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2667 INFOT = 2
2668 CALL CHERK( 'u', 't', 0, 0, RALPHA, A, 1, RBETA, C, 1 )
2669 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2670 INFOT = 3
2671 CALL CHERK( 'u', 'n', -1, 0, RALPHA, A, 1, RBETA, C, 1 )
2672 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2673 INFOT = 3
2674 CALL CHERK( 'u', 'c', -1, 0, RALPHA, A, 1, RBETA, C, 1 )
2675 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2676 INFOT = 3
2677 CALL CHERK( 'l', 'n', -1, 0, RALPHA, A, 1, RBETA, C, 1 )
2678 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2679 INFOT = 3
2680 CALL CHERK( 'l', 'c', -1, 0, RALPHA, A, 1, RBETA, C, 1 )
2681 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2682 INFOT = 4
2683 CALL CHERK( 'u', 'n', 0, -1, RALPHA, A, 1, RBETA, C, 1 )
2684 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2685 INFOT = 4
2686 CALL CHERK( 'u', 'c', 0, -1, RALPHA, A, 1, RBETA, C, 1 )
2687 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2688 INFOT = 4
2689 CALL CHERK( 'l', 'n', 0, -1, RALPHA, A, 1, RBETA, C, 1 )
2690 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2691 INFOT = 4
2692 CALL CHERK( 'l', 'c', 0, -1, RALPHA, A, 1, RBETA, C, 1 )
2693 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2694 INFOT = 7
2695 CALL CHERK( 'u', 'n', 2, 0, RALPHA, A, 1, RBETA, C, 2 )
2696 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2697 INFOT = 7
2698 CALL CHERK( 'u', 'c', 0, 2, RALPHA, A, 1, RBETA, C, 1 )
2699 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2700 INFOT = 7
2701 CALL CHERK( 'l', 'n', 2, 0, RALPHA, A, 1, RBETA, C, 2 )
2702 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2703 INFOT = 7
2704 CALL CHERK( 'l', 'c', 0, 2, RALPHA, A, 1, RBETA, C, 1 )
2705 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2706 INFOT = 10
2707 CALL CHERK( 'u', 'n', 2, 0, RALPHA, A, 2, RBETA, C, 1 )
2708 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2709 INFOT = 10
2710 CALL CHERK( 'u', 'c', 2, 0, RALPHA, A, 1, RBETA, C, 1 )
2711 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2712 INFOT = 10
2713 CALL CHERK( 'l', 'n', 2, 0, RALPHA, A, 2, RBETA, C, 1 )
2714 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2715 INFOT = 10
2716 CALL CHERK( 'l', 'c', 2, 0, RALPHA, A, 1, RBETA, C, 1 )
2717 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2718 GO TO 100
2719 70 INFOT = 1
2720 CALL CSYRK( '/', 'n', 0, 0, ALPHA, A, 1, BETA, C, 1 )
2721 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2722 INFOT = 2
2723 CALL CSYRK( 'u', 'c', 0, 0, ALPHA, A, 1, BETA, C, 1 )
2724 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2725 INFOT = 3
2726 CALL CSYRK( 'u', 'n', -1, 0, ALPHA, A, 1, BETA, C, 1 )
2727 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2728 INFOT = 3
2729 CALL CSYRK( 'u', 't', -1, 0, ALPHA, A, 1, BETA, C, 1 )
2730 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2731 INFOT = 3
2732 CALL CSYRK( 'l', 'n', -1, 0, ALPHA, A, 1, BETA, C, 1 )
2733 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2734 INFOT = 3
2735 CALL CSYRK( 'l', 't', -1, 0, ALPHA, A, 1, BETA, C, 1 )
2736 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2737 INFOT = 4
2738 CALL CSYRK( 'u', 'n', 0, -1, ALPHA, A, 1, BETA, C, 1 )
2739 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2740 INFOT = 4
2741 CALL CSYRK( 'u', 't', 0, -1, ALPHA, A, 1, BETA, C, 1 )
2742 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2743 INFOT = 4
2744 CALL CSYRK( 'l', 'n', 0, -1, ALPHA, A, 1, BETA, C, 1 )
2745 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2746 INFOT = 4
2747 CALL CSYRK( 'l', 't', 0, -1, ALPHA, A, 1, BETA, C, 1 )
2748 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2749 INFOT = 7
2750 CALL CSYRK( 'u', 'n', 2, 0, ALPHA, A, 1, BETA, C, 2 )
2751 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2752 INFOT = 7
2753 CALL CSYRK( 'u', 't', 0, 2, ALPHA, A, 1, BETA, C, 1 )
2754 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2755 INFOT = 7
2756 CALL CSYRK( 'l', 'n', 2, 0, ALPHA, A, 1, BETA, C, 2 )
2757 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2758 INFOT = 7
2759 CALL CSYRK( 'l', 't', 0, 2, ALPHA, A, 1, BETA, C, 1 )
2760 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2761 INFOT = 10
2762 CALL CSYRK( 'u', 'n', 2, 0, ALPHA, A, 2, BETA, C, 1 )
2763 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2764 INFOT = 10
2765 CALL CSYRK( 'u', 't', 2, 0, ALPHA, A, 1, BETA, C, 1 )
2766 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2767 INFOT = 10
2768 CALL CSYRK( 'l', 'n', 2, 0, ALPHA, A, 2, BETA, C, 1 )
2769 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2770 INFOT = 10
2771 CALL CSYRK( 'l', 't', 2, 0, ALPHA, A, 1, BETA, C, 1 )
2772 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2773 GO TO 100
2774 80 INFOT = 1
2775 CALL CHER2K( '/', 'n', 0, 0, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2776 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2777 INFOT = 2
2778 CALL CHER2K( 'u', 't', 0, 0, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2779 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2780 INFOT = 3
2781 CALL CHER2K( 'u', 'n', -1, 0, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2782 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2783 INFOT = 3
2784 CALL CHER2K( 'u', 'c', -1, 0, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2785 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2786 INFOT = 3
2787 CALL CHER2K( 'l', 'n', -1, 0, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2788 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2789 INFOT = 3
2790 CALL CHER2K( 'l', 'c', -1, 0, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2791 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2792 INFOT = 4
2793 CALL CHER2K( 'u', 'n', 0, -1, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2794 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2795 INFOT = 4
2796 CALL CHER2K( 'u', 'c', 0, -1, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2797 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2798 INFOT = 4
2799 CALL CHER2K( 'l', 'n', 0, -1, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2800 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2801 INFOT = 4
2802 CALL CHER2K( 'l', 'c', 0, -1, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2803 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2804 INFOT = 7
2805 CALL CHER2K( 'u', 'n', 2, 0, ALPHA, A, 1, B, 1, RBETA, C, 2 )
2806 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2807 INFOT = 7
2808 CALL CHER2K( 'u', 'c', 0, 2, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2809 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2810 INFOT = 7
2811 CALL CHER2K( 'l', 'n', 2, 0, ALPHA, A, 1, B, 1, RBETA, C, 2 )
2812 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2813 INFOT = 7
2814 CALL CHER2K( 'l', 'c', 0, 2, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2815 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2816 INFOT = 9
2817 CALL CHER2K( 'u', 'n', 2, 0, ALPHA, A, 2, B, 1, RBETA, C, 2 )
2818 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2819 INFOT = 9
2820 CALL CHER2K( 'u', 'c', 0, 2, ALPHA, A, 2, B, 1, RBETA, C, 1 )
2821 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2822 INFOT = 9
2823 CALL CHER2K( 'l', 'n', 2, 0, ALPHA, A, 2, B, 1, RBETA, C, 2 )
2824 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2825 INFOT = 9
2826 CALL CHER2K( 'l', 'c', 0, 2, ALPHA, A, 2, B, 1, RBETA, C, 1 )
2827 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2828 INFOT = 12
2829 CALL CHER2K( 'u', 'n', 2, 0, ALPHA, A, 2, B, 2, RBETA, C, 1 )
2830 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2831 INFOT = 12
2832 CALL CHER2K( 'u', 'c', 2, 0, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2833 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2834 INFOT = 12
2835 CALL CHER2K( 'l', 'n', 2, 0, ALPHA, A, 2, B, 2, RBETA, C, 1 )
2836 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2837 INFOT = 12
2838 CALL CHER2K( 'l', 'c', 2, 0, ALPHA, A, 1, B, 1, RBETA, C, 1 )
2839 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2840 GO TO 100
2841 90 INFOT = 1
2842 CALL CSYR2K( '/', 'n', 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2843 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2844 INFOT = 2
2845 CALL CSYR2K( 'u', 'c', 0, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2846 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2847 INFOT = 3
2848 CALL CSYR2K( 'u', 'n', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2849 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2850 INFOT = 3
2851 CALL CSYR2K( 'u', 't', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2852 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2853 INFOT = 3
2854 CALL CSYR2K( 'l', 'n', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2855 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2856 INFOT = 3
2857 CALL CSYR2K( 'l', 't', -1, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2858 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2859 INFOT = 4
2860 CALL CSYR2K( 'u', 'n', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2861 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2862 INFOT = 4
2863 CALL CSYR2K( 'u', 't', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2864 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2865 INFOT = 4
2866 CALL CSYR2K( 'l', 'n', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2867 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2868 INFOT = 4
2869 CALL CSYR2K( 'l', 't', 0, -1, ALPHA, A, 1, B, 1, BETA, C, 1 )
2870 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2871 INFOT = 7
2872 CALL CSYR2K( 'u', 'n', 2, 0, ALPHA, A, 1, B, 1, BETA, C, 2 )
2873 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2874 INFOT = 7
2875 CALL CSYR2K( 'u', 't', 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2876 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2877 INFOT = 7
2878 CALL CSYR2K( 'l', 'n', 2, 0, ALPHA, A, 1, B, 1, BETA, C, 2 )
2879 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2880 INFOT = 7
2881 CALL CSYR2K( 'l', 't', 0, 2, ALPHA, A, 1, B, 1, BETA, C, 1 )
2882 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2883 INFOT = 9
2884 CALL CSYR2K( 'u', 'n', 2, 0, ALPHA, A, 2, B, 1, BETA, C, 2 )
2885 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2886 INFOT = 9
2887 CALL CSYR2K( 'u', 't', 0, 2, ALPHA, A, 2, B, 1, BETA, C, 1 )
2888 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2889 INFOT = 9
2890 CALL CSYR2K( 'l', 'n', 2, 0, ALPHA, A, 2, B, 1, BETA, C, 2 )
2891 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2892 INFOT = 9
2893 CALL CSYR2K( 'l', 't', 0, 2, ALPHA, A, 2, B, 1, BETA, C, 1 )
2894 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2895 INFOT = 12
2896 CALL CSYR2K( 'u', 'n', 2, 0, ALPHA, A, 2, B, 2, BETA, C, 1 )
2897 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2898 INFOT = 12
2899 CALL CSYR2K( 'u', 't', 2, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2900 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2901 INFOT = 12
2902 CALL CSYR2K( 'l', 'n', 2, 0, ALPHA, A, 2, B, 2, BETA, C, 1 )
2903 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2904 INFOT = 12
2905 CALL CSYR2K( 'l', 't', 2, 0, ALPHA, A, 1, B, 1, BETA, C, 1 )
2906 CALL CHKXER( SRNAMT, INFOT, NOUT, LERR, OK )
2907*
2908 100 IF( OK )THEN
2909 WRITE( NOUT, FMT = 9999 )SRNAMT
2910 ELSE
2911 WRITE( NOUT, FMT = 9998 )SRNAMT
2912 END IF
2913 RETURN
2914*
2915 9999 FORMAT( ' ', A6, ' passed the tests of error-exits' )
2916 9998 FORMAT( ' ******* ', A6, ' failed the tests of error-exits *****',
2917 $ '**' )
2918*
2919* End of CCHKE
2920*
chkxer
subroutine chkxer(srnamt, infot, nout, lerr, ok)
Definition cblat3.f:3405

◆ chkxer()

subroutine chkxer ( character*6 srnamt,
integer infot,
integer nout,
logical lerr,
logical ok )

Definition at line 3404 of file cblat3.f.

3405*
3406* Tests whether XERBLA has detected an error when it should.
3407*
3408* Auxiliary routine for test program for Level 3 Blas.
3409*
3410* -- Written on 8-February-1989.
3411* Jack Dongarra, Argonne National Laboratory.
3412* Iain Duff, AERE Harwell.
3413* Jeremy Du Croz, Numerical Algorithms Group Ltd.
3414* Sven Hammarling, Numerical Algorithms Group Ltd.
3415*
3416* .. Scalar Arguments ..
3417 INTEGER INFOT, NOUT
3418 LOGICAL LERR, OK
3419 CHARACTER*6 SRNAMT
3420* .. Executable Statements ..
3421 IF( .NOT.lerr )THEN
3422 WRITE( nout, fmt = 9999 )infot, srnamt
3423 ok = .false.
3424 END IF
3425 lerr = .false.
3426 RETURN
3427*
3428 9999 FORMAT( ' ***** ILLEGAL VALUE OF PARAMETER NUMBER ', i2, ' NOT D',
3429 $ 'ETECTED BY ', a6, ' *****' )
3430*
3431* End of CHKXER
3432*

◆ cmake()

subroutine cmake ( character*2 type,
character*1 uplo,
character*1 diag,
integer m,
integer n,
complex, dimension( nmax, * ) a,
integer nmax,
complex, dimension( * ) aa,
integer lda,
logical reset,
complex transl )

Definition at line 2922 of file cblat3.f.

2924*
2925* Generates values for an M by N matrix A.
2926* Stores the values in the array AA in the data structure required
2927* by the routine, with unwanted elements set to rogue value.
2928*
2929* TYPE is 'GE', 'HE', 'SY' or 'TR'.
2930*
2931* Auxiliary routine for test program for Level 3 Blas.
2932*
2933* -- Written on 8-February-1989.
2934* Jack Dongarra, Argonne National Laboratory.
2935* Iain Duff, AERE Harwell.
2936* Jeremy Du Croz, Numerical Algorithms Group Ltd.
2937* Sven Hammarling, Numerical Algorithms Group Ltd.
2938*
2939* .. Parameters ..
2940 COMPLEX ZERO, ONE
2941 parameter( zero = ( 0.0, 0.0 ), one = ( 1.0, 0.0 ) )
2942 COMPLEX ROGUE
2943 parameter( rogue = ( -1.0e10, 1.0e10 ) )
2944 REAL RZERO
2945 parameter( rzero = 0.0 )
2946 REAL RROGUE
2947 parameter( rrogue = -1.0e10 )
2948* .. Scalar Arguments ..
2949 COMPLEX TRANSL
2950 INTEGER LDA, M, N, NMAX
2951 LOGICAL RESET
2952 CHARACTER*1 DIAG, UPLO
2953 CHARACTER*2 TYPE
2954* .. Array Arguments ..
2955 COMPLEX A( NMAX, * ), AA( * )
2956* .. Local Scalars ..
2957 INTEGER I, IBEG, IEND, J, JJ
2958 LOGICAL GEN, HER, LOWER, SYM, TRI, UNIT, UPPER
2959* .. External Functions ..
2960 COMPLEX CBEG
2961 EXTERNAL cbeg
2962* .. Intrinsic Functions ..
2963 INTRINSIC cmplx, conjg, real
2964* .. Executable Statements ..
2965 gen = type.EQ.'GE'
2966 her = type.EQ.'HE'
2967 sym = type.EQ.'SY'
2968 tri = type.EQ.'TR'
2969 upper = ( her.OR.sym.OR.tri ).AND.uplo.EQ.'U'
2970 lower = ( her.OR.sym.OR.tri ).AND.uplo.EQ.'L'
2971 unit = tri.AND.diag.EQ.'U'
2972*
2973* Generate data in array A.
2974*
2975 DO 20 j = 1, n
2976 DO 10 i = 1, m
2977 IF( gen.OR.( upper.AND.i.LE.j ).OR.( lower.AND.i.GE.j ) )
2978 $ THEN
2979 a( i, j ) = cbeg( reset ) + transl
2980 IF( i.NE.j )THEN
2981* Set some elements to zero
2982 IF( n.GT.3.AND.j.EQ.n/2 )
2983 $ a( i, j ) = zero
2984 IF( her )THEN
2985 a( j, i ) = conjg( a( i, j ) )
2986 ELSE IF( sym )THEN
2987 a( j, i ) = a( i, j )
2988 ELSE IF( tri )THEN
2989 a( j, i ) = zero
2990 END IF
2991 END IF
2992 END IF
2993 10 CONTINUE
2994 IF( her )
2995 $ a( j, j ) = cmplx( real( a( j, j ) ), rzero )
2996 IF( tri )
2997 $ a( j, j ) = a( j, j ) + one
2998 IF( unit )
2999 $ a( j, j ) = one
3000 20 CONTINUE
3001*
3002* Store elements in array AS in data structure required by routine.
3003*
3004 IF( type.EQ.'GE' )THEN
3005 DO 50 j = 1, n
3006 DO 30 i = 1, m
3007 aa( i + ( j - 1 )*lda ) = a( i, j )
3008 30 CONTINUE
3009 DO 40 i = m + 1, lda
3010 aa( i + ( j - 1 )*lda ) = rogue
3011 40 CONTINUE
3012 50 CONTINUE
3013 ELSE IF( type.EQ.'HE'.OR.type.EQ.'SY'.OR.type.EQ.'TR' )THEN
3014 DO 90 j = 1, n
3015 IF( upper )THEN
3016 ibeg = 1
3017 IF( unit )THEN
3018 iend = j - 1
3019 ELSE
3020 iend = j
3021 END IF
3022 ELSE
3023 IF( unit )THEN
3024 ibeg = j + 1
3025 ELSE
3026 ibeg = j
3027 END IF
3028 iend = n
3029 END IF
3030 DO 60 i = 1, ibeg - 1
3031 aa( i + ( j - 1 )*lda ) = rogue
3032 60 CONTINUE
3033 DO 70 i = ibeg, iend
3034 aa( i + ( j - 1 )*lda ) = a( i, j )
3035 70 CONTINUE
3036 DO 80 i = iend + 1, lda
3037 aa( i + ( j - 1 )*lda ) = rogue
3038 80 CONTINUE
3039 IF( her )THEN
3040 jj = j + ( j - 1 )*lda
3041 aa( jj ) = cmplx( real( aa( jj ) ), rrogue )
3042 END IF
3043 90 CONTINUE
3044 END IF
3045 RETURN
3046*
3047* End of CMAKE
3048*

◆ cmmch()

subroutine cmmch ( character*1 transa,
character*1 transb,
integer m,
integer n,
integer kk,
complex alpha,
complex, dimension( lda, * ) a,
integer lda,
complex, dimension( ldb, * ) b,
integer ldb,
complex beta,
complex, dimension( ldc, * ) c,
integer ldc,
complex, dimension( * ) ct,
real, dimension( * ) g,
complex, dimension( ldcc, * ) cc,
integer ldcc,
real eps,
real err,
logical fatal,
integer nout,
logical mv )

Definition at line 3050 of file cblat3.f.

3053*
3054* Checks the results of the computational tests.
3055*
3056* Auxiliary routine for test program for Level 3 Blas.
3057*
3058* -- Written on 8-February-1989.
3059* Jack Dongarra, Argonne National Laboratory.
3060* Iain Duff, AERE Harwell.
3061* Jeremy Du Croz, Numerical Algorithms Group Ltd.
3062* Sven Hammarling, Numerical Algorithms Group Ltd.
3063*
3064* .. Parameters ..
3065 COMPLEX ZERO
3066 parameter( zero = ( 0.0, 0.0 ) )
3067 REAL RZERO, RONE
3068 parameter( rzero = 0.0, rone = 1.0 )
3069* .. Scalar Arguments ..
3070 COMPLEX ALPHA, BETA
3071 REAL EPS, ERR
3072 INTEGER KK, LDA, LDB, LDC, LDCC, M, N, NOUT
3073 LOGICAL FATAL, MV
3074 CHARACTER*1 TRANSA, TRANSB
3075* .. Array Arguments ..
3076 COMPLEX A( LDA, * ), B( LDB, * ), C( LDC, * ),
3077 $ CC( LDCC, * ), CT( * )
3078 REAL G( * )
3079* .. Local Scalars ..
3080 COMPLEX CL
3081 REAL ERRI
3082 INTEGER I, J, K
3083 LOGICAL CTRANA, CTRANB, TRANA, TRANB
3084* .. Intrinsic Functions ..
3085 INTRINSIC abs, aimag, conjg, max, real, sqrt
3086* .. Statement Functions ..
3087 REAL ABS1
3088* .. Statement Function definitions ..
3089 abs1( cl ) = abs( real( cl ) ) + abs( aimag( cl ) )
3090* .. Executable Statements ..
3091 trana = transa.EQ.'t.OR..EQ.'TRANSA'c'
3092.EQ. TRANB = TRANSB't.OR..EQ.'TRANSB'c'
3093.EQ. CTRANA = TRANSA'c'
3094.EQ. CTRANB = TRANSB'c'
3095*
3096* Compute expected result, one column at a time, in CT using data
3097* in A, B and C.
3098* Compute gauges in G.
3099*
3100 DO 220 J = 1, N
3101*
3102 DO 10 I = 1, M
3103 CT( I ) = ZERO
3104 G( I ) = RZERO
3105 10 CONTINUE
3106.NOT..AND..NOT. IF( TRANATRANB )THEN
3107 DO 30 K = 1, KK
3108 DO 20 I = 1, M
3109 CT( I ) = CT( I ) + A( I, K )*B( K, J )
3110 G( I ) = G( I ) + ABS1( A( I, K ) )*ABS1( B( K, J ) )
3111 20 CONTINUE
3112 30 CONTINUE
3113.AND..NOT. ELSE IF( TRANATRANB )THEN
3114 IF( CTRANA )THEN
3115 DO 50 K = 1, KK
3116 DO 40 I = 1, M
3117 CT( I ) = CT( I ) + CONJG( A( K, I ) )*B( K, J )
3118 G( I ) = G( I ) + ABS1( A( K, I ) )*
3119 $ ABS1( B( K, J ) )
3120 40 CONTINUE
3121 50 CONTINUE
3122 ELSE
3123 DO 70 K = 1, KK
3124 DO 60 I = 1, M
3125 CT( I ) = CT( I ) + A( K, I )*B( K, J )
3126 G( I ) = G( I ) + ABS1( A( K, I ) )*
3127 $ ABS1( B( K, J ) )
3128 60 CONTINUE
3129 70 CONTINUE
3130 END IF
3131.NOT..AND. ELSE IF( TRANATRANB )THEN
3132 IF( CTRANB )THEN
3133 DO 90 K = 1, KK
3134 DO 80 I = 1, M
3135 CT( I ) = CT( I ) + A( I, K )*CONJG( B( J, K ) )
3136 G( I ) = G( I ) + ABS1( A( I, K ) )*
3137 $ ABS1( B( J, K ) )
3138 80 CONTINUE
3139 90 CONTINUE
3140 ELSE
3141 DO 110 K = 1, KK
3142 DO 100 I = 1, M
3143 CT( I ) = CT( I ) + A( I, K )*B( J, K )
3144 G( I ) = G( I ) + ABS1( A( I, K ) )*
3145 $ ABS1( B( J, K ) )
3146 100 CONTINUE
3147 110 CONTINUE
3148 END IF
3149.AND. ELSE IF( TRANATRANB )THEN
3150 IF( CTRANA )THEN
3151 IF( CTRANB )THEN
3152 DO 130 K = 1, KK
3153 DO 120 I = 1, M
3154 CT( I ) = CT( I ) + CONJG( A( K, I ) )*
3155 $ CONJG( B( J, K ) )
3156 G( I ) = G( I ) + ABS1( A( K, I ) )*
3157 $ ABS1( B( J, K ) )
3158 120 CONTINUE
3159 130 CONTINUE
3160 ELSE
3161 DO 150 K = 1, KK
3162 DO 140 I = 1, M
3163 CT( I ) = CT( I ) + CONJG( A( K, I ) )*B( J, K )
3164 G( I ) = G( I ) + ABS1( A( K, I ) )*
3165 $ ABS1( B( J, K ) )
3166 140 CONTINUE
3167 150 CONTINUE
3168 END IF
3169 ELSE
3170 IF( CTRANB )THEN
3171 DO 170 K = 1, KK
3172 DO 160 I = 1, M
3173 CT( I ) = CT( I ) + A( K, I )*CONJG( B( J, K ) )
3174 G( I ) = G( I ) + ABS1( A( K, I ) )*
3175 $ ABS1( B( J, K ) )
3176 160 CONTINUE
3177 170 CONTINUE
3178 ELSE
3179 DO 190 K = 1, KK
3180 DO 180 I = 1, M
3181 CT( I ) = CT( I ) + A( K, I )*B( J, K )
3182 G( I ) = G( I ) + ABS1( A( K, I ) )*
3183 $ ABS1( B( J, K ) )
3184 180 CONTINUE
3185 190 CONTINUE
3186 END IF
3187 END IF
3188 END IF
3189 DO 200 I = 1, M
3190 CT( I ) = ALPHA*CT( I ) + BETA*C( I, J )
3191 G( I ) = ABS1( ALPHA )*G( I ) +
3192 $ ABS1( BETA )*ABS1( C( I, J ) )
3193 200 CONTINUE
3194*
3195* Compute the error ratio for this result.
3196*
3197 ERR = ZERO
3198 DO 210 I = 1, M
3199 ERRI = ABS1( CT( I ) - CC( I, J ) )/EPS
3200.NE. IF( G( I )RZERO )
3201 $ ERRI = ERRI/G( I )
3202 ERR = MAX( ERR, ERRI )
3203.GE. IF( ERR*SQRT( EPS )RONE )
3204 $ GO TO 230
3205 210 CONTINUE
3206*
3207 220 CONTINUE
3208*
3209* If the loop completes, all results are at least half accurate.
3210 GO TO 250
3211*
3212* Report fatal error.
3213*
3214 230 FATAL = .TRUE.
3215 WRITE( NOUT, FMT = 9999 )
3216 DO 240 I = 1, M
3217 IF( MV )THEN
3218 WRITE( NOUT, FMT = 9998 )I, CT( I ), CC( I, J )
3219 ELSE
3220 WRITE( NOUT, FMT = 9998 )I, CC( I, J ), CT( I )
3221 END IF
3222 240 CONTINUE
3223.GT. IF( N1 )
3224 $ WRITE( NOUT, FMT = 9997 )J
3225*
3226 250 CONTINUE
3227 RETURN
3228*
3229 9999 FORMAT( ' ******* fatal error - computed result is less than hal',
3230 $ 'f accurate *******', /' expected re',
3231 $ 'sult computed result' )
3232 9998 FORMAT( 1X, I7, 2( ' (', G15.6, ',', G15.6, ')' ) )
3233 9997 FORMAT( ' these are the results for column ', I3 )
3234*
3235* End of CMMCH
3236*

◆ lce()

logical function lce ( complex, dimension( * ) ri,
complex, dimension( * ) rj,
integer lr )

Definition at line 3238 of file cblat3.f.

3239*
3240* Tests if two arrays are identical.
3241*
3242* Auxiliary routine for test program for Level 3 Blas.
3243*
3244* -- Written on 8-February-1989.
3245* Jack Dongarra, Argonne National Laboratory.
3246* Iain Duff, AERE Harwell.
3247* Jeremy Du Croz, Numerical Algorithms Group Ltd.
3248* Sven Hammarling, Numerical Algorithms Group Ltd.
3249*
3250* .. Scalar Arguments ..
3251 INTEGER LR
3252* .. Array Arguments ..
3253 COMPLEX RI( * ), RJ( * )
3254* .. Local Scalars ..
3255 INTEGER I
3256* .. Executable Statements ..
3257 DO 10 i = 1, lr
3258 IF( ri( i ).NE.rj( i ) )
3259 $ GO TO 20
3260 10 CONTINUE
3261 lce = .true.
3262 GO TO 30
3263 20 CONTINUE
3264 lce = .false.
3265 30 RETURN
3266*
3267* End of LCE
3268*

◆ lceres()

logical function lceres ( character*2 type,
character*1 uplo,
integer m,
integer n,
complex, dimension( lda, * ) aa,
complex, dimension( lda, * ) as,
integer lda )

Definition at line 3270 of file cblat3.f.

3271*
3272* Tests if selected elements in two arrays are equal.
3273*
3274* TYPE is 'GE' or 'HE' or 'SY'.
3275*
3276* Auxiliary routine for test program for Level 3 Blas.
3277*
3278* -- Written on 8-February-1989.
3279* Jack Dongarra, Argonne National Laboratory.
3280* Iain Duff, AERE Harwell.
3281* Jeremy Du Croz, Numerical Algorithms Group Ltd.
3282* Sven Hammarling, Numerical Algorithms Group Ltd.
3283*
3284* .. Scalar Arguments ..
3285 INTEGER LDA, M, N
3286 CHARACTER*1 UPLO
3287 CHARACTER*2 TYPE
3288* .. Array Arguments ..
3289 COMPLEX AA( LDA, * ), AS( LDA, * )
3290* .. Local Scalars ..
3291 INTEGER I, IBEG, IEND, J
3292 LOGICAL UPPER
3293* .. Executable Statements ..
3294 upper = uplo.EQ.'U'
3295 IF( type.EQ.'GE' )THEN
3296 DO 20 j = 1, n
3297 DO 10 i = m + 1, lda
3298 IF( aa( i, j ).NE.as( i, j ) )
3299 $ GO TO 70
3300 10 CONTINUE
3301 20 CONTINUE
3302 ELSE IF( type.EQ.'HE'.OR.type.EQ.'SY' )THEN
3303 DO 50 j = 1, n
3304 IF( upper )THEN
3305 ibeg = 1
3306 iend = j
3307 ELSE
3308 ibeg = j
3309 iend = n
3310 END IF
3311 DO 30 i = 1, ibeg - 1
3312 IF( aa( i, j ).NE.as( i, j ) )
3313 $ GO TO 70
3314 30 CONTINUE
3315 DO 40 i = iend + 1, lda
3316 IF( aa( i, j ).NE.as( i, j ) )
3317 $ GO TO 70
3318 40 CONTINUE
3319 50 CONTINUE
3320 END IF
3321*
3322 lceres = .true.
3323 GO TO 80
3324 70 CONTINUE
3325 lceres = .false.
3326 80 RETURN
3327*
3328* End of LCERES
3329*

◆ sdiff()

real function sdiff ( real x,
real y )

Definition at line 3385 of file cblat3.f.

3386*
3387* Auxiliary routine for test program for Level 3 Blas.
3388*
3389* -- Written on 8-February-1989.
3390* Jack Dongarra, Argonne National Laboratory.
3391* Iain Duff, AERE Harwell.
3392* Jeremy Du Croz, Numerical Algorithms Group Ltd.
3393* Sven Hammarling, Numerical Algorithms Group Ltd.
3394*
3395* .. Scalar Arguments ..
3396 REAL X, Y
3397* .. Executable Statements ..
3398 sdiff = x - y
3399 RETURN
3400*
3401* End of SDIFF
3402*
sdiff
real function sdiff(x, y)
Definition cblat3.f:3386

◆ xerbla()

subroutine xerbla ( character*6 srname,
integer info )

Definition at line 3434 of file cblat3.f.

3435*
3436* This is a special version of XERBLA to be used only as part of
3437* the test program for testing error exits from the Level 3 BLAS
3438* routines.
3439*
3440* XERBLA is an error handler for the Level 3 BLAS routines.
3441*
3442* It is called by the Level 3 BLAS routines if an input parameter is
3443* invalid.
3444*
3445* Auxiliary routine for test program for Level 3 Blas.
3446*
3447* -- Written on 8-February-1989.
3448* Jack Dongarra, Argonne National Laboratory.
3449* Iain Duff, AERE Harwell.
3450* Jeremy Du Croz, Numerical Algorithms Group Ltd.
3451* Sven Hammarling, Numerical Algorithms Group Ltd.
3452*
3453* .. Scalar Arguments ..
3454 INTEGER INFO
3455 CHARACTER*6 SRNAME
3456* .. Scalars in Common ..
3457 INTEGER INFOT, NOUT
3458 LOGICAL LERR, OK
3459 CHARACTER*6 SRNAMT
3460* .. Common blocks ..
3461 COMMON /infoc/infot, nout, ok, lerr
3462 COMMON /srnamc/srnamt
3463* .. Executable Statements ..
3464 lerr = .true.
3465 IF( info.NE.infot )THEN
3466 IF( infot.NE.0 )THEN
3467 WRITE( nout, fmt = 9999 )info, infot
3468 ELSE
3469 WRITE( nout, fmt = 9997 )info
3470 END IF
3471 ok = .false.
3472 END IF
3473 IF( srname.NE.srnamt )THEN
3474 WRITE( nout, fmt = 9998 )srname, srnamt
3475 ok = .false.
3476 END IF
3477 RETURN
3478*
3479 9999 FORMAT( ' ******* XERBLA WAS CALLED WITH INFO = ', i6, ' INSTEAD',
3480 $ ' OF ', i2, ' *******' )
3481 9998 FORMAT( ' ******* XERBLA WAS CALLED WITH SRNAME = ', a6, ' INSTE',
3482 $ 'AD OF ', a6, ' *******' )
3483 9997 FORMAT( ' ******* XERBLA WAS CALLED WITH INFO = ', i6,
3484 $ ' *******' )
3485*
3486* End of XERBLA
3487*