cern.colt.matrix.linalg

## Class SeqBlas

• All Implemented Interfaces:
Blas

```public class SeqBlas
extends Object
implements Blas```
Sequential implementation of the Basic Linear Algebra System.
Version:
0.9, 16/04/2000
Author:
wolfgang.hoschek@cern.ch
• ### Field Summary

Fields
Modifier and Type Field and Description
`static Blas` `seqBlas`
Little trick to allow for "aliasing", that is, renaming this class.
• ### Constructor Summary

Constructors
Modifier Constructor and Description
`protected ` `SeqBlas()`
Makes this class non instantiable, but still let's others inherit from it.
• ### Method Summary

Methods
Modifier and Type Method and Description
`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

`clone, equals, finalize, 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(...);

• ### Constructor Detail

• #### SeqBlas

`protected SeqBlas()`
Makes this class non instantiable, but still let's others inherit from it.
• ### 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.
`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,
`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).