DenseTensorBLAS

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def gemm[T](transa: Char, transb: Char, m: Int, n: Int, k: Int, alpha: T, a: Array[T], aOffset: Int, lda: Int, b: Array[T], bOffset: Int, ldb: Int, beta: T, c: Array[T], cOffset: Int, ldc: Int)(implicit ev: TensorNumeric[T]): Unit

The gemm routines compute a scalar-matrix-matrix product and add the result to a scalar-matrix product, with general matrices.
The gemm routines compute a scalar-matrix-matrix product and add the result to a scalar-matrix product, with general matrices. C := alpha*op(A)*op(B) + beta*C, where: op(X) is one of op(X) = X, or op(X) = XT, alpha and beta are scalars, A, B and C are matrices: op(A) is an m-by-k matrix, op(B) is a k-by-n matrix, C is an m-by-n matrix.
this interface treat the input array as column-major array.
T

transa
Specifies the form of op(A) used in the matrix multiplication: if transa=CblasNoTrans, then op(A) = A; if transa=CblasTrans, then op(A) = AT;
transb
Specifies the form of op(B) used in the matrix multiplication: if transb=CblasNoTrans, then op(B) = B; if transb=CblasTrans, then op(B) = BT;
m
Specifies the number of rows of the matrix op(A) and of the matrix C. The value of m must be at least zero.
n
Specifies the number of columns of the matrix op(B) and the number of columns of the matrix C. The value of n must be at least zero.
k
Specifies the number of columns of the matrix op(A) and the number of rows of the matrix op(B). The value of k must be at least zero.
alpha
Specifies the scalar alpha.
a
Array. if transa=CblasNoTrans, size lda*k. if transa=CblasTrans, size lda*m.
aOffset
a offset
lda
Specifies the leading dimension of a as declared in the calling (sub)program. if transa=CblasNoTrans, lda must be at least max(1, m). if transa=CblasTrans, lda must be at least max(1, k).
b
Array. if transb=CblasNoTrans, size ldb by n. if transb=CblasTrans, size ldb by k.
bOffset
b offset
ldb
Specifies the leading dimension of b as declared in the calling (sub)program. if transb=CblasNoTrans, ldb must be at least max(1, m). if transb=CblasTrans, ldb must be at least max(1, k).
beta
Specifies the scalar beta. When beta is equal to zero, then c need not be set on input.
c
Array, size ldc by n. Before entry, the leading m-by-n part of the array c must contain the matrix C, except when beta is equal to zero, in which case c need not be set on entry.
cOffset
c offset
ldc
ldc must be at least max(1, m).
ev
def gemv[T](alpha: T, matrix: Tensor[T], vector: Tensor[T], beta: T, r: Tensor[T])(implicit ev: TensorNumeric[T]): Unit

to be fixed: this interface treat the input tensor as row-major array.
to be fixed: this interface treat the input tensor as row-major array.
T

alpha
matrix
vector
beta
r
ev
def gemv[T](trans: Char, m: Int, n: Int, alpha: T, a: Array[T], aOffset: Int, lda: Int, x: Array[T], xOffset: Int, incx: Int, beta: T, y: Array[T], yOffset: Int, incy: Int)(implicit ev: TensorNumeric[T]): Unit

The gemv routines perform a matrix-vector operation defined as y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y, where: alpha and beta are scalars, x and y are vectors, A is an m-by-n matrix.
The gemv routines perform a matrix-vector operation defined as y := alpha*A*x + beta*y, or y := alpha*A'*x + beta*y, where: alpha and beta are scalars, x and y are vectors, A is an m-by-n matrix.
this interface treat the input array as column-major array.
T

trans
Specifies the operation: if trans=CblasNoTrans, then y := alpha*A*x + beta*y; if trans=CblasTrans, then y := alpha*A'*x + beta*y;
m
Specifies the number of rows of the matrix A. The value of m must be at least zero.
n
Specifies the number of columns of the matrix A. The value of n must be at least zero.
alpha
Specifies the scalar alpha.
a
Array, size lda* n. Before entry, the leading m-by-n part of the array a must contain the matrix A.
aOffset
a offset
lda
Specifies the leading dimension of a as declared in the calling (sub)program. the value of lda must be at least max(1, m).
x
Array, size at least (1+(n-1)*abs(incx)). Before entry, the incremented array x must contain the vector x.
xOffset
x offset
incx
Specifies the increment for the elements of x. The value of incx must not be zero.
beta
Specifies the scalar beta. When beta is set to zero, then y need not be set on input.
y
Array, size at least (1 +(m - 1)*abs(incy)). Before entry with non-zero beta, the incremented array y must contain the vector y.
yOffset
y offset
incy
Specifies the increment for the elements of y. The value of incy must not be zero.
ev
def ger[T](m: Int, n: Int, alpha: T, x: Array[T], xOffset: Int, incx: Int, y: Array[T], yOffset: Int, incy: Int, a: Array[T], aOffset: Int, lda: Int)(implicit ev: TensorNumeric[T]): Unit

The ger routines perform a matrix-vector operation defined as A := alpha*x*y'+ A, where: alpha is a scalar, x is an m-element vector, y is an n-element vector, A is an m-by-n general matrix.
The ger routines perform a matrix-vector operation defined as A := alpha*x*y'+ A, where: alpha is a scalar, x is an m-element vector, y is an n-element vector, A is an m-by-n general matrix.
this interface treat the input array as column-major array.
T

m
Specifies the number of rows of the matrix A. The value of m must be at least zero.
n
Specifies the number of columns of the matrix A. The value of n must be at least zero.
alpha
Specifies the scalar alpha.
x
Array, size at least (1 + (m - 1)*abs(incx)). Before entry, the incremented array x must contain the m-element vector x.
xOffset
x offset
incx
Specifies the increment for the elements of x. The value of incx must not be zero.
y
Array, size at least (1 + (n - 1)*abs(incy)). Before entry, the incremented array y must contain the n-element vector y.
yOffset
y offset
incy
Specifies the increment for the elements of y. The value of incy must not be zero.
a
Array, size lda * n. Before entry, the leading m-by-n part of the array a must contain the matrix A.
aOffset
a offset
lda
Specifies the leading dimension of a as declared in the calling (sub)program. the value of lda must be at least max(1, m).
ev
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
var time: Long
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

object DenseTensorBLAS

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def gemm[T](transa: Char, transb: Char, m: Int, n: Int, k: Int, alpha: T, a: Array[T], aOffset: Int, lda: Int, b: Array[T], bOffset: Int, ldb: Int, beta: T, c: Array[T], cOffset: Int, ldc: Int)(implicit ev: TensorNumeric[T]): Unit

def gemv[T](alpha: T, matrix: Tensor[T], vector: Tensor[T], beta: T, r: Tensor[T])(implicit ev: TensorNumeric[T]): Unit

def gemv[T](trans: Char, m: Int, n: Int, alpha: T, a: Array[T], aOffset: Int, lda: Int, x: Array[T], xOffset: Int, incx: Int, beta: T, y: Array[T], yOffset: Int, incy: Int)(implicit ev: TensorNumeric[T]): Unit

def ger[T](m: Int, n: Int, alpha: T, x: Array[T], xOffset: Int, incx: Int, y: Array[T], yOffset: Int, incy: Int, a: Array[T], aOffset: Int, lda: Int)(implicit ev: TensorNumeric[T]): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

var time: Long

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped