| //Translated by Jose Antonio De Santiago-Castillo. | |
| //E-mail:JAntonioDeSantiago@gmail.com | |
| //Website: www.DotNumerics.com | |
| // | |
| //Fortran to C# Translation. | |
| //Translated by: | |
| //F2CSharp Version 0.72 (Dicember 7, 2009) | |
| //Code Optimizations: , assignment operator, for-loop: array indexes | |
| // | |
| using System; | |
| using DotNumerics.FortranLibrary; | |
| namespace DotNumerics.LinearAlgebra.CSLapack | |
| { | |
| /// <summary> | |
| /// Purpose | |
| /// ======= | |
| /// | |
| /// DGEMV performs one of the matrix-vector operations | |
| /// | |
| /// y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y, | |
| /// | |
| /// where alpha and beta are scalars, x and y are vectors and A is an | |
| /// m by n matrix. | |
| /// | |
| /// Parameters | |
| /// ========== | |
| /// | |
| /// TRANS - CHARACTER*1. | |
| /// On entry, TRANS specifies the operation to be performed as | |
| /// follows: | |
| /// | |
| /// TRANS = 'N' or 'n' y := alpha*A*x + beta*y. | |
| /// | |
| /// TRANS = 'T' or 't' y := alpha*A'*x + beta*y. | |
| /// | |
| /// TRANS = 'C' or 'c' y := alpha*A'*x + beta*y. | |
| /// | |
| /// Unchanged on exit. | |
| /// | |
| /// M - INTEGER. | |
| /// On entry, M specifies the number of rows of the matrix A. | |
| /// M must be at least zero. | |
| /// Unchanged on exit. | |
| /// | |
| /// N - INTEGER. | |
| /// On entry, N specifies the number of columns of the matrix A. | |
| /// N must be at least zero. | |
| /// Unchanged on exit. | |
| /// | |
| /// ALPHA - DOUBLE PRECISION. | |
| /// On entry, ALPHA specifies the scalar alpha. | |
| /// Unchanged on exit. | |
| /// | |
| /// A - DOUBLE PRECISION array of DIMENSION ( LDA, n ). | |
| /// Before entry, the leading m by n part of the array A must | |
| /// contain the matrix of coefficients. | |
| /// Unchanged on exit. | |
| /// | |
| /// LDA - INTEGER. | |
| /// On entry, LDA specifies the first dimension of A as declared | |
| /// in the calling (sub) program. LDA must be at least | |
| /// max( 1, m ). | |
| /// Unchanged on exit. | |
| /// | |
| /// X - DOUBLE PRECISION array of DIMENSION at least | |
| /// ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' | |
| /// and at least | |
| /// ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. | |
| /// Before entry, the incremented array X must contain the | |
| /// vector x. | |
| /// Unchanged on exit. | |
| /// | |
| /// INCX - INTEGER. | |
| /// On entry, INCX specifies the increment for the elements of | |
| /// X. INCX must not be zero. | |
| /// Unchanged on exit. | |
| /// | |
| /// BETA - DOUBLE PRECISION. | |
| /// On entry, BETA specifies the scalar beta. When BETA is | |
| /// supplied as zero then Y need not be set on input. | |
| /// Unchanged on exit. | |
| /// | |
| /// Y - DOUBLE PRECISION array of DIMENSION at least | |
| /// ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n' | |
| /// and at least | |
| /// ( 1 + ( n - 1 )*abs( INCY ) ) otherwise. | |
| /// Before entry with BETA non-zero, the incremented array Y | |
| /// must contain the vector y. On exit, Y is overwritten by the | |
| /// updated vector y. | |
| /// | |
| /// INCY - INTEGER. | |
| /// On entry, INCY specifies the increment for the elements of | |
| /// Y. INCY must not be zero. | |
| /// Unchanged on exit. | |
| ///</summary> | |
| public class DGEMV | |
| { | |
| LSAME _lsame; XERBLA _xerbla; | |
| const double ONE = 1.0E+0; const double ZERO = 0.0E+0; | |
| public DGEMV(LSAME lsame, XERBLA xerbla) | |
| { | |
| this._lsame = lsame; this._xerbla = xerbla; | |
| } | |
| public DGEMV() | |
| { | |
| LSAME lsame = new LSAME(); | |
| XERBLA xerbla = new XERBLA(); | |
| this._lsame = lsame; this._xerbla = xerbla; | |
| } | |
| /// <summary> | |
| /// Purpose | |
| /// ======= | |
| /// | |
| /// DGEMV performs one of the matrix-vector operations | |
| /// | |
| /// y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y, | |
| /// | |
| /// where alpha and beta are scalars, x and y are vectors and A is an | |
| /// m by n matrix. | |
| /// | |
| /// Parameters | |
| /// ========== | |
| /// | |
| /// TRANS - CHARACTER*1. | |
| /// On entry, TRANS specifies the operation to be performed as | |
| /// follows: | |
| /// | |
| /// TRANS = 'N' or 'n' y := alpha*A*x + beta*y. | |
| /// | |
| /// TRANS = 'T' or 't' y := alpha*A'*x + beta*y. | |
| /// | |
| /// TRANS = 'C' or 'c' y := alpha*A'*x + beta*y. | |
| /// | |
| /// Unchanged on exit. | |
| /// | |
| /// M - INTEGER. | |
| /// On entry, M specifies the number of rows of the matrix A. | |
| /// M must be at least zero. | |
| /// Unchanged on exit. | |
| /// | |
| /// N - INTEGER. | |
| /// On entry, N specifies the number of columns of the matrix A. | |
| /// N must be at least zero. | |
| /// Unchanged on exit. | |
| /// | |
| /// ALPHA - DOUBLE PRECISION. | |
| /// On entry, ALPHA specifies the scalar alpha. | |
| /// Unchanged on exit. | |
| /// | |
| /// A - DOUBLE PRECISION array of DIMENSION ( LDA, n ). | |
| /// Before entry, the leading m by n part of the array A must | |
| /// contain the matrix of coefficients. | |
| /// Unchanged on exit. | |
| /// | |
| /// LDA - INTEGER. | |
| /// On entry, LDA specifies the first dimension of A as declared | |
| /// in the calling (sub) program. LDA must be at least | |
| /// max( 1, m ). | |
| /// Unchanged on exit. | |
| /// | |
| /// X - DOUBLE PRECISION array of DIMENSION at least | |
| /// ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' | |
| /// and at least | |
| /// ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. | |
| /// Before entry, the incremented array X must contain the | |
| /// vector x. | |
| /// Unchanged on exit. | |
| /// | |
| /// INCX - INTEGER. | |
| /// On entry, INCX specifies the increment for the elements of | |
| /// X. INCX must not be zero. | |
| /// Unchanged on exit. | |
| /// | |
| /// BETA - DOUBLE PRECISION. | |
| /// On entry, BETA specifies the scalar beta. When BETA is | |
| /// supplied as zero then Y need not be set on input. | |
| /// Unchanged on exit. | |
| /// | |
| /// Y - DOUBLE PRECISION array of DIMENSION at least | |
| /// ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n' | |
| /// and at least | |
| /// ( 1 + ( n - 1 )*abs( INCY ) ) otherwise. | |
| /// Before entry with BETA non-zero, the incremented array Y | |
| /// must contain the vector y. On exit, Y is overwritten by the | |
| /// updated vector y. | |
| /// | |
| /// INCY - INTEGER. | |
| /// On entry, INCY specifies the increment for the elements of | |
| /// Y. INCY must not be zero. | |
| /// Unchanged on exit. | |
| ///</summary> | |
| /// <param name="TRANS"> | |
| /// - CHARACTER*1. | |
| /// On entry, TRANS specifies the operation to be performed as | |
| /// follows: | |
| /// | |
| /// TRANS = 'N' or 'n' y := alpha*A*x + beta*y. | |
| /// | |
| /// TRANS = 'T' or 't' y := alpha*A'*x + beta*y. | |
| /// | |
| /// TRANS = 'C' or 'c' y := alpha*A'*x + beta*y. | |
| /// | |
| /// Unchanged on exit. | |
| ///</param> | |
| /// <param name="M"> | |
| /// - INTEGER. | |
| /// On entry, M specifies the number of rows of the matrix A. | |
| /// M must be at least zero. | |
| /// Unchanged on exit. | |
| ///</param> | |
| /// <param name="N"> | |
| /// - INTEGER. | |
| /// On entry, N specifies the number of columns of the matrix A. | |
| /// N must be at least zero. | |
| /// Unchanged on exit. | |
| ///</param> | |
| /// <param name="ALPHA"> | |
| /// - DOUBLE PRECISION. | |
| /// On entry, ALPHA specifies the scalar alpha. | |
| /// Unchanged on exit. | |
| ///</param> | |
| /// <param name="A"> | |
| /// - DOUBLE PRECISION array of DIMENSION ( LDA, n ). | |
| /// Before entry, the leading m by n part of the array A must | |
| /// contain the matrix of coefficients. | |
| /// Unchanged on exit. | |
| ///</param> | |
| /// <param name="LDA"> | |
| /// - INTEGER. | |
| /// On entry, LDA specifies the first dimension of A as declared | |
| /// in the calling (sub) program. LDA must be at least | |
| /// max( 1, m ). | |
| /// Unchanged on exit. | |
| ///</param> | |
| /// <param name="X"> | |
| /// - DOUBLE PRECISION array of DIMENSION at least | |
| /// ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' | |
| /// and at least | |
| /// ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. | |
| /// Before entry, the incremented array X must contain the | |
| /// vector x. | |
| /// Unchanged on exit. | |
| ///</param> | |
| /// <param name="INCX"> | |
| /// - INTEGER. | |
| /// On entry, INCX specifies the increment for the elements of | |
| /// X. INCX must not be zero. | |
| /// Unchanged on exit. | |
| ///</param> | |
| /// <param name="BETA"> | |
| /// - DOUBLE PRECISION. | |
| /// On entry, BETA specifies the scalar beta. When BETA is | |
| /// supplied as zero then Y need not be set on input. | |
| /// Unchanged on exit. | |
| ///</param> | |
| /// <param name="Y"> | |
| /// := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y, | |
| ///</param> | |
| /// <param name="INCY"> | |
| /// - INTEGER. | |
| /// On entry, INCY specifies the increment for the elements of | |
| /// Y. INCY must not be zero. | |
| /// Unchanged on exit. | |
| /// | |
| ///</param> | |
| public void Run(string TRANS, int M, int N, double ALPHA, double[] A, int offset_a, int LDA | |
| , double[] X, int offset_x, int INCX, double BETA, ref double[] Y, int offset_y, int INCY) | |
| { | |
| double TEMP = 0; int I = 0; int INFO = 0; int IX = 0; int IY = 0; int J = 0; int JX = 0; int JY = 0; int KX = 0; | |
| int KY = 0;int LENX = 0; int LENY = 0; | |
| int A_J = 0; | |
| int o_a = -1 - LDA + offset_a; int o_x = -1 + offset_x; int o_y = -1 + offset_y; | |
| TRANS = TRANS.Substring(0, 1); | |
| // * .. Scalar Arguments .. | |
| // * .. Array Arguments .. | |
| // * .. | |
| // * | |
| // * Purpose | |
| // * ======= | |
| // * | |
| // * DGEMV performs one of the matrix-vector operations | |
| // * | |
| // * y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y, | |
| // * | |
| // * where alpha and beta are scalars, x and y are vectors and A is an | |
| // * m by n matrix. | |
| // * | |
| // * Parameters | |
| // * ========== | |
| // * | |
| // * TRANS - CHARACTER*1. | |
| // * On entry, TRANS specifies the operation to be performed as | |
| // * follows: | |
| // * | |
| // * TRANS = 'N' or 'n' y := alpha*A*x + beta*y. | |
| // * | |
| // * TRANS = 'T' or 't' y := alpha*A'*x + beta*y. | |
| // * | |
| // * TRANS = 'C' or 'c' y := alpha*A'*x + beta*y. | |
| // * | |
| // * Unchanged on exit. | |
| // * | |
| // * M - INTEGER. | |
| // * On entry, M specifies the number of rows of the matrix A. | |
| // * M must be at least zero. | |
| // * Unchanged on exit. | |
| // * | |
| // * N - INTEGER. | |
| // * On entry, N specifies the number of columns of the matrix A. | |
| // * N must be at least zero. | |
| // * Unchanged on exit. | |
| // * | |
| // * ALPHA - DOUBLE PRECISION. | |
| // * On entry, ALPHA specifies the scalar alpha. | |
| // * Unchanged on exit. | |
| // * | |
| // * A - DOUBLE PRECISION array of DIMENSION ( LDA, n ). | |
| // * Before entry, the leading m by n part of the array A must | |
| // * contain the matrix of coefficients. | |
| // * Unchanged on exit. | |
| // * | |
| // * LDA - INTEGER. | |
| // * On entry, LDA specifies the first dimension of A as declared | |
| // * in the calling (sub) program. LDA must be at least | |
| // * max( 1, m ). | |
| // * Unchanged on exit. | |
| // * | |
| // * X - DOUBLE PRECISION array of DIMENSION at least | |
| // * ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n' | |
| // * and at least | |
| // * ( 1 + ( m - 1 )*abs( INCX ) ) otherwise. | |
| // * Before entry, the incremented array X must contain the | |
| // * vector x. | |
| // * Unchanged on exit. | |
| // * | |
| // * INCX - INTEGER. | |
| // * On entry, INCX specifies the increment for the elements of | |
| // * X. INCX must not be zero. | |
| // * Unchanged on exit. | |
| // * | |
| // * BETA - DOUBLE PRECISION. | |
| // * On entry, BETA specifies the scalar beta. When BETA is | |
| // * supplied as zero then Y need not be set on input. | |
| // * Unchanged on exit. | |
| // * | |
| // * Y - DOUBLE PRECISION array of DIMENSION at least | |
| // * ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n' | |
| // * and at least | |
| // * ( 1 + ( n - 1 )*abs( INCY ) ) otherwise. | |
| // * Before entry with BETA non-zero, the incremented array Y | |
| // * must contain the vector y. On exit, Y is overwritten by the | |
| // * updated vector y. | |
| // * | |
| // * INCY - INTEGER. | |
| // * On entry, INCY specifies the increment for the elements of | |
| // * Y. INCY must not be zero. | |
| // * Unchanged on exit. | |
| // * | |
| // * | |
| // * Level 2 Blas routine. | |
| // * | |
| // * -- Written on 22-October-1986. | |
| // * Jack Dongarra, Argonne National Lab. | |
| // * Jeremy Du Croz, Nag Central Office. | |
| // * Sven Hammarling, Nag Central Office. | |
| // * Richard Hanson, Sandia National Labs. | |
| // * | |
| // * | |
| // * .. Parameters .. | |
| // * .. Local Scalars .. | |
| // * .. External Functions .. | |
| // * .. External Subroutines .. | |
| // * .. Intrinsic Functions .. | |
| // INTRINSIC MAX; | |
| // * .. | |
| // * .. Executable Statements .. | |
| // * | |
| // * Test the input parameters. | |
| // * | |
| INFO = 0; | |
| if (!this._lsame.Run(TRANS, "N") && !this._lsame.Run(TRANS, "T") && !this._lsame.Run(TRANS, "C")) | |
| { | |
| INFO = 1; | |
| } | |
| else | |
| { | |
| if (M < 0) | |
| { | |
| INFO = 2; | |
| } | |
| else | |
| { | |
| if (N < 0) | |
| { | |
| INFO = 3; | |
| } | |
| else | |
| { | |
| if (LDA < Math.Max(1, M)) | |
| { | |
| INFO = 6; | |
| } | |
| else | |
| { | |
| if (INCX == 0) | |
| { | |
| INFO = 8; | |
| } | |
| else | |
| { | |
| if (INCY == 0) | |
| { | |
| INFO = 11; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if (INFO != 0) | |
| { | |
| this._xerbla.Run("DGEMV ", INFO); | |
| return; | |
| } | |
| // * | |
| // * Quick return if possible. | |
| // * | |
| if ((M == 0) || (N == 0) || ((ALPHA == ZERO) && (BETA == ONE))) return; | |
| // * | |
| // * Set LENX and LENY, the lengths of the vectors x and y, and set | |
| // * up the start points in X and Y. | |
| // * | |
| if (this._lsame.Run(TRANS, "N")) | |
| { | |
| LENX = N; | |
| LENY = M; | |
| } | |
| else | |
| { | |
| LENX = M; | |
| LENY = N; | |
| } | |
| if (INCX > 0) | |
| { | |
| KX = 1; | |
| } | |
| else | |
| { | |
| KX = 1 - (LENX - 1) * INCX; | |
| } | |
| if (INCY > 0) | |
| { | |
| KY = 1; | |
| } | |
| else | |
| { | |
| KY = 1 - (LENY - 1) * INCY; | |
| } | |
| // * | |
| // * Start the operations. In this version the elements of A are | |
| // * accessed sequentially with one pass through A. | |
| // * | |
| // * First form y := beta*y. | |
| // * | |
| if (BETA != ONE) | |
| { | |
| if (INCY == 1) | |
| { | |
| if (BETA == ZERO) | |
| { | |
| for (I = 1; I <= LENY; I++) | |
| { | |
| Y[I + o_y] = ZERO; | |
| } | |
| } | |
| else | |
| { | |
| for (I = 1; I <= LENY; I++) | |
| { | |
| Y[I + o_y] *= BETA; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| IY = KY; | |
| if (BETA == ZERO) | |
| { | |
| for (I = 1; I <= LENY; I++) | |
| { | |
| Y[IY + o_y] = ZERO; | |
| IY += INCY; | |
| } | |
| } | |
| else | |
| { | |
| for (I = 1; I <= LENY; I++) | |
| { | |
| Y[IY + o_y] *= BETA; | |
| IY += INCY; | |
| } | |
| } | |
| } | |
| } | |
| if (ALPHA == ZERO) return; | |
| if (this._lsame.Run(TRANS, "N")) | |
| { | |
| // * | |
| // * Form y := alpha*A*x + y. | |
| // * | |
| JX = KX; | |
| if (INCY == 1) | |
| { | |
| for (J = 1; J <= N; J++) | |
| { | |
| if (X[JX + o_x] != ZERO) | |
| { | |
| TEMP = ALPHA * X[JX + o_x]; | |
| A_J = J * LDA + o_a; | |
| for (I = 1; I <= M; I++) | |
| { | |
| Y[I + o_y] += TEMP * A[I + A_J]; | |
| } | |
| } | |
| JX += INCX; | |
| } | |
| } | |
| else | |
| { | |
| for (J = 1; J <= N; J++) | |
| { | |
| if (X[JX + o_x] != ZERO) | |
| { | |
| TEMP = ALPHA * X[JX + o_x]; | |
| IY = KY; | |
| A_J = J * LDA + o_a; | |
| for (I = 1; I <= M; I++) | |
| { | |
| Y[IY + o_y] += TEMP * A[I + A_J]; | |
| IY += INCY; | |
| } | |
| } | |
| JX += INCX; | |
| } | |
| } | |
| } | |
| else | |
| { | |
| // * | |
| // * Form y := alpha*A'*x + y. | |
| // * | |
| JY = KY; | |
| if (INCX == 1) | |
| { | |
| for (J = 1; J <= N; J++) | |
| { | |
| TEMP = ZERO; | |
| A_J = J * LDA + o_a; | |
| for (I = 1; I <= M; I++) | |
| { | |
| TEMP += A[I + A_J] * X[I + o_x]; | |
| } | |
| Y[JY + o_y] += ALPHA * TEMP; | |
| JY += INCY; | |
| } | |
| } | |
| else | |
| { | |
| for (J = 1; J <= N; J++) | |
| { | |
| TEMP = ZERO; | |
| IX = KX; | |
| A_J = J * LDA + o_a; | |
| for (I = 1; I <= M; I++) | |
| { | |
| TEMP += A[I + A_J] * X[IX + o_x]; | |
| IX += INCX; | |
| } | |
| Y[JY + o_y] += ALPHA * TEMP; | |
| JY += INCY; | |
| } | |
| } | |
| } | |
| // * | |
| return; | |
| // * | |
| // * End of DGEMV . | |
| // * | |
| } | |
| } | |
| } | |