LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
zsymv.f
Go to the documentation of this file.
00001 *> \brief \b ZSYMV
00002 *
00003 *  =========== DOCUMENTATION ===========
00004 *
00005 * Online html documentation available at 
00006 *            http://www.netlib.org/lapack/explore-html/ 
00007 *
00008 *> \htmlonly
00009 *> Download ZSYMV + dependencies 
00010 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/zsymv.f"> 
00011 *> [TGZ]</a> 
00012 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/zsymv.f"> 
00013 *> [ZIP]</a> 
00014 *> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/zsymv.f"> 
00015 *> [TXT]</a>
00016 *> \endhtmlonly 
00017 *
00018 *  Definition:
00019 *  ===========
00020 *
00021 *       SUBROUTINE ZSYMV( UPLO, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY )
00022 * 
00023 *       .. Scalar Arguments ..
00024 *       CHARACTER          UPLO
00025 *       INTEGER            INCX, INCY, LDA, N
00026 *       COMPLEX*16         ALPHA, BETA
00027 *       ..
00028 *       .. Array Arguments ..
00029 *       COMPLEX*16         A( LDA, * ), X( * ), Y( * )
00030 *       ..
00031 *  
00032 *
00033 *> \par Purpose:
00034 *  =============
00035 *>
00036 *> \verbatim
00037 *>
00038 *> ZSYMV  performs the matrix-vector  operation
00039 *>
00040 *>    y := alpha*A*x + beta*y,
00041 *>
00042 *> where alpha and beta are scalars, x and y are n element vectors and
00043 *> A is an n by n symmetric matrix.
00044 *> \endverbatim
00045 *
00046 *  Arguments:
00047 *  ==========
00048 *
00049 *> \param[in] UPLO
00050 *> \verbatim
00051 *>          UPLO is CHARACTER*1
00052 *>           On entry, UPLO specifies whether the upper or lower
00053 *>           triangular part of the array A is to be referenced as
00054 *>           follows:
00055 *>
00056 *>              UPLO = 'U' or 'u'   Only the upper triangular part of A
00057 *>                                  is to be referenced.
00058 *>
00059 *>              UPLO = 'L' or 'l'   Only the lower triangular part of A
00060 *>                                  is to be referenced.
00061 *>
00062 *>           Unchanged on exit.
00063 *> \endverbatim
00064 *>
00065 *> \param[in] N
00066 *> \verbatim
00067 *>          N is INTEGER
00068 *>           On entry, N specifies the order of the matrix A.
00069 *>           N must be at least zero.
00070 *>           Unchanged on exit.
00071 *> \endverbatim
00072 *>
00073 *> \param[in] ALPHA
00074 *> \verbatim
00075 *>          ALPHA is COMPLEX*16
00076 *>           On entry, ALPHA specifies the scalar alpha.
00077 *>           Unchanged on exit.
00078 *> \endverbatim
00079 *>
00080 *> \param[in] A
00081 *> \verbatim
00082 *>          A is COMPLEX*16 array, dimension ( LDA, N )
00083 *>           Before entry, with  UPLO = 'U' or 'u', the leading n by n
00084 *>           upper triangular part of the array A must contain the upper
00085 *>           triangular part of the symmetric matrix and the strictly
00086 *>           lower triangular part of A is not referenced.
00087 *>           Before entry, with UPLO = 'L' or 'l', the leading n by n
00088 *>           lower triangular part of the array A must contain the lower
00089 *>           triangular part of the symmetric matrix and the strictly
00090 *>           upper triangular part of A is not referenced.
00091 *>           Unchanged on exit.
00092 *> \endverbatim
00093 *>
00094 *> \param[in] LDA
00095 *> \verbatim
00096 *>          LDA is INTEGER
00097 *>           On entry, LDA specifies the first dimension of A as declared
00098 *>           in the calling (sub) program. LDA must be at least
00099 *>           max( 1, N ).
00100 *>           Unchanged on exit.
00101 *> \endverbatim
00102 *>
00103 *> \param[in] X
00104 *> \verbatim
00105 *>          X is COMPLEX*16 array, dimension at least
00106 *>           ( 1 + ( N - 1 )*abs( INCX ) ).
00107 *>           Before entry, the incremented array X must contain the N-
00108 *>           element vector x.
00109 *>           Unchanged on exit.
00110 *> \endverbatim
00111 *>
00112 *> \param[in] INCX
00113 *> \verbatim
00114 *>          INCX is INTEGER
00115 *>           On entry, INCX specifies the increment for the elements of
00116 *>           X. INCX must not be zero.
00117 *>           Unchanged on exit.
00118 *> \endverbatim
00119 *>
00120 *> \param[in] BETA
00121 *> \verbatim
00122 *>          BETA is COMPLEX*16
00123 *>           On entry, BETA specifies the scalar beta. When BETA is
00124 *>           supplied as zero then Y need not be set on input.
00125 *>           Unchanged on exit.
00126 *> \endverbatim
00127 *>
00128 *> \param[in,out] Y
00129 *> \verbatim
00130 *>          Y is COMPLEX*16 array, dimension at least
00131 *>           ( 1 + ( N - 1 )*abs( INCY ) ).
00132 *>           Before entry, the incremented array Y must contain the n
00133 *>           element vector y. On exit, Y is overwritten by the updated
00134 *>           vector y.
00135 *> \endverbatim
00136 *>
00137 *> \param[in] INCY
00138 *> \verbatim
00139 *>          INCY is INTEGER
00140 *>           On entry, INCY specifies the increment for the elements of
00141 *>           Y. INCY must not be zero.
00142 *>           Unchanged on exit.
00143 *> \endverbatim
00144 *
00145 *  Authors:
00146 *  ========
00147 *
00148 *> \author Univ. of Tennessee 
00149 *> \author Univ. of California Berkeley 
00150 *> \author Univ. of Colorado Denver 
00151 *> \author NAG Ltd. 
00152 *
00153 *> \date November 2011
00154 *
00155 *> \ingroup complex16SYauxiliary
00156 *
00157 *  =====================================================================
00158       SUBROUTINE ZSYMV( UPLO, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY )
00159 *
00160 *  -- LAPACK auxiliary routine (version 3.4.0) --
00161 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00162 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00163 *     November 2011
00164 *
00165 *     .. Scalar Arguments ..
00166       CHARACTER          UPLO
00167       INTEGER            INCX, INCY, LDA, N
00168       COMPLEX*16         ALPHA, BETA
00169 *     ..
00170 *     .. Array Arguments ..
00171       COMPLEX*16         A( LDA, * ), X( * ), Y( * )
00172 *     ..
00173 *
00174 * =====================================================================
00175 *
00176 *     .. Parameters ..
00177       COMPLEX*16         ONE
00178       PARAMETER          ( ONE = ( 1.0D+0, 0.0D+0 ) )
00179       COMPLEX*16         ZERO
00180       PARAMETER          ( ZERO = ( 0.0D+0, 0.0D+0 ) )
00181 *     ..
00182 *     .. Local Scalars ..
00183       INTEGER            I, INFO, IX, IY, J, JX, JY, KX, KY
00184       COMPLEX*16         TEMP1, TEMP2
00185 *     ..
00186 *     .. External Functions ..
00187       LOGICAL            LSAME
00188       EXTERNAL           LSAME
00189 *     ..
00190 *     .. External Subroutines ..
00191       EXTERNAL           XERBLA
00192 *     ..
00193 *     .. Intrinsic Functions ..
00194       INTRINSIC          MAX
00195 *     ..
00196 *     .. Executable Statements ..
00197 *
00198 *     Test the input parameters.
00199 *
00200       INFO = 0
00201       IF( .NOT.LSAME( UPLO, 'U' ) .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
00202          INFO = 1
00203       ELSE IF( N.LT.0 ) THEN
00204          INFO = 2
00205       ELSE IF( LDA.LT.MAX( 1, N ) ) THEN
00206          INFO = 5
00207       ELSE IF( INCX.EQ.0 ) THEN
00208          INFO = 7
00209       ELSE IF( INCY.EQ.0 ) THEN
00210          INFO = 10
00211       END IF
00212       IF( INFO.NE.0 ) THEN
00213          CALL XERBLA( 'ZSYMV ', INFO )
00214          RETURN
00215       END IF
00216 *
00217 *     Quick return if possible.
00218 *
00219       IF( ( N.EQ.0 ) .OR. ( ( ALPHA.EQ.ZERO ) .AND. ( BETA.EQ.ONE ) ) )
00220      $   RETURN
00221 *
00222 *     Set up the start points in  X  and  Y.
00223 *
00224       IF( INCX.GT.0 ) THEN
00225          KX = 1
00226       ELSE
00227          KX = 1 - ( N-1 )*INCX
00228       END IF
00229       IF( INCY.GT.0 ) THEN
00230          KY = 1
00231       ELSE
00232          KY = 1 - ( N-1 )*INCY
00233       END IF
00234 *
00235 *     Start the operations. In this version the elements of A are
00236 *     accessed sequentially with one pass through the triangular part
00237 *     of A.
00238 *
00239 *     First form  y := beta*y.
00240 *
00241       IF( BETA.NE.ONE ) THEN
00242          IF( INCY.EQ.1 ) THEN
00243             IF( BETA.EQ.ZERO ) THEN
00244                DO 10 I = 1, N
00245                   Y( I ) = ZERO
00246    10          CONTINUE
00247             ELSE
00248                DO 20 I = 1, N
00249                   Y( I ) = BETA*Y( I )
00250    20          CONTINUE
00251             END IF
00252          ELSE
00253             IY = KY
00254             IF( BETA.EQ.ZERO ) THEN
00255                DO 30 I = 1, N
00256                   Y( IY ) = ZERO
00257                   IY = IY + INCY
00258    30          CONTINUE
00259             ELSE
00260                DO 40 I = 1, N
00261                   Y( IY ) = BETA*Y( IY )
00262                   IY = IY + INCY
00263    40          CONTINUE
00264             END IF
00265          END IF
00266       END IF
00267       IF( ALPHA.EQ.ZERO )
00268      $   RETURN
00269       IF( LSAME( UPLO, 'U' ) ) THEN
00270 *
00271 *        Form  y  when A is stored in upper triangle.
00272 *
00273          IF( ( INCX.EQ.1 ) .AND. ( INCY.EQ.1 ) ) THEN
00274             DO 60 J = 1, N
00275                TEMP1 = ALPHA*X( J )
00276                TEMP2 = ZERO
00277                DO 50 I = 1, J - 1
00278                   Y( I ) = Y( I ) + TEMP1*A( I, J )
00279                   TEMP2 = TEMP2 + A( I, J )*X( I )
00280    50          CONTINUE
00281                Y( J ) = Y( J ) + TEMP1*A( J, J ) + ALPHA*TEMP2
00282    60       CONTINUE
00283          ELSE
00284             JX = KX
00285             JY = KY
00286             DO 80 J = 1, N
00287                TEMP1 = ALPHA*X( JX )
00288                TEMP2 = ZERO
00289                IX = KX
00290                IY = KY
00291                DO 70 I = 1, J - 1
00292                   Y( IY ) = Y( IY ) + TEMP1*A( I, J )
00293                   TEMP2 = TEMP2 + A( I, J )*X( IX )
00294                   IX = IX + INCX
00295                   IY = IY + INCY
00296    70          CONTINUE
00297                Y( JY ) = Y( JY ) + TEMP1*A( J, J ) + ALPHA*TEMP2
00298                JX = JX + INCX
00299                JY = JY + INCY
00300    80       CONTINUE
00301          END IF
00302       ELSE
00303 *
00304 *        Form  y  when A is stored in lower triangle.
00305 *
00306          IF( ( INCX.EQ.1 ) .AND. ( INCY.EQ.1 ) ) THEN
00307             DO 100 J = 1, N
00308                TEMP1 = ALPHA*X( J )
00309                TEMP2 = ZERO
00310                Y( J ) = Y( J ) + TEMP1*A( J, J )
00311                DO 90 I = J + 1, N
00312                   Y( I ) = Y( I ) + TEMP1*A( I, J )
00313                   TEMP2 = TEMP2 + A( I, J )*X( I )
00314    90          CONTINUE
00315                Y( J ) = Y( J ) + ALPHA*TEMP2
00316   100       CONTINUE
00317          ELSE
00318             JX = KX
00319             JY = KY
00320             DO 120 J = 1, N
00321                TEMP1 = ALPHA*X( JX )
00322                TEMP2 = ZERO
00323                Y( JY ) = Y( JY ) + TEMP1*A( J, J )
00324                IX = JX
00325                IY = JY
00326                DO 110 I = J + 1, N
00327                   IX = IX + INCX
00328                   IY = IY + INCY
00329                   Y( IY ) = Y( IY ) + TEMP1*A( I, J )
00330                   TEMP2 = TEMP2 + A( I, J )*X( IX )
00331   110          CONTINUE
00332                Y( JY ) = Y( JY ) + ALPHA*TEMP2
00333                JX = JX + INCX
00334                JY = JY + INCY
00335   120       CONTINUE
00336          END IF
00337       END IF
00338 *
00339       RETURN
00340 *
00341 *     End of ZSYMV
00342 *
00343       END
 All Files Functions