/*
* Call any of the cblas_xrot functions as directly as possible.
*
* xROT is a BLAS level 1 routine (taking two vectors) which applies a plane rotation.
*
* It's tough to find documentation on xROT. Here are what we think the arguments are for:
* * n :: number of elements to consider in x and y
* * x :: a vector (expects an NVector)
* * incx :: stride of x
* * y :: a vector (expects an NVector)
* * incy :: stride of y
* * c :: cosine of the angle of rotation
* * s :: sine of the angle of rotation
*
* Note that c and s will be the same dtype as x and y, except when x and y are complex. If x and y are complex, c and s
* will be float for Complex64 or double for Complex128.
*
* You probably don't want to call this function. Instead, why don't you try rot, which is more flexible
* with its arguments?
*
* This function does almost no type checking. Seriously, be really careful when you call it! There's no exception
* handling, so you can easily crash Ruby!
*/
static VALUE nm_lapacke_cblas_rot(VALUE self, VALUE n, VALUE x, VALUE incx, VALUE y, VALUE incy, VALUE c, VALUE s) {
static void (*ttable[nm::NUM_DTYPES])(const int N, void*, const int, void*, const int, const void*, const void*) = {
NULL, NULL, NULL, NULL, NULL, // can't represent c and s as integers, so no point in having integer operations.
nm::math::lapacke::cblas_rot<float,float>,
nm::math::lapacke::cblas_rot<double,double>,
nm::math::lapacke::cblas_rot<nm::Complex64,float>,
nm::math::lapacke::cblas_rot<nm::Complex128,double>,
nm::math::lapacke::cblas_rot<nm::RubyObject,nm::RubyObject>
};
nm::dtype_t dtype = NM_DTYPE(x);
if (!ttable[dtype]) {
rb_raise(nm_eDataTypeError, "this operation undefined for integer vectors");
return Qfalse;
} else {
void *pC, *pS;
// We need to ensure the cosine and sine arguments are the correct dtype -- which may differ from the actual dtype.
if (dtype == nm::COMPLEX64) {
pC = NM_ALLOCA_N(float,1);
pS = NM_ALLOCA_N(float,1);
rubyval_to_cval(c, nm::FLOAT32, pC);
rubyval_to_cval(s, nm::FLOAT32, pS);
} else if (dtype == nm::COMPLEX128) {
static VALUE nm_cblas_trsm(VALUE self,
VALUE order,
VALUE side, VALUE uplo,
VALUE trans_a, VALUE diag,
VALUE m, VALUE n,
VALUE alpha,
VALUE a, VALUE lda,
VALUE b, VALUE ldb)
{
static void (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER, const enum CBLAS_SIDE, const enum CBLAS_UPLO,
const enum CBLAS_TRANSPOSE, const enum CBLAS_DIAG,
const int, const int, const void* alpha, const void* a,
const int lda, void* b, const int ldb) = {
NULL, NULL, NULL, NULL, NULL, // integers not allowed due to division
nm::math::cblas_trsm<float>,
nm::math::cblas_trsm<double>,
cblas_ctrsm, cblas_ztrsm, // call directly, same function signature!
nm::math::cblas_trsm<nm::Rational32>,
nm::math::cblas_trsm<nm::Rational64>,
nm::math::cblas_trsm<nm::Rational128>,
nm::math::cblas_trsm<nm::RubyObject>
};
dtype_t dtype = NM_DTYPE(a);
void *pAlpha = ALLOCA_N(char, DTYPE_SIZES[dtype]);
rubyval_to_cval(alpha, dtype, pAlpha);
ttable[dtype](blas_order_sym(order), blas_side_sym(side), blas_uplo_sym(uplo), blas_transpose_sym(trans_a), blas_diag_sym(diag), FIX2INT(m), FIX2INT(n), pAlpha, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), NM_STORAGE_DENSE(b)->elements, FIX2INT(ldb));
return Qtrue;
}
/* Call any of the cblas_xgemv functions as directly as possible.
*
* The cblas_xgemv functions (dgemv, sgemv, cgemv, and zgemv) define the following operation:
*
* y = alpha*op(A)*x + beta*y
*
* where op(A) is one of <tt>op(A) = A</tt>, <tt>op(A) = A**T</tt>, or the complex conjugate of A.
*
* Note that this will only work for dense matrices that are of types :float32, :float64, :complex64, and :complex128.
* Other types are not implemented in BLAS, and while they exist in NMatrix, this method is intended only to
* expose the ultra-optimized ATLAS versions.
*
* == Arguments
* See: http://www.netlib.org/blas/dgemm.f
*
* You probably don't want to call this function. Instead, why don't you try cblas_gemv, which is more flexible
* with its arguments?
*
* This function does almost no type checking. Seriously, be really careful when you call it! There's no exception
* handling, so you can easily crash Ruby!
*/
static VALUE nm_cblas_gemv(VALUE self,
VALUE trans_a,
VALUE m, VALUE n,
VALUE alpha,
VALUE a, VALUE lda,
VALUE x, VALUE incx,
VALUE beta,
VALUE y, VALUE incy)
{
NAMED_DTYPE_TEMPLATE_TABLE(ttable, nm::math::cblas_gemv, bool, const enum CBLAS_TRANSPOSE trans_a, int m, int n, void* alpha, void* a, int lda, void* x, int incx, void* beta, void* y, int incy);
dtype_t dtype = NM_DTYPE(a);
void *pAlpha = ALLOCA_N(char, DTYPE_SIZES[dtype]),
*pBeta = ALLOCA_N(char, DTYPE_SIZES[dtype]);
rubyval_to_cval(alpha, dtype, pAlpha);
rubyval_to_cval(beta, dtype, pBeta);
return ttable[dtype](blas_transpose_sym(trans_a), FIX2INT(m), FIX2INT(n), pAlpha, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), NM_STORAGE_DENSE(x)->elements, FIX2INT(incx), pBeta, NM_STORAGE_DENSE(y)->elements, FIX2INT(incy)) ? Qtrue : Qfalse;
}
/*
* Based on LAPACK's dscal function, but for any dtype.
*
* In-place modification; returns the modified vector as well.
*/
static VALUE nm_clapack_scal(VALUE self, VALUE n, VALUE scale, VALUE vector, VALUE incx) {
dtype_t dtype = NM_DTYPE(vector);
void* da = ALLOCA_N(char, DTYPE_SIZES[dtype]);
rubyval_to_cval(scale, dtype, da);
NAMED_DTYPE_TEMPLATE_TABLE(ttable, nm::math::clapack_scal, void, const int n, const void* da, void* dx, const int incx);
ttable[dtype](FIX2INT(n), da, NM_STORAGE_DENSE(vector)->elements, FIX2INT(incx));
return vector;
}
/*
* call-seq:
* NMatrix::BLAS.cblas_scal(n, alpha, vector, inc) -> NMatrix
*
* BLAS level 1 function +scal+. Works with all dtypes.
*
* Scale +vector+ in-place by +alpha+ and also return it. The operation is as
* follows:
* x <- alpha * x
*
* - +n+ -> Number of elements of +vector+.
* - +alpha+ -> Scalar value used in the operation.
* - +vector+ -> NMatrix of shape [n,1] or [1,n]. Modified in-place.
* - +inc+ -> Increment used in the scaling function. Should generally be 1.
*/
static VALUE nm_lapacke_cblas_scal(VALUE self, VALUE n, VALUE alpha, VALUE vector, VALUE incx) {
nm::dtype_t dtype = NM_DTYPE(vector);
void* scalar = NM_ALLOCA_N(char, DTYPE_SIZES[dtype]);
rubyval_to_cval(alpha, dtype, scalar);
NAMED_DTYPE_TEMPLATE_TABLE(ttable, nm::math::lapacke::cblas_scal, void, const int n,
const void* scalar, void* x, const int incx);
ttable[dtype](FIX2INT(n), scalar, NM_STORAGE_DENSE(vector)->elements,
FIX2INT(incx));
return vector;
}
/* Call any of the cblas_xgemm functions as directly as possible.
*
* The cblas_xgemm functions (dgemm, sgemm, cgemm, and zgemm) define the following operation:
*
* C = alpha*op(A)*op(B) + beta*C
*
* where op(X) is one of <tt>op(X) = X</tt>, <tt>op(X) = X**T</tt>, or the complex conjugate of X.
*
* Note that this will only work for dense matrices that are of types :float32, :float64, :complex64, and :complex128.
* Other types are not implemented in BLAS, and while they exist in NMatrix, this method is intended only to
* expose the ultra-optimized ATLAS versions.
*
* == Arguments
* See: http://www.netlib.org/blas/dgemm.f
*
* You probably don't want to call this function. Instead, why don't you try cblas_gemm, which is more flexible
* with its arguments?
*
* This function does almost no type checking. Seriously, be really careful when you call it! There's no exception
* handling, so you can easily crash Ruby!
*/
static VALUE nm_cblas_gemm(VALUE self,
VALUE order,
VALUE trans_a, VALUE trans_b,
VALUE m, VALUE n, VALUE k,
VALUE alpha,
VALUE a, VALUE lda,
VALUE b, VALUE ldb,
VALUE beta,
VALUE c, VALUE ldc)
{
NAMED_DTYPE_TEMPLATE_TABLE(ttable, nm::math::cblas_gemm, void, const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE trans_a, const enum CBLAS_TRANSPOSE trans_b, int m, int n, int k, void* alpha, void* a, int lda, void* b, int ldb, void* beta, void* c, int ldc);
dtype_t dtype = NM_DTYPE(a);
void *pAlpha = ALLOCA_N(char, DTYPE_SIZES[dtype]),
*pBeta = ALLOCA_N(char, DTYPE_SIZES[dtype]);
rubyval_to_cval(alpha, dtype, pAlpha);
rubyval_to_cval(beta, dtype, pBeta);
ttable[dtype](blas_order_sym(order), blas_transpose_sym(trans_a), blas_transpose_sym(trans_b), FIX2INT(m), FIX2INT(n), FIX2INT(k), pAlpha, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), NM_STORAGE_DENSE(b)->elements, FIX2INT(ldb), pBeta, NM_STORAGE_DENSE(c)->elements, FIX2INT(ldc));
return c;
}
