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
    Modifier and Type | Field and Description
    --- | ---
    `static Blas` | `seqBlas` Little trick to allow for "aliasing", that is, renaming this class.

  - ### 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

      `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).

Jump to the Colt Homepage