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
Modifier and Type Field Description

private static Functions F

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

Constructor Summary

Constructors
Modifier Constructor Description

protected SeqBlas()
Makes this class non instantiable, but still let's others inherit from it.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	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 = alphaAB + beta*C`.
`void`	`dgemv(boolean transposeA, double alpha, DoubleMatrix2D A, DoubleMatrix1D x, double beta, DoubleMatrix1D y)`	Generalized linear algebraic matrix-vector multiply; `y = alphaAx + beta*y`.
`void`	`dger(double alpha, DoubleMatrix1D x, DoubleMatrix1D y, DoubleMatrix2D A)`	Performs a rank 1 update; `A = A + alphaxy'`.
`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 = cx + sy; y = cy - sx`.
`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 = alphaAx + beta*y`.
`void`	`dtrmv(boolean isUpperTriangular, boolean transposeA, boolean isUnitTriangular, DoubleMatrix2D A, DoubleMatrix1D x)`	Triangular matrix-vector multiplication; `x = Ax` 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]\|,...).`.
`private double`	`sign(double a, double b)`	Implements the FORTRAN sign (not sin) function.

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(...);
  - F
```
private static final Functions F
```
- 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.
    
    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.
    
    rotvec - [] Must be at least of length 4. On output contains the values {a,b,c,s}.
  - 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).
  - sign
```
private double sign(double a,
                    double b)
```
    Implements the FORTRAN sign (not sin) function. See the code for details.
    
    Parameters:
    
    a - a
    
    b - b

Modifier and Type	Field	Description
`private static Functions`	`F`
`static Blas`	`seqBlas`	Little trick to allow for "aliasing", that is, renaming this class.

Class SeqBlas

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

seqBlas

F

Constructor Detail

SeqBlas

Method Detail

assign

assign

dasum

daxpy

daxpy

dcopy

dcopy

ddot

dgemm

dgemv

dger

dnrm2

drot

drotg

dscal

dscal

dswap

dswap

dsymv

dtrmv

idamax

sign