object DenseTensorBLAS
- Alphabetic
- By Inheritance
- DenseTensorBLAS
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @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.
- 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).
-
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.
-
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.
- 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.
-
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.
- 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).
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
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
- @native() @throws( ... )