struct.solver
Class BLAS

java.lang.Object
  extended by struct.solver.BLAS

public class BLAS
extends java.lang.Object

Native BLAS. The same calling conventions as the CBLAS . Note that the methods using enumerations to indicate matrix type now uses class integer constants.


Field Summary
static int ColMajor
          Order enumeration
static int Left
          Side enumeration
static int Lower
          Upper/lower enumeration
static int NonUnit
          Diagonal enumeration
static int NoTrans
          Transpose enumeration
static int Right
          Side enumeration
static int RowMajor
          Order enumeration
static int Trans
          Transpose enumeration
static int Unit
          Diagonal enumeration
static int Upper
          Upper/lower enumeration
 
Constructor Summary
private BLAS()
           
 
Method Summary
static double asum(int N, double[] X, int incX)
           
static void axpy(int N, double alpha, double[] X, int incX, double[] Y, int incY)
           
static void copy(int N, double[] X, int incX, double[] Y, int incY)
           
static double dot(int N, double[] X, int incX, double[] Y, int incY)
           
static void gbmv(int order, int TransA, int M, int N, int KL, int KU, double alpha, double[] A, int lda, double[] X, int incX, double beta, double[] Y, int incY)
           
static void gemm(int Order, int TransA, int TransB, int M, int N, int K, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc)
           
static void gemv(int order, int TransA, int M, int N, double alpha, double[] A, int lda, double[] X, int incX, double beta, double[] Y, int incY)
           
static void ger(int order, int M, int N, double alpha, double[] X, int incX, double[] Y, int incY, double[] A, int lda)
           
static int idamax(int N, double[] X, int incX)
           
static void init()
          A dummy method which can be called to load the library
static double nrm2(int N, double[] X, int incX)
           
static void rot(int N, double[] X, int incX, double[] Y, int incY, double c, double s)
           
static void rotg(double[] a, double[] b, double[] c, double[] s)
           
static void rotm(int N, double[] X, int incX, double[] Y, int incY, double[] P)
           
static void rotmg(double[] d1, double[] d2, double[] b1, double b2, double[] P)
           
static void sbmv(int order, int Uplo, int N, int K, double alpha, double[] A, int lda, double[] X, int incX, double beta, double[] Y, int incY)
           
static void scal(int N, double alpha, double[] X, int incX)
           
static void spmv(int order, int Uplo, int N, double alpha, double[] Ap, double[] X, int incX, double beta, double[] Y, int incY)
           
static void spr(int order, int Uplo, int N, double alpha, double[] X, int incX, double[] Ap)
           
static void spr2(int order, int Uplo, int N, double alpha, double[] X, int incX, double[] Y, int incY, double[] Ap)
           
static void swap(int N, double[] X, int incX, double[] Y, int incY)
           
static void symm(int Order, int Side, int Uplo, int M, int N, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc)
           
static void symv(int order, int Uplo, int N, double alpha, double[] A, int lda, double[] X, int incX, double beta, double[] Y, int incY)
           
static void syr(int order, int Uplo, int N, double alpha, double[] X, int incX, double[] A, int lda)
           
static void syr2(int order, int Uplo, int N, double alpha, double[] X, int incX, double[] Y, int incY, double[] A, int lda)
           
static void syr2k(int Order, int Uplo, int Trans, int N, int K, double alpha, double[] A, int lda, double[] B, int ldb, double beta, double[] C, int ldc)
           
static void syrk(int Order, int Uplo, int Trans, int N, int K, double alpha, double[] A, int lda, double beta, double[] C, int ldc)
           
static void tbmv(int order, int Uplo, int TransA, int Diag, int N, int K, double[] A, int lda, double[] X, int incX)
           
static void tbsv(int order, int Uplo, int TransA, int Diag, int N, int K, double[] A, int lda, double[] X, int incX)
           
static void tpmv(int order, int Uplo, int TransA, int Diag, int N, double[] Ap, double[] X, int incX)
           
static void tpsv(int order, int Uplo, int TransA, int Diag, int N, double[] Ap, double[] X, int incX)
           
static void trmm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, double alpha, double[] A, int lda, double[] B, int ldb)
           
static void trmv(int order, int Uplo, int TransA, int Diag, int N, double[] A, int lda, double[] X, int incX)
           
static void trsm(int Order, int Side, int Uplo, int TransA, int Diag, int M, int N, double alpha, double[] A, int lda, double[] B, int ldb)
           
static void trsv(int order, int Uplo, int TransA, int Diag, int N, double[] A, int lda, double[] X, int incX)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

RowMajor

public static final int RowMajor
Order enumeration

See Also:
Constant Field Values

ColMajor

public static final int ColMajor
Order enumeration

See Also:
Constant Field Values

NoTrans

public static final int NoTrans
Transpose enumeration

See Also:
Constant Field Values

Trans

public static final int Trans
Transpose enumeration

See Also:
Constant Field Values

Upper

public static final int Upper
Upper/lower enumeration

See Also:
Constant Field Values

Lower

public static final int Lower
Upper/lower enumeration

See Also:
Constant Field Values

NonUnit

public static final int NonUnit
Diagonal enumeration

See Also:
Constant Field Values

Unit

public static final int Unit
Diagonal enumeration

See Also:
Constant Field Values

Left

public static final int Left
Side enumeration

See Also:
Constant Field Values

Right

public static final int Right
Side enumeration

See Also:
Constant Field Values
Constructor Detail

BLAS

private BLAS()
Method Detail

init

public static void init()
A dummy method which can be called to load the library


dot

public static double dot(int N,
                         double[] X,
                         int incX,
                         double[] Y,
                         int incY)

nrm2

public static double nrm2(int N,
                          double[] X,
                          int incX)

asum

public static double asum(int N,
                          double[] X,
                          int incX)

idamax

public static int idamax(int N,
                         double[] X,
                         int incX)

swap

public static void swap(int N,
                        double[] X,
                        int incX,
                        double[] Y,
                        int incY)

copy

public static void copy(int N,
                        double[] X,
                        int incX,
                        double[] Y,
                        int incY)

axpy

public static void axpy(int N,
                        double alpha,
                        double[] X,
                        int incX,
                        double[] Y,
                        int incY)

rotg

public static void rotg(double[] a,
                        double[] b,
                        double[] c,
                        double[] s)

rotmg

public static void rotmg(double[] d1,
                         double[] d2,
                         double[] b1,
                         double b2,
                         double[] P)

rot

public static void rot(int N,
                       double[] X,
                       int incX,
                       double[] Y,
                       int incY,
                       double c,
                       double s)

rotm

public static void rotm(int N,
                        double[] X,
                        int incX,
                        double[] Y,
                        int incY,
                        double[] P)

scal

public static void scal(int N,
                        double alpha,
                        double[] X,
                        int incX)

gemv

public static void gemv(int order,
                        int TransA,
                        int M,
                        int N,
                        double alpha,
                        double[] A,
                        int lda,
                        double[] X,
                        int incX,
                        double beta,
                        double[] Y,
                        int incY)

gbmv

public static void gbmv(int order,
                        int TransA,
                        int M,
                        int N,
                        int KL,
                        int KU,
                        double alpha,
                        double[] A,
                        int lda,
                        double[] X,
                        int incX,
                        double beta,
                        double[] Y,
                        int incY)

trmv

public static void trmv(int order,
                        int Uplo,
                        int TransA,
                        int Diag,
                        int N,
                        double[] A,
                        int lda,
                        double[] X,
                        int incX)

tbmv

public static void tbmv(int order,
                        int Uplo,
                        int TransA,
                        int Diag,
                        int N,
                        int K,
                        double[] A,
                        int lda,
                        double[] X,
                        int incX)

tpmv

public static void tpmv(int order,
                        int Uplo,
                        int TransA,
                        int Diag,
                        int N,
                        double[] Ap,
                        double[] X,
                        int incX)

trsv

public static void trsv(int order,
                        int Uplo,
                        int TransA,
                        int Diag,
                        int N,
                        double[] A,
                        int lda,
                        double[] X,
                        int incX)

tbsv

public static void tbsv(int order,
                        int Uplo,
                        int TransA,
                        int Diag,
                        int N,
                        int K,
                        double[] A,
                        int lda,
                        double[] X,
                        int incX)

tpsv

public static void tpsv(int order,
                        int Uplo,
                        int TransA,
                        int Diag,
                        int N,
                        double[] Ap,
                        double[] X,
                        int incX)

symv

public static void symv(int order,
                        int Uplo,
                        int N,
                        double alpha,
                        double[] A,
                        int lda,
                        double[] X,
                        int incX,
                        double beta,
                        double[] Y,
                        int incY)

sbmv

public static void sbmv(int order,
                        int Uplo,
                        int N,
                        int K,
                        double alpha,
                        double[] A,
                        int lda,
                        double[] X,
                        int incX,
                        double beta,
                        double[] Y,
                        int incY)

spmv

public static void spmv(int order,
                        int Uplo,
                        int N,
                        double alpha,
                        double[] Ap,
                        double[] X,
                        int incX,
                        double beta,
                        double[] Y,
                        int incY)

ger

public static void ger(int order,
                       int M,
                       int N,
                       double alpha,
                       double[] X,
                       int incX,
                       double[] Y,
                       int incY,
                       double[] A,
                       int lda)

syr

public static void syr(int order,
                       int Uplo,
                       int N,
                       double alpha,
                       double[] X,
                       int incX,
                       double[] A,
                       int lda)

spr

public static void spr(int order,
                       int Uplo,
                       int N,
                       double alpha,
                       double[] X,
                       int incX,
                       double[] Ap)

syr2

public static void syr2(int order,
                        int Uplo,
                        int N,
                        double alpha,
                        double[] X,
                        int incX,
                        double[] Y,
                        int incY,
                        double[] A,
                        int lda)

spr2

public static void spr2(int order,
                        int Uplo,
                        int N,
                        double alpha,
                        double[] X,
                        int incX,
                        double[] Y,
                        int incY,
                        double[] Ap)

gemm

public static void gemm(int Order,
                        int TransA,
                        int TransB,
                        int M,
                        int N,
                        int K,
                        double alpha,
                        double[] A,
                        int lda,
                        double[] B,
                        int ldb,
                        double beta,
                        double[] C,
                        int ldc)

symm

public static void symm(int Order,
                        int Side,
                        int Uplo,
                        int M,
                        int N,
                        double alpha,
                        double[] A,
                        int lda,
                        double[] B,
                        int ldb,
                        double beta,
                        double[] C,
                        int ldc)

syrk

public static void syrk(int Order,
                        int Uplo,
                        int Trans,
                        int N,
                        int K,
                        double alpha,
                        double[] A,
                        int lda,
                        double beta,
                        double[] C,
                        int ldc)

syr2k

public static void syr2k(int Order,
                         int Uplo,
                         int Trans,
                         int N,
                         int K,
                         double alpha,
                         double[] A,
                         int lda,
                         double[] B,
                         int ldb,
                         double beta,
                         double[] C,
                         int ldc)

trmm

public static void trmm(int Order,
                        int Side,
                        int Uplo,
                        int TransA,
                        int Diag,
                        int M,
                        int N,
                        double alpha,
                        double[] A,
                        int lda,
                        double[] B,
                        int ldb)

trsm

public static void trsm(int Order,
                        int Side,
                        int Uplo,
                        int TransA,
                        int Diag,
                        int M,
                        int N,
                        double alpha,
                        double[] A,
                        int lda,
                        double[] B,
                        int ldb)


Copyright (C) 2006 University of Pennsylvania.