SCALAPACK 2.2.2
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ pzblas2tstchk()

subroutine pzblas2tstchk ( integer  ictxt,
integer  nout,
integer  nrout,
character*1  uplo,
character*1  trans,
character*1  diag,
integer  m,
integer  n,
complex*16  alpha,
complex*16, dimension( * )  a,
complex*16, dimension( * )  pa,
integer  ia,
integer  ja,
integer, dimension( * )  desca,
complex*16, dimension( * )  x,
complex*16, dimension( * )  px,
integer  ix,
integer  jx,
integer, dimension( * )  descx,
integer  incx,
complex*16  beta,
complex*16, dimension( * )  y,
complex*16, dimension( * )  py,
integer  iy,
integer  jy,
integer, dimension( * )  descy,
integer  incy,
real  thresh,
complex*16  rogue,
double precision, dimension( * )  work,
integer  info 
)

Definition at line 2562 of file pzblas2tst.f.

2567*
2568* -- PBLAS test routine (version 2.0) --
2569* University of Tennessee, Knoxville, Oak Ridge National Laboratory,
2570* and University of California, Berkeley.
2571* April 1, 1998
2572*
2573* .. Scalar Arguments ..
2574 CHARACTER*1 DIAG, TRANS, UPLO
2575 INTEGER IA, ICTXT, INCX, INCY, INFO, IX, IY, JA, JX,
2576 $ JY, M, N, NOUT, NROUT
2577 REAL THRESH
2578 COMPLEX*16 ALPHA, BETA, ROGUE
2579* ..
2580* .. Array Arguments ..
2581 INTEGER DESCA( * ), DESCX( * ), DESCY( * )
2582 DOUBLE PRECISION WORK( * )
2583 COMPLEX*16 A( * ), PA( * ), PX( * ), PY( * ), X( * ),
2584 $ Y( * )
2585* ..
2586*
2587* Purpose
2588* =======
2589*
2590* PZBLAS2TSTCHK performs the computational tests of the Level 2 PBLAS.
2591*
2592* Notes
2593* =====
2594*
2595* A description vector is associated with each 2D block-cyclicly dis-
2596* tributed matrix. This vector stores the information required to
2597* establish the mapping between a matrix entry and its corresponding
2598* process and memory location.
2599*
2600* In the following comments, the character _ should be read as
2601* "of the distributed matrix". Let A be a generic term for any 2D
2602* block cyclicly distributed matrix. Its description vector is DESCA:
2603*
2604* NOTATION STORED IN EXPLANATION
2605* ---------------- --------------- ------------------------------------
2606* DTYPE_A (global) DESCA( DTYPE_ ) The descriptor type.
2607* CTXT_A (global) DESCA( CTXT_ ) The BLACS context handle, indicating
2608* the NPROW x NPCOL BLACS process grid
2609* A is distributed over. The context
2610* itself is global, but the handle
2611* (the integer value) may vary.
2612* M_A (global) DESCA( M_ ) The number of rows in the distribu-
2613* ted matrix A, M_A >= 0.
2614* N_A (global) DESCA( N_ ) The number of columns in the distri-
2615* buted matrix A, N_A >= 0.
2616* IMB_A (global) DESCA( IMB_ ) The number of rows of the upper left
2617* block of the matrix A, IMB_A > 0.
2618* INB_A (global) DESCA( INB_ ) The number of columns of the upper
2619* left block of the matrix A,
2620* INB_A > 0.
2621* MB_A (global) DESCA( MB_ ) The blocking factor used to distri-
2622* bute the last M_A-IMB_A rows of A,
2623* MB_A > 0.
2624* NB_A (global) DESCA( NB_ ) The blocking factor used to distri-
2625* bute the last N_A-INB_A columns of
2626* A, NB_A > 0.
2627* RSRC_A (global) DESCA( RSRC_ ) The process row over which the first
2628* row of the matrix A is distributed,
2629* NPROW > RSRC_A >= 0.
2630* CSRC_A (global) DESCA( CSRC_ ) The process column over which the
2631* first column of A is distributed.
2632* NPCOL > CSRC_A >= 0.
2633* LLD_A (local) DESCA( LLD_ ) The leading dimension of the local
2634* array storing the local blocks of
2635* the distributed matrix A,
2636* IF( Lc( 1, N_A ) > 0 )
2637* LLD_A >= MAX( 1, Lr( 1, M_A ) )
2638* ELSE
2639* LLD_A >= 1.
2640*
2641* Let K be the number of rows of a matrix A starting at the global in-
2642* dex IA,i.e, A( IA:IA+K-1, : ). Lr( IA, K ) denotes the number of rows
2643* that the process of row coordinate MYROW ( 0 <= MYROW < NPROW ) would
2644* receive if these K rows were distributed over NPROW processes. If K
2645* is the number of columns of a matrix A starting at the global index
2646* JA, i.e, A( :, JA:JA+K-1, : ), Lc( JA, K ) denotes the number of co-
2647* lumns that the process MYCOL ( 0 <= MYCOL < NPCOL ) would receive if
2648* these K columns were distributed over NPCOL processes.
2649*
2650* The values of Lr() and Lc() may be determined via a call to the func-
2651* tion PB_NUMROC:
2652* Lr( IA, K ) = PB_NUMROC( K, IA, IMB_A, MB_A, MYROW, RSRC_A, NPROW )
2653* Lc( JA, K ) = PB_NUMROC( K, JA, INB_A, NB_A, MYCOL, CSRC_A, NPCOL )
2654*
2655* Arguments
2656* =========
2657*
2658* ICTXT (local input) INTEGER
2659* On entry, ICTXT specifies the BLACS context handle, indica-
2660* ting the global context of the operation. The context itself
2661* is global, but the value of ICTXT is local.
2662*
2663* NOUT (global input) INTEGER
2664* On entry, NOUT specifies the unit number for the output file.
2665* When NOUT is 6, output to screen, when NOUT is 0, output to
2666* stderr. NOUT is only defined for process 0.
2667*
2668* NROUT (global input) INTEGER
2669* On entry, NROUT specifies which routine will be tested as
2670* follows:
2671* If NROUT = 1, PZGEMV will be tested;
2672* else if NROUT = 2, PZHEMV will be tested;
2673* else if NROUT = 3, PZTRMV will be tested;
2674* else if NROUT = 4, PZTRSV will be tested;
2675* else if NROUT = 5, PZGERU will be tested;
2676* else if NROUT = 6, PZGERC will be tested;
2677* else if NROUT = 7, PZHER will be tested;
2678* else if NROUT = 8, PZHER2 will be tested;
2679*
2680* UPLO (global input) CHARACTER*1
2681* On entry, UPLO specifies if the upper or lower part of the
2682* matrix operand is to be referenced.
2683*
2684* TRANS (global input) CHARACTER*1
2685* On entry, TRANS specifies if the matrix operand A is to be
2686* transposed.
2687*
2688* DIAG (global input) CHARACTER*1
2689* On entry, DIAG specifies if the triangular matrix operand is
2690* unit or non-unit.
2691*
2692* M (global input) INTEGER
2693* On entry, M specifies the number of rows of A.
2694*
2695* N (global input) INTEGER
2696* On entry, N specifies the number of columns of A.
2697*
2698* ALPHA (global input) COMPLEX*16
2699* On entry, ALPHA specifies the scalar alpha.
2700*
2701* A (local input/local output) COMPLEX*16 array
2702* On entry, A is an array of dimension (DESCA( M_ ),*). This
2703* array contains a local copy of the initial entire matrix PA.
2704*
2705* PA (local input) COMPLEX*16 array
2706* On entry, PA is an array of dimension (DESCA( LLD_ ),*). This
2707* array contains the local entries of the matrix PA.
2708*
2709* IA (global input) INTEGER
2710* On entry, IA specifies A's global row index, which points to
2711* the beginning of the submatrix sub( A ).
2712*
2713* JA (global input) INTEGER
2714* On entry, JA specifies A's global column index, which points
2715* to the beginning of the submatrix sub( A ).
2716*
2717* DESCA (global and local input) INTEGER array
2718* On entry, DESCA is an integer array of dimension DLEN_. This
2719* is the array descriptor for the matrix A.
2720*
2721* X (local input/local output) COMPLEX*16 array
2722* On entry, X is an array of dimension (DESCX( M_ ),*). This
2723* array contains a local copy of the initial entire matrix PX.
2724*
2725* PX (local input) COMPLEX*16 array
2726* On entry, PX is an array of dimension (DESCX( LLD_ ),*). This
2727* array contains the local entries of the matrix PX.
2728*
2729* IX (global input) INTEGER
2730* On entry, IX specifies X's global row index, which points to
2731* the beginning of the submatrix sub( X ).
2732*
2733* JX (global input) INTEGER
2734* On entry, JX specifies X's global column index, which points
2735* to the beginning of the submatrix sub( X ).
2736*
2737* DESCX (global and local input) INTEGER array
2738* On entry, DESCX is an integer array of dimension DLEN_. This
2739* is the array descriptor for the matrix X.
2740*
2741* INCX (global input) INTEGER
2742* On entry, INCX specifies the global increment for the
2743* elements of X. Only two values of INCX are supported in
2744* this version, namely 1 and M_X. INCX must not be zero.
2745*
2746* BETA (global input) COMPLEX*16
2747* On entry, BETA specifies the scalar beta.
2748*
2749* Y (local input/local output) COMPLEX*16 array
2750* On entry, Y is an array of dimension (DESCY( M_ ),*). This
2751* array contains a local copy of the initial entire matrix PY.
2752*
2753* PY (local input) COMPLEX*16 array
2754* On entry, PY is an array of dimension (DESCY( LLD_ ),*). This
2755* array contains the local entries of the matrix PY.
2756*
2757* IY (global input) INTEGER
2758* On entry, IY specifies Y's global row index, which points to
2759* the beginning of the submatrix sub( Y ).
2760*
2761* JY (global input) INTEGER
2762* On entry, JY specifies Y's global column index, which points
2763* to the beginning of the submatrix sub( Y ).
2764*
2765* DESCY (global and local input) INTEGER array
2766* On entry, DESCY is an integer array of dimension DLEN_. This
2767* is the array descriptor for the matrix Y.
2768*
2769* INCY (global input) INTEGER
2770* On entry, INCY specifies the global increment for the
2771* elements of Y. Only two values of INCY are supported in
2772* this version, namely 1 and M_Y. INCY must not be zero.
2773*
2774* THRESH (global input) REAL
2775* On entry, THRESH is the threshold value for the test ratio.
2776*
2777* ROGUE (global input) COMPLEX*16
2778* On entry, ROGUE specifies the constant used to pad the
2779* non-referenced part of triangular, symmetric or Hermitian ma-
2780* trices.
2781*
2782* WORK (workspace) DOUBLE PRECISION array
2783* On entry, WORK is an array of dimension LWORK where LWORK is
2784* at least MAX( M, N ). This array is used to store the compu-
2785* ted gauges (see PZMVCH).
2786*
2787* INFO (global output) INTEGER
2788* On exit, if INFO = 0, no error has been found, otherwise
2789* if( MOD( INFO, 2 ) = 1 ) then an error on A has been found,
2790* if( MOD( INFO/2, 2 ) = 1 ) then an error on X has been found,
2791* if( MOD( INFO/4, 2 ) = 1 ) then an error on Y has been found.
2792*
2793* -- Written on April 1, 1998 by
2794* Antoine Petitet, University of Tennessee, Knoxville 37996, USA.
2795*
2796* =====================================================================
2797*
2798* .. Parameters ..
2799 DOUBLE PRECISION RZERO
2800 parameter( rzero = 0.0d+0 )
2801 COMPLEX*16 ONE, ZERO
2802 parameter( one = ( 1.0d+0, 0.0d+0 ),
2803 $ zero = ( 0.0d+0, 0.0d+0 ) )
2804 INTEGER BLOCK_CYCLIC_2D_INB, CSRC_, CTXT_, DLEN_,
2805 $ DTYPE_, IMB_, INB_, LLD_, MB_, M_, NB_, N_,
2806 $ RSRC_
2807 parameter( block_cyclic_2d_inb = 2, dlen_ = 11,
2808 $ dtype_ = 1, ctxt_ = 2, m_ = 3, n_ = 4,
2809 $ imb_ = 5, inb_ = 6, mb_ = 7, nb_ = 8,
2810 $ rsrc_ = 9, csrc_ = 10, lld_ = 11 )
2811* ..
2812* .. Local Scalars ..
2813 INTEGER I, MYCOL, MYROW, NPCOL, NPROW
2814 DOUBLE PRECISION ERR
2815 COMPLEX*16 ALPHA1
2816* ..
2817* .. Local Arrays ..
2818 INTEGER IERR( 3 )
2819* ..
2820* .. External Subroutines ..
2821 EXTERNAL blacs_gridinfo, pb_zlaset, pzchkmin, pzchkvin,
2822 $ pzmvch, pztrmv, pzvmch, pzvmch2, ztrsv
2823* ..
2824* .. External Functions ..
2825 LOGICAL LSAME
2826 EXTERNAL lsame
2827* ..
2828* .. Intrinsic Functions ..
2829 INTRINSIC dcmplx, dble
2830* ..
2831* .. Executable Statements ..
2832*
2833 info = 0
2834*
2835* Quick return if possible
2836*
2837 IF( ( m.LE.0 ).OR.( n.LE.0 ) )
2838 $ RETURN
2839*
2840* Start the operations
2841*
2842 CALL blacs_gridinfo( ictxt, nprow, npcol, myrow, mycol )
2843*
2844 DO 10 i = 1, 3
2845 ierr( i ) = 0
2846 10 CONTINUE
2847*
2848 IF( nrout.EQ.1 ) THEN
2849*
2850* Test PZGEMV
2851*
2852* Check the resulting vector Y
2853*
2854 CALL pzmvch( ictxt, trans, m, n, alpha, a, ia, ja, desca, x,
2855 $ ix, jx, descx, incx, beta, y, py, iy, jy, descy,
2856 $ incy, work, err, ierr( 3 ) )
2857*
2858 IF( ierr( 3 ).NE.0 ) THEN
2859 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
2860 $ WRITE( nout, fmt = 9997 )
2861 ELSE IF( err.GT.dble( thresh ) ) THEN
2862 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
2863 $ WRITE( nout, fmt = 9996 ) err
2864 END IF
2865*
2866* Check the input-only arguments
2867*
2868 CALL pzchkmin( err, m, n, a, pa, ia, ja, desca, ierr( 1 ) )
2869 IF( lsame( trans, 'N' ) ) THEN
2870 CALL pzchkvin( err, n, x, px, ix, jx, descx, incx,
2871 $ ierr( 2 ) )
2872 ELSE
2873 CALL pzchkvin( err, m, x, px, ix, jx, descx, incx,
2874 $ ierr( 2 ) )
2875 END IF
2876*
2877 ELSE IF( nrout.EQ.2 ) THEN
2878*
2879* Test PZHEMV
2880*
2881* Check the resulting vector Y
2882*
2883 CALL pzmvch( ictxt, 'No transpose', n, n, alpha, a, ia, ja,
2884 $ desca, x, ix, jx, descx, incx, beta, y, py, iy,
2885 $ jy, descy, incy, work, err, ierr( 3 ) )
2886*
2887 IF( ierr( 3 ).NE.0 ) THEN
2888 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
2889 $ WRITE( nout, fmt = 9997 )
2890 ELSE IF( err.GT.dble( thresh ) ) THEN
2891 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
2892 $ WRITE( nout, fmt = 9996 ) err
2893 END IF
2894*
2895* Check the input-only arguments
2896*
2897 IF( lsame( uplo, 'L' ) ) THEN
2898 CALL pb_zlaset( 'Upper', n-1, n-1, 0, rogue, rogue,
2899 $ a( ia+ja*desca( m_ ) ), desca( m_ ) )
2900 ELSE
2901 CALL pb_zlaset( 'Lower', n-1, n-1, 0, rogue, rogue,
2902 $ a( ia+1+(ja-1)*desca( m_ ) ), desca( m_ ) )
2903 END IF
2904 CALL pzchkmin( err, n, n, a, pa, ia, ja, desca, ierr( 1 ) )
2905 CALL pzchkvin( err, n, x, px, ix, jx, descx, incx, ierr( 2 ) )
2906*
2907 ELSE IF( nrout.EQ.3 ) THEN
2908*
2909* Test PZTRMV
2910*
2911* Check the resulting vector X
2912*
2913 CALL pzmvch( ictxt, trans, n, n, one, a, ia, ja, desca, y, ix,
2914 $ jx, descx, incx, zero, x, px, ix, jx, descx, incx,
2915 $ work, err, ierr( 2 ) )
2916*
2917 IF( ierr( 2 ).NE.0 ) THEN
2918 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
2919 $ WRITE( nout, fmt = 9997 )
2920 ELSE IF( err.GT.dble( thresh ) ) THEN
2921 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
2922 $ WRITE( nout, fmt = 9996 ) err
2923 END IF
2924*
2925* Check the input-only arguments
2926*
2927 IF( lsame( uplo, 'L' ) ) THEN
2928 IF( lsame( diag, 'N' ) ) THEN
2929 CALL pb_zlaset( 'Upper', n-1, n-1, 0, rogue, rogue,
2930 $ a( ia+ja*desca( m_ ) ), desca( m_ ) )
2931 ELSE
2932 CALL pb_zlaset( 'Upper', n, n, 0, rogue, one,
2933 $ a( ia+(ja-1)*desca( m_ ) ), desca( m_ ) )
2934 END IF
2935 ELSE
2936 IF( lsame( diag, 'N' ) ) THEN
2937 CALL pb_zlaset( 'Lower', n-1, n-1, 0, rogue, rogue,
2938 $ a( ia+1+(ja-1)*desca( m_ ) ),
2939 $ desca( m_ ) )
2940 ELSE
2941 CALL pb_zlaset( 'Lower', n, n, 0, rogue, one,
2942 $ a( ia+(ja-1)*desca( m_ ) ), desca( m_ ) )
2943 END IF
2944 END IF
2945 CALL pzchkmin( err, n, n, a, pa, ia, ja, desca, ierr( 1 ) )
2946*
2947 ELSE IF( nrout.EQ.4 ) THEN
2948*
2949* Test PZTRSV
2950*
2951* Check the resulting vector X
2952*
2953 CALL ztrsv( uplo, trans, diag, n, a( ia+(ja-1)*desca( m_ ) ),
2954 $ desca( m_ ), x( ix+(jx-1)*descx( m_ ) ), incx )
2955 CALL pztrmv( uplo, trans, diag, n, pa, ia, ja, desca, px, ix,
2956 $ jx, descx, incx )
2957 CALL pzmvch( ictxt, trans, n, n, one, a, ia, ja, desca, x, ix,
2958 $ jx, descx, incx, zero, y, px, ix, jx, descx, incx,
2959 $ work, err, ierr( 2 ) )
2960*
2961 IF( ierr( 2 ).NE.0 ) THEN
2962 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
2963 $ WRITE( nout, fmt = 9997 )
2964 ELSE IF( err.GT.dble( thresh ) ) THEN
2965 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
2966 $ WRITE( nout, fmt = 9996 ) err
2967 END IF
2968*
2969* Check the input-only arguments
2970*
2971 IF( lsame( uplo, 'L' ) ) THEN
2972 IF( lsame( diag, 'N' ) ) THEN
2973 CALL pb_zlaset( 'Upper', n-1, n-1, 0, rogue, rogue,
2974 $ a( ia+ja*desca( m_ ) ), desca( m_ ) )
2975 ELSE
2976 CALL pb_zlaset( 'Upper', n, n, 0, rogue, one,
2977 $ a( ia+(ja-1)*desca( m_ ) ), desca( m_ ) )
2978 END IF
2979 ELSE
2980 IF( lsame( diag, 'N' ) ) THEN
2981 CALL pb_zlaset( 'Lower', n-1, n-1, 0, rogue, rogue,
2982 $ a( ia+1+(ja-1)*desca( m_ ) ),
2983 $ desca( m_ ) )
2984 ELSE
2985 CALL pb_zlaset( 'Lower', n, n, 0, rogue, one,
2986 $ a( ia+(ja-1)*desca( m_ ) ), desca( m_ ) )
2987 END IF
2988 END IF
2989 CALL pzchkmin( err, n, n, a, pa, ia, ja, desca, ierr( 1 ) )
2990*
2991 ELSE IF( nrout.EQ.5 ) THEN
2992*
2993* Test PZGERU
2994*
2995* Check the resulting matrix A
2996*
2997 CALL pzvmch( ictxt, 'No transpose', 'Ge', m, n, alpha, x, ix,
2998 $ jx, descx, incx, y, iy, jy, descy, incy, a, pa,
2999 $ ia, ja, desca, work, err, ierr( 1 ) )
3000 IF( ierr( 1 ).NE.0 ) THEN
3001 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3002 $ WRITE( nout, fmt = 9997 )
3003 ELSE IF( err.GT.dble( thresh ) ) THEN
3004 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3005 $ WRITE( nout, fmt = 9996 ) err
3006 END IF
3007*
3008* Check the input-only arguments
3009*
3010 CALL pzchkvin( err, m, x, px, ix, jx, descx, incx, ierr( 2 ) )
3011 CALL pzchkvin( err, n, y, py, iy, jy, descy, incy, ierr( 3 ) )
3012*
3013 ELSE IF( nrout.EQ.6 ) THEN
3014*
3015* Test PZGERC
3016*
3017* Check the resulting matrix A
3018*
3019 CALL pzvmch( ictxt, 'Conjugate transpose', 'Ge', m, n, alpha,
3020 $ x, ix, jx, descx, incx, y, iy, jy, descy, incy,
3021 $ a, pa, ia, ja, desca, work, err, ierr( 1 ) )
3022 IF( ierr( 1 ).NE.0 ) THEN
3023 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3024 $ WRITE( nout, fmt = 9997 )
3025 ELSE IF( err.GT.dble( thresh ) ) THEN
3026 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3027 $ WRITE( nout, fmt = 9996 ) err
3028 END IF
3029*
3030* Check the input-only arguments
3031*
3032 CALL pzchkvin( err, m, x, px, ix, jx, descx, incx, ierr( 2 ) )
3033 CALL pzchkvin( err, n, y, py, iy, jy, descy, incy, ierr( 3 ) )
3034*
3035 ELSE IF( nrout.EQ.7 ) THEN
3036*
3037* Test PZHER
3038*
3039* Check the resulting matrix A
3040*
3041 alpha1 = dcmplx( dble( alpha ), rzero )
3042 CALL pzvmch( ictxt, 'Conjugate transpose', uplo, n, n, alpha1,
3043 $ x, ix, jx, descx, incx, x, ix, jx, descx, incx, a,
3044 $ pa, ia, ja, desca, work, err, ierr( 1 ) )
3045 IF( ierr( 1 ).NE.0 ) THEN
3046 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3047 $ WRITE( nout, fmt = 9997 )
3048 ELSE IF( err.GT.dble( thresh ) ) THEN
3049 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3050 $ WRITE( nout, fmt = 9996 ) err
3051 END IF
3052*
3053* Check the input-only arguments
3054*
3055 CALL pzchkvin( err, n, x, px, ix, jx, descx, incx, ierr( 2 ) )
3056*
3057 ELSE IF( nrout.EQ.8 ) THEN
3058*
3059* Test PZHER2
3060*
3061* Check the resulting matrix A
3062*
3063 CALL pzvmch2( ictxt, uplo, n, n, alpha, x, ix, jx, descx, incx,
3064 $ y, iy, jy, descy, incy, a, pa, ia, ja, desca,
3065 $ work, err, ierr( 1 ) )
3066 IF( ierr( 1 ).NE.0 ) THEN
3067 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3068 $ WRITE( nout, fmt = 9997 )
3069 ELSE IF( err.GT.dble( thresh ) ) THEN
3070 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3071 $ WRITE( nout, fmt = 9996 ) err
3072 END IF
3073*
3074* Check the input-only arguments
3075*
3076 CALL pzchkvin( err, n, x, px, ix, jx, descx, incx, ierr( 2 ) )
3077 CALL pzchkvin( err, n, y, py, iy, jy, descy, incy, ierr( 3 ) )
3078*
3079 END IF
3080*
3081 IF( ierr( 1 ).NE.0 ) THEN
3082 info = info + 1
3083 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3084 $ WRITE( nout, fmt = 9999 ) 'A'
3085 END IF
3086*
3087 IF( ierr( 2 ).NE.0 ) THEN
3088 info = info + 2
3089 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3090 $ WRITE( nout, fmt = 9998 ) 'X'
3091 END IF
3092*
3093 IF( ierr( 3 ).NE.0 ) THEN
3094 info = info + 4
3095 IF( myrow.EQ.0 .AND. mycol.EQ.0 )
3096 $ WRITE( nout, fmt = 9998 ) 'Y'
3097 END IF
3098*
3099 9999 FORMAT( 2x, ' ***** ERROR: Matrix operand ', a,
3100 $ ' is incorrect.' )
3101 9998 FORMAT( 2x, ' ***** ERROR: Vector operand ', a,
3102 $ ' is incorrect.' )
3103 9997 FORMAT( 2x, ' ***** FATAL ERROR - Computed result is less ',
3104 $ 'than half accurate *****' )
3105 9996 FORMAT( 2x, ' ***** Test completed with maximum test ratio: ',
3106 $ f11.5, ' SUSPECT *****' )
3107*
3108 RETURN
3109*
3110* End of PZBLAS2TSTCHK
3111*
pzchkvin
subroutine pzchkvin(errmax, n, x, px, ix, jx, descx, incx, info)
Definition pzblastst.f:2582
pb_zlaset
subroutine pb_zlaset(uplo, m, n, ioffd, alpha, beta, a, lda)
Definition pzblastst.f:10049
pzchkmin
subroutine pzchkmin(errmax, m, n, a, pa, ia, ja, desca, info)
Definition pzblastst.f:3332
pzmvch
subroutine pzmvch(ictxt, trans, m, n, alpha, a, ia, ja, desca, x, ix, jx, descx, incx, beta, y, py, iy, jy, descy, incy, g, err, info)
Definition pzblastst.f:4172
pzvmch
subroutine pzvmch(ictxt, trans, uplo, m, n, alpha, x, ix, jx, descx, incx, y, iy, jy, descy, incy, a, pa, ia, ja, desca, g, err, info)
Definition pzblastst.f:4606
pzvmch2
subroutine pzvmch2(ictxt, uplo, m, n, alpha, x, ix, jx, descx, incx, y, iy, jy, descy, incy, a, pa, ia, ja, desca, g, err, info)
Definition pzblastst.f:4975
lsame
logical function lsame(ca, cb)
Definition tools.f:1724
Here is the call graph for this function:
Here is the caller graph for this function: