1       SUBROUTINE SLAPTM( N, NRHS, ALPHA, D, E, X, LDX, BETA, B, LDB )
  2 *
  3 *  -- LAPACK auxiliary routine (version 3.1) --
  4 *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
  5 *     November 2006
  6 *
  7 *     .. Scalar Arguments ..
  8       INTEGER            LDB, LDX, N, NRHS
  9       REAL               ALPHA, BETA
 10 *     ..
 11 *     .. Array Arguments ..
 12       REAL               B( LDB, * ), D( * ), E( * ), X( LDX, * )
 13 *     ..
 14 *
 15 *  Purpose
 16 *  =======
 17 *
 18 *  SLAPTM multiplies an N by NRHS matrix X by a symmetric tridiagonal
 19 *  matrix A and stores the result in a matrix B.  The operation has the
 20 *  form
 21 *
 22 *     B := alpha * A * X + beta * B
 23 *
 24 *  where alpha may be either 1. or -1. and beta may be 0., 1., or -1.
 25 *
 26 *  Arguments
 27 *  =========
 28 *
 29 *  N       (input) INTEGER
 30 *          The order of the matrix A.  N >= 0.
 31 *
 32 *  NRHS    (input) INTEGER
 33 *          The number of right hand sides, i.e., the number of columns
 34 *          of the matrices X and B.
 35 *
 36 *  ALPHA   (input) REAL
 37 *          The scalar alpha.  ALPHA must be 1. or -1.; otherwise,
 38 *          it is assumed to be 0.
 39 *
 40 *  D       (input) REAL array, dimension (N)
 41 *          The n diagonal elements of the tridiagonal matrix A.
 42 *
 43 *  E       (input) REAL array, dimension (N-1)
 44 *          The (n-1) subdiagonal or superdiagonal elements of A.
 45 *
 46 *  X       (input) REAL array, dimension (LDX,NRHS)
 47 *          The N by NRHS matrix X.
 48 *
 49 *  LDX     (input) INTEGER
 50 *          The leading dimension of the array X.  LDX >= max(N,1).
 51 *
 52 *  BETA    (input) REAL
 53 *          The scalar beta.  BETA must be 0., 1., or -1.; otherwise,
 54 *          it is assumed to be 1.
 55 *
 56 *  B       (input/output) REAL array, dimension (LDB,NRHS)
 57 *          On entry, the N by NRHS matrix B.
 58 *          On exit, B is overwritten by the matrix expression
 59 *          B := alpha * A * X + beta * B.
 60 *
 61 *  LDB     (input) INTEGER
 62 *          The leading dimension of the array B.  LDB >= max(N,1).
 63 *
 64 *  =====================================================================
 65 *
 66 *     .. Parameters ..
 67       REAL               ONE, ZERO
 68       PARAMETER          ( ONE = 1.0E+0, ZERO = 0.0E+0 )
 69 *     ..
 70 *     .. Local Scalars ..
 71       INTEGER            I, J
 72 *     ..
 73 *     .. Executable Statements ..
 74 *
 75       IF( N.EQ.0 )
 76      $   RETURN
 77 *
 78 *     Multiply B by BETA if BETA.NE.1.
 79 *
 80       IF( BETA.EQ.ZERO ) THEN
 81          DO 20 J = 1, NRHS
 82             DO 10 I = 1, N
 83                B( I, J ) = ZERO
 84    10       CONTINUE
 85    20    CONTINUE
 86       ELSE IF( BETA.EQ.-ONE ) THEN
 87          DO 40 J = 1, NRHS
 88             DO 30 I = 1, N
 89                B( I, J ) = -B( I, J )
 90    30       CONTINUE
 91    40    CONTINUE
 92       END IF
 93 *
 94       IF( ALPHA.EQ.ONE ) THEN
 95 *
 96 *        Compute B := B + A*X
 97 *
 98          DO 60 J = 1, NRHS
 99             IF( N.EQ.1 ) THEN
100                B( 1, J ) = B( 1, J ) + D( 1 )*X( 1, J )
101             ELSE
102                B( 1, J ) = B( 1, J ) + D( 1 )*X( 1, J ) +
103      $                     E( 1 )*X( 2, J )
104                B( N, J ) = B( N, J ) + E( N-1 )*X( N-1, J ) +
105      $                     D( N )*X( N, J )
106                DO 50 I = 2, N - 1
107                   B( I, J ) = B( I, J ) + E( I-1 )*X( I-1, J ) +
108      $                        D( I )*X( I, J ) + E( I )*X( I+1, J )
109    50          CONTINUE
110             END IF
111    60    CONTINUE
112       ELSE IF( ALPHA.EQ.-ONE ) THEN
113 *
114 *        Compute B := B - A*X
115 *
116          DO 80 J = 1, NRHS
117             IF( N.EQ.1 ) THEN
118                B( 1, J ) = B( 1, J ) - D( 1 )*X( 1, J )
119             ELSE
120                B( 1, J ) = B( 1, J ) - D( 1 )*X( 1, J ) -
121      $                     E( 1 )*X( 2, J )
122                B( N, J ) = B( N, J ) - E( N-1 )*X( N-1, J ) -
123      $                     D( N )*X( N, J )
124                DO 70 I = 2, N - 1
125                   B( I, J ) = B( I, J ) - E( I-1 )*X( I-1, J ) -
126      $                        D( I )*X( I, J ) - E( I )*X( I+1, J )
127    70          CONTINUE
128             END IF
129    80    CONTINUE
130       END IF
131       RETURN
132 *
133 *     End of SLAPTM
134 *
135       END