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 SmpBLAS1

java.lang.Object
  |
  +--drasys.or.linear.blas.SmpBLAS1
public class SmpBLAS1
extends java.lang.Object
implements BLAS1I

Parallel implementation of the BLAS1 for Java. 'BLAS1' operates on Java arrays and supports sub-vectors which allows it to work with both '0' and '1' based indexing. The arrays containing complex elements store each complex element in two adjacent array positions. The real component has the even index and the imaginary component has the next higher index. The 'beg*' and 'inc*' arguments to the complex methods specify the logical index of the complex element, these are multiplied by two internally to obtain the offset into the array.

See Also:
DenseVector, RowMajorMatrix, ColumnMajorMatrix, RowArrayMatrix, ColumnArrayMatrix, DenseVector, RowMajorMatrix,

References:

Parallel Algorithms for Matrix Computations
    K.A. Gallivan / Paperback / Published 1990
Linear Algebra and Its Applications
    Gilbert Strang / Hardcover / Published 1988
Matrix Computations (Johns Hopkins Studies in the Mathematical Sciences)
    Gene H. Golub, Charles F. Van Loan (Contributor) / Paperback / Published 1996

Constructor Summary
SmpBLAS1()
          Construct a default underlying serial BLAS implementation.
SmpBLAS1(BLAS1I blas1)
          Construct an explicit underlying serial BLAS implementation.
 
Method Summary
 void caxpy(int n, ComplexI alpha, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Constant times a vector plus a vector: y = y + alpha * x.
 void ccopy(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Copies vector x to vector y: y = x.
 Complex cdotc(int n, float[] x, int begx, int incx, float[] y, int begy, int incy, Complex results)
          Computes the dot product of two vectors: alpha = x (.) y.
 Complex cdotu(int n, float[] x, int begx, int incx, float[] y, int begy, int incy, Complex results)
          Computes the dot product of two vectors: alpha = x (.) y.
 void cscal(int n, ComplexI alpha, float[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.
 void csscal(int n, float alpha, float[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.
 void cswap(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Interchange two vectors: x <-> y.
 double dasum(int n, double[] x, int begx, int incx)
          Computes the sum of the absolute values.
 void daxpy(int n, double alpha, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Constant times a vector plus a vector: y = y + alpha * x.
 void dcopy(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Copies vector x to vector y: y = x.
 double ddot(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Computes the dot product of two vectors: alpha = x (.) y.
 double dnrm2(int n, double[] x, int begx, int incx)
          Computes the euclidean norm of the vector: sqrt(sum(xi^2))
 void drot(int n, double[] x, int begx, int incx, double[] y, int begy, int incy, double cos, double sin)
          Applies a plane rotation: x = cos*x + sin*y & y = cos*y + sin*x
 void drotg(Real a, Real b, Real cos, Real sin)
          Generates the parmseters cos and sin for a plane rotation.
 void dscal(int n, double alpha, double[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.
 double dsdot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Computes the dot product of two vectors: alpha = x (.) y.
 void dswap(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Interchange two vectors: x <-> y.
 double dzasum(int n, double[] x, int begx, int incx)
          Computes the sum of the absolute values.
 double dznrm2(int n, double[] x, int begx, int incx)
          Computes the euclidean norm of the vector: sqrt(sum(xi^2))
 Smp getSmp()
          Get the underlying Smp object.
 int icamax(int n, float[] x, int begx, int incx)
          Finds the index of the element with the maximum absolute value.
 int idamax(int n, double[] x, int begx, int incx)
          Finds the index of the element with the maximum absolute value.
 int isamax(int n, float[] x, int begx, int incx)
          Finds the index of the element with the maximum absolute value.
 int izamax(int n, double[] x, int begx, int incx)
          Finds the index of the element with the maximum absolute value.
 float sasum(int n, float[] x, int begx, int incx)
          Computes the sum of the absolute values.
 void saxpy(int n, float alpha, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Constant times a vector plus a vector: y = y + alpha * x.
 float scasum(int n, float[] x, int begx, int incx)
          Computes the sum of the absolute values.
 float scnrm2(int n, float[] x, int begx, int incx)
          Computes the euclidean norm of the vector: sqrt(sum(xi^2))
 void scopy(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Copies vector x to vector y: y = x.
 float sdot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Computes the dot product of two vectors: alpha = x (.) y.
 float sdsdot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Computes the dot product of two vectors: alpha = x (.) y.
 void setSmp(Smp smp)
          Set the underlying Smp object.
 float snrm2(int n, float[] x, int begx, int incx)
          Computes the euclidean norm of the vector: sqrt(sum(xi^2))
 void srot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy, float cos, float sin)
          Applies a plane rotation: x = cos*x + sin*y & y = cos*y + sin*x
 void srotg(Real a, Real b, Real cos, Real sin)
          Generates the parmseters cos and sin for a plane rotation.
 void sscal(int n, float alpha, float[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.
 void sswap(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Interchange two vectors: x <-> y.
 void zaxpy(int n, ComplexI alpha, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Constant times a vector plus a vector: y = y + alpha * x.
 void zcopy(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Copies vector x to vector y: y = x.
 Complex zdotc(int n, double[] x, int begx, int incx, double[] y, int begy, int incy, Complex results)
          Computes the dot product of two vectors: alpha = x (.) y.
 Complex zdotu(int n, double[] x, int begx, int incx, double[] y, int begy, int incy, Complex results)
          Computes the dot product of two vectors: alpha = x (.) y.
 void zdscal(int n, double alpha, double[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.
 void zscal(int n, ComplexI alpha, double[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.
 void zswap(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Interchange two vectors: x <-> y.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

SmpBLAS1

public SmpBLAS1()
Construct a default underlying serial BLAS implementation. The default minimum operations per thread is '100'.

SmpBLAS1

public SmpBLAS1(BLAS1I blas1)
Construct an explicit underlying serial BLAS implementation. The default minimum operations per thread is '100'.
Method Detail

getSmp

public Smp getSmp()
Get the underlying Smp object.

setSmp

public void setSmp(Smp smp)
Set the underlying Smp object.

dasum

public double dasum(int n,
                    double[] x,
                    int begx,
                    int incx)
             throws BlasException
Computes the sum of the absolute values.
Specified by:
dasum in interface BLAS1I
Parameters:
n - number of vector element
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

idamax

public int idamax(int n,
                  double[] x,
                  int begx,
                  int incx)
           throws BlasException
Finds the index of the element with the maximum absolute value.
Specified by:
idamax in interface BLAS1I
Parameters:
n - number of vector elements
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

izamax

public int izamax(int n,
                  double[] x,
                  int begx,
                  int incx)
           throws BlasException
Finds the index of the element with the maximum absolute value.
Specified by:
izamax in interface BLAS1I
Parameters:
n - number of vector elements
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

isamax

public int isamax(int n,
                  float[] x,
                  int begx,
                  int incx)
           throws BlasException
Finds the index of the element with the maximum absolute value.
Specified by:
isamax in interface BLAS1I
Parameters:
n - number of vector elements
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

icamax

public int icamax(int n,
                  float[] x,
                  int begx,
                  int incx)
           throws BlasException
Finds the index of the element with the maximum absolute value.
Specified by:
icamax in interface BLAS1I
Parameters:
n - number of vector elements
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

dzasum

public double dzasum(int n,
                     double[] x,
                     int begx,
                     int incx)
              throws BlasException
Computes the sum of the absolute values.
Specified by:
dzasum in interface BLAS1I
Parameters:
n - number of vector element
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

daxpy

public void daxpy(int n,
                  double alpha,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException
Constant times a vector plus a vector: y = y + alpha * x.
Specified by:
daxpy in interface BLAS1I
Parameters:
n - number of vector elements
alpha - constant multiplier of 'x'.
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

dcopy

public void dcopy(int n,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException
Copies vector x to vector y: y = x.
Specified by:
dcopy in interface BLAS1I
Parameters:
n - number of vector elements
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

drotg

public void drotg(Real a,
                  Real b,
                  Real cos,
                  Real sin)
           throws BlasException
Generates the parmseters cos and sin for a plane rotation.
Specified by:
drotg in interface BLAS1I
Parameters:
da -  
db -  
cos - cosine return value
sin - sine return value

srotg

public void srotg(Real a,
                  Real b,
                  Real cos,
                  Real sin)
           throws BlasException
Generates the parmseters cos and sin for a plane rotation.
Specified by:
srotg in interface BLAS1I
Parameters:
da -  
db -  
cos - cosine return value
sin - sine return value

ddot

public double ddot(int n,
                   double[] x,
                   int begx,
                   int incx,
                   double[] y,
                   int begy,
                   int incy)
            throws BlasException
Computes the dot product of two vectors: alpha = x (.) y.
Specified by:
ddot in interface BLAS1I
Parameters:
n - number of vector elements
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

drot

public void drot(int n,
                 double[] x,
                 int begx,
                 int incx,
                 double[] y,
                 int begy,
                 int incy,
                 double cos,
                 double sin)
          throws BlasException
Applies a plane rotation: x = cos*x + sin*y & y = cos*y + sin*x
Specified by:
drot in interface BLAS1I
Parameters:
n - number of vector elements
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
alpha - constant
beta - constant

dscal

public void dscal(int n,
                  double alpha,
                  double[] x,
                  int begx,
                  int incx)
           throws BlasException
Scale a vector by a constant: x = alpha * x.
Specified by:
dscal in interface BLAS1I
Parameters:
n - number of vector elements
alpha - scale factor
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

zdscal

public void zdscal(int n,
                   double alpha,
                   double[] x,
                   int begx,
                   int incx)
            throws BlasException
Scale a vector by a constant: x = alpha * x.
Specified by:
zdscal in interface BLAS1I
Parameters:
n - number of vector elements
alpha - scale factor
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

dswap

public void dswap(int n,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException
Interchange two vectors: x <-> y.
Specified by:
dswap in interface BLAS1I
Parameters:
n - number of vector elements
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

dnrm2

public double dnrm2(int n,
                    double[] x,
                    int begx,
                    int incx)
             throws BlasException
Computes the euclidean norm of the vector: sqrt(sum(xi^2))
Specified by:
dnrm2 in interface BLAS1I
Parameters:
n - number of vector elements
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

dznrm2

public double dznrm2(int n,
                     double[] x,
                     int begx,
                     int incx)
              throws BlasException
Computes the euclidean norm of the vector: sqrt(sum(xi^2))
Specified by:
dznrm2 in interface BLAS1I
Parameters:
n - number of vector elements
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

sasum

public float sasum(int n,
                   float[] x,
                   int begx,
                   int incx)
            throws BlasException
Computes the sum of the absolute values.
Specified by:
sasum in interface BLAS1I
Parameters:
n - number of vector element
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

scasum

public float scasum(int n,
                    float[] x,
                    int begx,
                    int incx)
             throws BlasException
Computes the sum of the absolute values.
Specified by:
scasum in interface BLAS1I
Parameters:
n - number of vector element
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

saxpy

public void saxpy(int n,
                  float alpha,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException
Constant times a vector plus a vector: y = y + alpha * x.
Specified by:
saxpy in interface BLAS1I
Parameters:
n - number of vector elements
alpha - constant multiplier of 'x'.
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

scopy

public void scopy(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException
Copies vector x to vector y: y = x.
Specified by:
scopy in interface BLAS1I
Parameters:
n - number of vector elements
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

sdot

public float sdot(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException
Computes the dot product of two vectors: alpha = x (.) y.
Specified by:
sdot in interface BLAS1I
Parameters:
n - number of vector elements
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

dsdot

public double dsdot(int n,
                    float[] x,
                    int begx,
                    int incx,
                    float[] y,
                    int begy,
                    int incy)
             throws BlasException
Computes the dot product of two vectors: alpha = x (.) y.
Specified by:
dsdot in interface BLAS1I
Parameters:
n - number of vector elements
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

sdsdot

public float sdsdot(int n,
                    float[] x,
                    int begx,
                    int incx,
                    float[] y,
                    int begy,
                    int incy)
             throws BlasException
Computes the dot product of two vectors: alpha = x (.) y.
Specified by:
sdsdot in interface BLAS1I
Parameters:
n - number of vector elements
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

srot

public void srot(int n,
                 float[] x,
                 int begx,
                 int incx,
                 float[] y,
                 int begy,
                 int incy,
                 float cos,
                 float sin)
          throws BlasException
Applies a plane rotation: x = cos*x + sin*y & y = cos*y + sin*x
Specified by:
srot in interface BLAS1I
Parameters:
n - number of vector elements
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
alpha - constant
beta - constant

sscal

public void sscal(int n,
                  float alpha,
                  float[] x,
                  int begx,
                  int incx)
           throws BlasException
Scale a vector by a constant: x = alpha * x.
Specified by:
sscal in interface BLAS1I
Parameters:
n - number of vector elements
alpha - scale factor
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

csscal

public void csscal(int n,
                   float alpha,
                   float[] x,
                   int begx,
                   int incx)
            throws BlasException
Scale a vector by a constant: x = alpha * x.
Specified by:
csscal in interface BLAS1I
Parameters:
n - number of vector elements
alpha - scale factor
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

sswap

public void sswap(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException
Interchange two vectors: x <-> y.
Specified by:
sswap in interface BLAS1I
Parameters:
n - number of vector elements
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

snrm2

public float snrm2(int n,
                   float[] x,
                   int begx,
                   int incx)
            throws BlasException
Computes the euclidean norm of the vector: sqrt(sum(xi^2))
Specified by:
snrm2 in interface BLAS1I
Parameters:
n - number of vector elements
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

scnrm2

public float scnrm2(int n,
                    float[] x,
                    int begx,
                    int incx)
             throws BlasException
Computes the euclidean norm of the vector: sqrt(sum(xi^2))
Specified by:
scnrm2 in interface BLAS1I
Parameters:
n - number of vector elements
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

zaxpy

public void zaxpy(int n,
                  ComplexI alpha,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException
Constant times a vector plus a vector: y = y + alpha * x.
Specified by:
zaxpy in interface BLAS1I
Parameters:
n - number of vector elements
alpha - constant multiplier of 'x'.
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

zcopy

public void zcopy(int n,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException
Copies vector x to vector y: y = x.
Specified by:
zcopy in interface BLAS1I
Parameters:
n - number of vector elements
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

zdotu

public Complex zdotu(int n,
                     double[] x,
                     int begx,
                     int incx,
                     double[] y,
                     int begy,
                     int incy,
                     Complex results)
              throws BlasException
Computes the dot product of two vectors: alpha = x (.) y.
Specified by:
zdotu in interface BLAS1I
Parameters:
n - number of vector elements
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

zdotc

public Complex zdotc(int n,
                     double[] x,
                     int begx,
                     int incx,
                     double[] y,
                     int begy,
                     int incy,
                     Complex results)
              throws BlasException
Computes the dot product of two vectors: alpha = x (.) y.
Specified by:
zdotc in interface BLAS1I
Parameters:
n - number of vector elements
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

zscal

public void zscal(int n,
                  ComplexI alpha,
                  double[] x,
                  int begx,
                  int incx)
           throws BlasException
Scale a vector by a constant: x = alpha * x.
Specified by:
zscal in interface BLAS1I
Parameters:
n - number of vector elements
alpha - scale factor
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

zswap

public void zswap(int n,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException
Interchange two vectors: x <-> y.
Specified by:
zswap in interface BLAS1I
Parameters:
n - number of vector elements
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

caxpy

public void caxpy(int n,
                  ComplexI alpha,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException
Constant times a vector plus a vector: y = y + alpha * x.
Specified by:
caxpy in interface BLAS1I
Parameters:
n - number of vector elements
alpha - constant multiplier of 'x'.
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

ccopy

public void ccopy(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException
Copies vector x to vector y: y = x.
Specified by:
ccopy in interface BLAS1I
Parameters:
n - number of vector elements
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

cdotu

public Complex cdotu(int n,
                     float[] x,
                     int begx,
                     int incx,
                     float[] y,
                     int begy,
                     int incy,
                     Complex results)
              throws BlasException
Computes the dot product of two vectors: alpha = x (.) y.
Specified by:
cdotu in interface BLAS1I
Parameters:
n - number of vector elements
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

cdotc

public Complex cdotc(int n,
                     float[] x,
                     int begx,
                     int incx,
                     float[] y,
                     int begy,
                     int incy,
                     Complex results)
              throws BlasException
Computes the dot product of two vectors: alpha = x (.) y.
Specified by:
cdotc in interface BLAS1I
Parameters:
n - number of vector elements
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

cscal

public void cscal(int n,
                  ComplexI alpha,
                  float[] x,
                  int begx,
                  int incx)
           throws BlasException
Scale a vector by a constant: x = alpha * x.
Specified by:
cscal in interface BLAS1I
Parameters:
n - number of vector elements
alpha - scale factor
x - array containing the vector elements
begx - offset of the first vector element
incx - the distance between vector elements

cswap

public void cswap(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException
Interchange two vectors: x <-> y.
Specified by:
cswap in interface BLAS1I
Parameters:
n - number of vector elements
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
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