Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES
SUMMARY:  INNER | FIELD | CONSTR | METHOD DETAIL:  FIELD | CONSTR | METHOD

drasys.or.linear.blas
Class BLAS2

java.lang.Object
  |
  +--drasys.or.linear.blas.BLAS2
public class BLAS2
extends java.lang.Object
implements BLAS2I

Serial implementation of the BLAS2. See BLAS2I for more details.

Constructor Summary
BLAS2()
           
 
Method Summary
 void cgemv(int m, int n, ComplexI alpha, float[] A, int begA, int incAi, int incAj, float[] x, int begx, int incx, ComplexI beta, float[] y, int begy, int incy)
          Computes: y = alpha*A*x + beta*y.
 void cgerc(int m, int n, ComplexI alpha, float[] x, int begx, int incx, float[] y, int begy, int incy, float[] A, int begA, int incAi, int incAj)
          Computes: A = alpha*x*y' + A.
 void cgeru(int m, int n, ComplexI alpha, float[] x, int begx, int incx, float[] y, int begy, int incy, float[] A, int begA, int incAi, int incAj)
          Computes: A = alpha*x*y' + A.
 void dgemv(int m, int n, double alpha, double[] A, int begA, int incAi, int incAj, double[] x, int begx, int incx, double beta, double[] y, int begy, int incy)
          Computes: y = alpha*A*x + beta*y.
 void dger(int m, int n, double alpha, double[] x, int begx, int incx, double[] y, int begy, int incy, double[] A, int begA, int incAi, int incAj)
          Computes: A = alpha*x*y' + A.
 void sgemv(int m, int n, float alpha, float[] A, int begA, int incAi, int incAj, float[] x, int begx, int incx, float beta, float[] y, int begy, int incy)
          Computes: y = alpha*A*x + beta*y.
 void sger(int m, int n, float alpha, float[] x, int begx, int incx, float[] y, int begy, int incy, float[] A, int begA, int incAi, int incAj)
          Computes: A = alpha*x*y' + A.
 void zgemv(int m, int n, ComplexI alpha, double[] A, int begA, int incAi, int incAj, double[] x, int begx, int incx, ComplexI beta, double[] y, int begy, int incy)
          Computes: y = alpha*A*x + beta*y.
 void zgerc(int m, int n, ComplexI alpha, double[] x, int begx, int incx, double[] y, int begy, int incy, double[] A, int begA, int incAi, int incAj)
          Computes: A = alpha*x*y' + A.
 void zgeru(int m, int n, ComplexI alpha, double[] x, int begx, int incx, double[] y, int begy, int incy, double[] A, int begA, int incAi, int incAj)
          Computes: A = alpha*x*y' + A.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

BLAS2

public BLAS2()
Method Detail

dgemv

public void dgemv(int m,
                  int n,
                  double alpha,
                  double[] A,
                  int begA,
                  int incAi,
                  int incAj,
                  double[] x,
                  int begx,
                  int incx,
                  double beta,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException
Computes: y = alpha*A*x + beta*y. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
dgemv in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
beta - constant scaler
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements

dger

public void dger(int m,
                 int n,
                 double alpha,
                 double[] x,
                 int begx,
                 int incx,
                 double[] y,
                 int begy,
                 int incy,
                 double[] A,
                 int begA,
                 int incAi,
                 int incAj)
          throws BlasException
Computes: A = alpha*x*y' + A. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
dger in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'

sgemv

public void sgemv(int m,
                  int n,
                  float alpha,
                  float[] A,
                  int begA,
                  int incAi,
                  int incAj,
                  float[] x,
                  int begx,
                  int incx,
                  float beta,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException
Computes: y = alpha*A*x + beta*y. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
sgemv in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
beta - constant scaler
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements

sger

public void sger(int m,
                 int n,
                 float alpha,
                 float[] x,
                 int begx,
                 int incx,
                 float[] y,
                 int begy,
                 int incy,
                 float[] A,
                 int begA,
                 int incAi,
                 int incAj)
          throws BlasException
Computes: A = alpha*x*y' + A. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
sger in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'

zgemv

public void zgemv(int m,
                  int n,
                  ComplexI alpha,
                  double[] A,
                  int begA,
                  int incAi,
                  int incAj,
                  double[] x,
                  int begx,
                  int incx,
                  ComplexI beta,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException
Computes: y = alpha*A*x + beta*y. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
zgemv in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
beta - constant scaler
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements

zgeru

public void zgeru(int m,
                  int n,
                  ComplexI alpha,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy,
                  double[] A,
                  int begA,
                  int incAi,
                  int incAj)
           throws BlasException
Computes: A = alpha*x*y' + A. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
zgeru in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'

zgerc

public void zgerc(int m,
                  int n,
                  ComplexI alpha,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy,
                  double[] A,
                  int begA,
                  int incAi,
                  int incAj)
           throws BlasException
Computes: A = alpha*x*y' + A. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
zgerc in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'

cgemv

public void cgemv(int m,
                  int n,
                  ComplexI alpha,
                  float[] A,
                  int begA,
                  int incAi,
                  int incAj,
                  float[] x,
                  int begx,
                  int incx,
                  ComplexI beta,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException
Computes: y = alpha*A*x + beta*y. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
cgemv in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
beta - constant scaler
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements

cgeru

public void cgeru(int m,
                  int n,
                  ComplexI alpha,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy,
                  float[] A,
                  int begA,
                  int incAi,
                  int incAj)
           throws BlasException
Computes: A = alpha*x*y' + A. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
cgeru in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'

cgerc

public void cgerc(int m,
                  int n,
                  ComplexI alpha,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy,
                  float[] A,
                  int begA,
                  int incAi,
                  int incAj)
           throws BlasException
Computes: A = alpha*x*y' + A. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'.
Specified by:
cgerc in interface BLAS2I
Parameters:
m - number of rows in 'A'
n - number of columns in 'A'
alpha - constant scaler
x - array containing the 'x' vector elements
begx - offset of the first 'x' vector element
incx - the distance between 'x' vector elements
y - array containing the 'y' vector elements
begy - offset of the first 'y' vector element
incy - the distance between 'y' vector elements
A - the matrix 'A' in contiguous format
begA - offset of the first element of 'A'
incAi - row increment for matrix 'A'
incAj - column increment for matrix 'A'
Overview  Package   Class  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES
SUMMARY:  INNER | FIELD | CONSTR | METHOD DETAIL:  FIELD | CONSTR | METHOD
Copyright(C)1997-2000 by DRA Systems all rights reserved. OpsResearch.com