cern.colt.matrix.linalg

## Class SeqBlas

- java.lang.Object
- - cern.colt.matrix.linalg.SeqBlas

All Implemented Interfaces:
  Blas

    public class SeqBlas
    extends java.lang.Object
    implements Blas

Sequential implementation of the Basic Linear Algebra System.

Version:
  0.9, 16/04/2000

### Field Summary

Fields
`static Blas` `seqBlas` Little trick to allow for "aliasing", that is, renaming this class.

### Method Summary

Methods
`void` `assign(DoubleMatrix2D A, DoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col])`.
`void` `assign(DoubleMatrix2D A, DoubleMatrix2D B, DoubleDoubleFunction function)` Assigns the result of a function to each cell; `x[row,col] = function(x[row,col],y[row,col])`.
`double` `dasum(DoubleMatrix1D x)` Returns the sum of absolute values; `|x[0]| + |x[1]| + ...`
`void` `daxpy(double alpha, DoubleMatrix1D x, DoubleMatrix1D y)` Combined vector scaling; `y = y + alpha*x`.
`void` `daxpy(double alpha, DoubleMatrix2D A, DoubleMatrix2D B)` Combined matrix scaling; `B = B + alpha*A`.
`void` `dcopy(DoubleMatrix1D x, DoubleMatrix1D y)` Vector assignment (copying); `y = x`.
`void` `dcopy(DoubleMatrix2D A, DoubleMatrix2D B)` Matrix assignment (copying); `B = A`.
`double` `ddot(DoubleMatrix1D x, DoubleMatrix1D y)` Returns the dot product of two vectors x and y, which is `Sum(x[i]*y[i])`.
`void` `dgemm(boolean transposeA, boolean transposeB, double alpha, DoubleMatrix2D A, DoubleMatrix2D B, double beta, DoubleMatrix2D C)` Generalized linear algebraic matrix-matrix multiply; `C = alpha*A*B + beta*C`.
`void` `dgemv(boolean transposeA, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)` Generalized linear algebraic matrix-vector multiply; `y = alpha*A*x + beta*y`.
`void` `dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)` Performs a rank 1 update; `A = A + alpha*x*y'`.
`double` `dnrm2(DoubleMatrix1D x)` Return the 2-norm; `sqrt(x[0]^2 + x[1]^2 + ...)`.
`void` `drot(DoubleMatrix1D x, DoubleMatrix1D y, double c, double s)` Applies a givens plane rotation to (x,y); `x = c*x + s*y; y = c*y - s*x`.
`void` `drotg(double a, double b, double[] rotvec)` Constructs a Givens plane rotation for `(a,b)`.
`void` `dscal(double alpha, DoubleMatrix1D x)` Vector scaling; `x = alpha*x`.
`void` `dscal(double alpha, DoubleMatrix2D A)` Matrix scaling; `A = alpha*A`.
`void` `dswap(DoubleMatrix1D x, DoubleMatrix1D y)` Swaps the elements of two vectors; `y <==> x`.
`void` `dswap(DoubleMatrix2D A, DoubleMatrix2D B)` Swaps the elements of two matrices; `B <==> A`.
`void` `dsymv(boolean isUpperTriangular, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)` Symmetric matrix-vector multiplication; `y = alpha*A*x + beta*y`.
`void` `dtrmv(boolean isUpperTriangular, boolean transposeA, boolean isUnitTriangular, DoubleMatrix2D A, DoubleMatrix1D x)` Triangular matrix-vector multiplication; `x = A*x` or `x = A'*x`.
`int` `idamax(DoubleMatrix1D x)` Returns the index of largest absolute value; `i such that |x[i]| == max(|x[0]|,|x[1]|,...).`.

### Methods inherited from class java.lang.Object

`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### seqBlas

    public static final Blas seqBlas

Little trick to allow for "aliasing", that is, renaming this class. Time and again writing code like

`SeqBlas.blas.dgemm(...);`

is a bit awkward. Using the aliasing you can instead write

`Blas B = SeqBlas.blas;
B.dgemm(...);`

### Method Detail

#### assign

    public void assign(DoubleMatrix2D A,
              DoubleFunction function)

Description copied from interface: `Blas`
Assigns the result of a function to each cell; `x[row,col] = function(x[row,col])`.

Specified by:
  `assign` in interface `Blas`
Parameters:
  `A` - the matrix to modify.
  `function` - a function object taking as argument the current cell's value.
See Also:
  `Functions`

#### assign

    public void assign(DoubleMatrix2D A,
              DoubleMatrix2D B,
              DoubleDoubleFunction function)

Description copied from interface: `Blas`
Assigns the result of a function to each cell; `x[row,col] = function(x[row,col],y[row,col])`.

Specified by:
  `assign` in interface `Blas`
Parameters:
  `A` - the matrix to modify.
  `B` - the secondary matrix to operate on.
  `function` - a function object taking as first argument the current cell's value of `this`, and as second argument the current cell's value of `y`,
See Also:
  `Functions`

#### dasum

    public double dasum(DoubleMatrix1D x)

Description copied from interface: `Blas`
Returns the sum of absolute values; `|x[0]| + |x[1]| + ...` . In fact equivalent to `x.aggregate(cern.jet.math.Functions.plus, cern.jet.math.Functions.abs)`.

Specified by:
  `dasum` in interface `Blas`
Parameters:
  `x` - the first vector.

#### daxpy

    public void daxpy(double alpha,
             DoubleMatrix1D x,
             DoubleMatrix1D y)

Description copied from interface: `Blas`
Combined vector scaling; `y = y + alpha*x`. In fact equivalent to `y.assign(x,cern.jet.math.Functions.plusMult(alpha))`.

Specified by:
  `daxpy` in interface `Blas`
Parameters:
  `alpha` - a scale factor.
  `x` - the first source vector.
  `y` - the second source vector, this is also the vector where results are stored.

#### daxpy

    public void daxpy(double alpha,
             DoubleMatrix2D A,
             DoubleMatrix2D B)

Description copied from interface: `Blas`
Combined matrix scaling; `B = B + alpha*A`. In fact equivalent to `B.assign(A,cern.jet.math.Functions.plusMult(alpha))`.

Specified by:
  `daxpy` in interface `Blas`
Parameters:
  `alpha` - a scale factor.
  `A` - the first source matrix.
  `B` - the second source matrix, this is also the matrix where results are stored.

#### dcopy

    public void dcopy(DoubleMatrix1D x,
             DoubleMatrix1D y)

Description copied from interface: `Blas`
Vector assignment (copying); `y = x`. In fact equivalent to `y.assign(x)`.

Specified by:
  `dcopy` in interface `Blas`
Parameters:
  `x` - the source vector.
  `y` - the destination vector.

#### dcopy

    public void dcopy(DoubleMatrix2D A,
             DoubleMatrix2D B)

Description copied from interface: `Blas`
Matrix assignment (copying); `B = A`. In fact equivalent to `B.assign(A)`.

Specified by:
  `dcopy` in interface `Blas`
Parameters:
  `A` - the source matrix.
  `B` - the destination matrix.

#### ddot

    public double ddot(DoubleMatrix1D x,
              DoubleMatrix1D y)

Description copied from interface: `Blas`
Returns the dot product of two vectors x and y, which is `Sum(x[i]*y[i])`. In fact equivalent to `x.zDotProduct(y)`.

Specified by:
  `ddot` in interface `Blas`
Parameters:
  `x` - the first vector.
  `y` - the second vector.
Returns:
  the sum of products.

#### dgemm

    public void dgemm(boolean transposeA,
             boolean transposeB,
             double alpha,
             DoubleMatrix2D A,
             DoubleMatrix2D B,
             double beta,
             DoubleMatrix2D C)

Description copied from interface: `Blas`
Generalized linear algebraic matrix-matrix multiply; `C = alpha*A*B + beta*C`. In fact equivalent to `A.zMult(B,C,alpha,beta,transposeA,transposeB)`. Note: Matrix shape conformance is checked after potential transpositions.

Specified by:
  `dgemm` in interface `Blas`
Parameters:
  `transposeA` - set this flag to indicate that the multiplication shall be performed on A'.
  `transposeB` - set this flag to indicate that the multiplication shall be performed on B'.
  `alpha` - a scale factor.
  `A` - the first source matrix.
  `B` - the second source matrix.
  `beta` - a scale factor.
  `C` - the third source matrix, this is also the matrix where results are stored.

#### dgemv

    public void dgemv(boolean transposeA,
             double alpha,
             DoubleMatrix2D A,
             DoubleMatrix1D x,
             double beta,
             DoubleMatrix1D y)

Description copied from interface: `Blas`
Generalized linear algebraic matrix-vector multiply; `y = alpha*A*x + beta*y`. In fact equivalent to `A.zMult(x,y,alpha,beta,transposeA)`. Note: Matrix shape conformance is checked after potential transpositions.

Specified by:
  `dgemv` in interface `Blas`
Parameters:
  `transposeA` - set this flag to indicate that the multiplication shall be performed on A'.
  `alpha` - a scale factor.
  `A` - the source matrix.
  `x` - the first source vector.
  `beta` - a scale factor.
  `y` - the second source vector, this is also the vector where results are stored.

#### dger

    public void dger(double alpha,
            DoubleMatrix1D x,
            DoubleMatrix1D y,
            DoubleMatrix2D A)

Description copied from interface: `Blas`
Performs a rank 1 update; `A = A + alpha*x*y'`. Example:

    A = { {6,5}, {7,6} }, x = {1,2}, y = {3,4}, alpha = 1 -->
    A = { {9,9}, {13,14} }

Specified by:
  `dger` in interface `Blas`
Parameters:
  `alpha` - a scalar.
  `x` - an m element vector.
  `y` - an n element vector.
  `A` - an m by n matrix.

#### dnrm2

    public double dnrm2(DoubleMatrix1D x)

Description copied from interface: `Blas`
Return the 2-norm; `sqrt(x[0]^2 + x[1]^2 + ...)`. In fact equivalent to `Math.sqrt(Algebra.DEFAULT.norm2(x))`.

Specified by:
  `dnrm2` in interface `Blas`
Parameters:
  `x` - the vector.

#### drot

    public void drot(DoubleMatrix1D x,
            DoubleMatrix1D y,
            double c,
            double s)

Description copied from interface: `Blas`
Applies a givens plane rotation to (x,y); `x = c*x + s*y; y = c*y - s*x`.

Specified by:
  `drot` in interface `Blas`
Parameters:
  `x` - the first vector.
  `y` - the second vector.
  `c` - the cosine of the angle of rotation.
  `s` - the sine of the angle of rotation.

#### drotg

    public void drotg(double a,
             double b,
             double[] rotvec)

Description copied from interface: `Blas`
Constructs a Givens plane rotation for `(a,b)`. Taken from the LINPACK translation from FORTRAN to Java, interface slightly modified. In the LINPACK listing DROTG is attributed to Jack Dongarra

Specified by:
  `drotg` in interface `Blas`
Parameters:
  `a` - rotational elimination parameter a.
  `b` - rotational elimination parameter b.

#### dscal

    public void dscal(double alpha,
             DoubleMatrix1D x)

Description copied from interface: `Blas`
Vector scaling; `x = alpha*x`. In fact equivalent to `x.assign(cern.jet.math.Functions.mult(alpha))`.

Specified by:
  `dscal` in interface `Blas`
Parameters:
  `alpha` - a scale factor.
  `x` - the first vector.

#### dscal

    public void dscal(double alpha,
             DoubleMatrix2D A)

Description copied from interface: `Blas`
Matrix scaling; `A = alpha*A`. In fact equivalent to `A.assign(cern.jet.math.Functions.mult(alpha))`.

Specified by:
  `dscal` in interface `Blas`
Parameters:
  `alpha` - a scale factor.
  `A` - the matrix.

#### dswap

    public void dswap(DoubleMatrix1D x,
             DoubleMatrix1D y)

Description copied from interface: `Blas`
Swaps the elements of two vectors; `y <==> x`. In fact equivalent to `y.swap(x)`.

Specified by:
  `dswap` in interface `Blas`
Parameters:
  `x` - the first vector.
  `y` - the second vector.

#### dswap

    public void dswap(DoubleMatrix2D A,
             DoubleMatrix2D B)

Description copied from interface: `Blas`
Swaps the elements of two matrices; `B <==> A`.

Specified by:
  `dswap` in interface `Blas`

#### dsymv

    public void dsymv(boolean isUpperTriangular,
             double alpha,
             DoubleMatrix2D A,
             DoubleMatrix1D x,
             double beta,
             DoubleMatrix1D y)

Description copied from interface: `Blas`
Symmetric matrix-vector multiplication; `y = alpha*A*x + beta*y`. Where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix. A can be in upper or lower triangular format.

Specified by:
  `dsymv` in interface `Blas`
Parameters:
  `isUpperTriangular` - is A upper triangular or lower triangular part to be used?
  `alpha` - scaling factor.
  `A` - the source matrix.
  `x` - the first source vector.
  `beta` - scaling factor.
  `y` - the second vector holding source and destination.

#### dtrmv

    public void dtrmv(boolean isUpperTriangular,
             boolean transposeA,
             boolean isUnitTriangular,
             DoubleMatrix2D A,
             DoubleMatrix1D x)

Description copied from interface: `Blas`
Triangular matrix-vector multiplication; `x = A*x` or `x = A'*x`. Where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix.

Specified by:
  `dtrmv` in interface `Blas`
Parameters:
  `isUpperTriangular` - is A upper triangular or lower triangular?
  `transposeA` - set this flag to indicate that the multiplication shall be performed on A'.
  `isUnitTriangular` - true --> A is assumed to be unit triangular; false --> A is not assumed to be unit triangular
  `A` - the source matrix.
  `x` - the vector holding source and destination.

#### idamax

    public int idamax(DoubleMatrix1D x)

Description copied from interface: `Blas`
Returns the index of largest absolute value; `i such that |x[i]| == max(|x[0]|,|x[1]|,...).`.

Specified by:
  `idamax` in interface `Blas`
Parameters:
  `x` - the vector to search through.
Returns:
  the index of largest absolute value (-1 if x is empty).