The OpenD Programming Language

glas.ndslice

Members

Aliases

asum
alias asum = _glas_dzasum
alias asum = _glas_scasum
alias asum = _glas_dasum
alias asum = _glas_sasum
alias asum = glas_dzasum
alias asum = glas_scasum
alias asum = glas_dasum
alias asum = glas_sasum

Takes the sum of the absolute values.

axpy
alias axpy = glas_saxpy
alias axpy = glas_daxpy
alias axpy = glas_caxpy
alias axpy = glas_zaxpy
alias axpy = _glas_saxpy
alias axpy = _glas_daxpy
alias axpy = _glas_caxpy
alias axpy = _glas_zaxpy

Constant times a vector plus a vector.

copy
alias copy = glas_scopy
alias copy = glas_dcopy
alias copy = glas_ccopy
alias copy = glas_zcopy
alias copy = _glas_scopy
alias copy = _glas_dcopy
alias copy = _glas_ccopy
alias copy = _glas_zcopy

copy copies a vector, x, to a vector, y.

dot
alias dot = glas_sdot
alias dot = _glas_ddot
alias dot = _glas_sdot
alias dot = glas_ddot

Forms the dot product of two vectors. Uses unrolled loops for increments equal to one.

dotc
alias dotc = _glas_zdotc
alias dotc = _glas_cdotc
alias dotc = glas_zdotc
alias dotc = glas_cdotc

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

dotu
alias dotu = _glas_zdotu
alias dotu = _glas_cdotu
alias dotu = glas_zdotu
alias dotu = glas_cdotu

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

dsdot
alias dsdot = _glas_dsdot
alias dsdot = glas_dsdot

Compute the inner product of two vectors with extended precision accumulation and result. Uses unrolled loops for increments equal to one.

gemm
alias gemm = glas_sgemm
alias gemm = glas_dgemm
alias gemm = glas_cgemm
alias gemm = glas_zgemm

Performs general matrix-matrix multiplication.

iamax
alias iamax = _glas_izamax
alias iamax = _glas_icamax
alias iamax = _glas_idamax
alias iamax = _glas_isamax
alias iamax = glas_izamax
alias iamax = glas_icamax
alias iamax = glas_idamax
alias iamax = glas_isamax

Finds the index of the first element having maximum |Re(.)| + |Im(.)|.

nrm2
alias nrm2 = _glas_dznrm2
alias nrm2 = _glas_scnrm2
alias nrm2 = _glas_dnrm2
alias nrm2 = _glas_snrm2
alias nrm2 = glas_dznrm2
alias nrm2 = glas_scnrm2
alias nrm2 = glas_dnrm2
alias nrm2 = glas_snrm2

Returns the euclidean norm of a vector via the function.

rot
alias rot = _glas_zdrot
alias rot = _glas_csrot
alias rot = _glas_drot
alias rot = _glas_srot
alias rot = glas_zdrot
alias rot = glas_csrot
alias rot = glas_srot
alias rot = glas_drot

Applies a plane rotation.

rotm
alias rotm = _glas_drotm
alias rotm = _glas_srotm
alias rotm = glas_drotm
alias rotm = glas_srotm

Applies a modified plane rotation.

scal
alias scal = _glas_zscal
alias scal = _glas_zdscal
alias scal = _glas_csIscal
alias scal = _glas_cscal
alias scal = _glas_csscal
alias scal = _glas_dscal
alias scal = _glas_sscal
alias scal = glas_zdIscal
alias scal = glas_zscal
alias scal = glas_zdscal
alias scal = glas_csIscal
alias scal = glas_cscal
alias scal = glas_csscal
alias scal = glas_dscal
alias scal = glas_sscal
alias scal = _glas_zdIscal

scal scales a vector by a constant.

swap
alias swap = _glas_zswap
alias swap = _glas_cswap
alias swap = _glas_dswap
alias swap = _glas_sswap
alias swap = glas_zswap
alias swap = glas_cswap
alias swap = glas_dswap
alias swap = glas_sswap

swap interchanges two vectors.

symm
alias symm = glas_zsymm
alias symm = glas_csymm
alias symm = glas_dsymm
alias symm = glas_ssymm

Performs symmetric or hermitian matrix-matrix multiplication.

validate_gemm
alias validate_gemm = glas_validate_gemm

Validates input data for GEMM operations.

validate_symm
alias validate_symm = glas_validate_symm

Validates input data for SYMM operations.

Functions

_glas_caxpy
void _glas_caxpy(cfloat a, size_t n, ptrdiff_t incx, const(cfloat)* x, ptrdiff_t incy, cfloat* y)

Constant times a vector plus a vector.

_glas_ccopy
void _glas_ccopy(size_t n, ptrdiff_t incx, const(cfloat)* x, ptrdiff_t incy, cfloat* y)

copy copies a vector, x, to a vector, y.

_glas_cdotc
cfloat _glas_cdotc(size_t n, ptrdiff_t incx, const(cfloat)* x, ptrdiff_t incy, const(cfloat)* y)

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

_glas_cdotu
cfloat _glas_cdotu(size_t n, ptrdiff_t incx, const(cfloat)* x, ptrdiff_t incy, const(cfloat)* y)

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

_glas_csIscal
void _glas_csIscal(ifloat a, size_t n, ptrdiff_t incx, cfloat* x)
_glas_cscal
void _glas_cscal(cfloat a, size_t n, ptrdiff_t incx, cfloat* x)

scal scales a vector by a constant.

_glas_csrot
void _glas_csrot(size_t n, ptrdiff_t incx, cfloat* x, ptrdiff_t incy, cfloat* y, float c, float s)

Applies a plane rotation.

_glas_csscal
void _glas_csscal(float a, size_t n, ptrdiff_t incx, cfloat* x)

scal scales a vector by a constant.

_glas_cswap
void _glas_cswap(size_t n, ptrdiff_t incx, cfloat* x, ptrdiff_t incy, cfloat* y)

swap interchanges two vectors.

_glas_dasum
double _glas_dasum(size_t n, ptrdiff_t incx, const(double)* x)

Takes the sum of the absolute values.

_glas_daxpy
void _glas_daxpy(double a, size_t n, ptrdiff_t incx, const(double)* x, ptrdiff_t incy, double* y)

Constant times a vector plus a vector.

_glas_dcopy
void _glas_dcopy(size_t n, ptrdiff_t incx, const(double)* x, ptrdiff_t incy, double* y)

copy copies a vector, x, to a vector, y.

_glas_ddot
double _glas_ddot(size_t n, ptrdiff_t incx, const(double)* x, ptrdiff_t incy, const(double)* y)

Forms the dot product of two vectors. Uses unrolled loops for increments equal to one.

_glas_dnrm2
double _glas_dnrm2(size_t n, ptrdiff_t incx, const(double)* x)

Returns the euclidean norm of a vector via the function.

_glas_drot
void _glas_drot(size_t n, ptrdiff_t incx, double* x, ptrdiff_t incy, double* y, double c, double s)

Applies a plane rotation.

_glas_drotm
void _glas_drotm(size_t n, ptrdiff_t incx, double* x, ptrdiff_t incy, double* y, double[5] sparam)

Applies a modified plane rotation.

_glas_dscal
void _glas_dscal(double a, size_t n, ptrdiff_t incx, double* x)

scal scales a vector by a constant.

_glas_dsdot
double _glas_dsdot(size_t n, ptrdiff_t incx, const(float)* x, ptrdiff_t incy, const(float)* y)

Compute the inner product of two vectors with extended precision accumulation and result. Uses unrolled loops for increments equal to one.

_glas_dswap
void _glas_dswap(size_t n, ptrdiff_t incx, double* x, ptrdiff_t incy, double* y)

swap interchanges two vectors.

_glas_dzasum
double _glas_dzasum(size_t n, ptrdiff_t incx, const(cdouble)* x)

Takes the sum of the absolute values.

_glas_dznrm2
double _glas_dznrm2(size_t n, ptrdiff_t incx, const(cdouble)* x)

Returns the euclidean norm of a vector via the function.

_glas_icamax
ptrdiff_t _glas_icamax(size_t n, ptrdiff_t incx, const(cfloat)* x)
_glas_idamax
ptrdiff_t _glas_idamax(size_t n, ptrdiff_t incx, const(double)* x)
_glas_isamax
ptrdiff_t _glas_isamax(size_t n, ptrdiff_t incx, const(float)* x)
_glas_izamax
ptrdiff_t _glas_izamax(size_t n, ptrdiff_t incx, const(cdouble)* x)

Finds the index of the first element having maximum |Re(.)| + |Im(.)|.

_glas_sasum
float _glas_sasum(size_t n, ptrdiff_t incx, const(float)* x)

Takes the sum of the absolute values.

_glas_saxpy
void _glas_saxpy(float a, size_t n, ptrdiff_t incx, const(float)* x, ptrdiff_t incy, float* y)

Constant times a vector plus a vector.

_glas_scasum
float _glas_scasum(size_t n, ptrdiff_t incx, const(cfloat)* x)

Takes the sum of the absolute values.

_glas_scnrm2
float _glas_scnrm2(size_t n, ptrdiff_t incx, const(cfloat)* x)

Returns the euclidean norm of a vector via the function.

_glas_scopy
void _glas_scopy(size_t n, ptrdiff_t incx, const(float)* x, ptrdiff_t incy, float* y)

copy copies a vector, x, to a vector, y.

_glas_sdot
float _glas_sdot(size_t n, ptrdiff_t incx, const(float)* x, ptrdiff_t incy, const(float)* y)

Forms the dot product of two vectors. Uses unrolled loops for increments equal to one.

_glas_snrm2
float _glas_snrm2(size_t n, ptrdiff_t incx, const(float)* x)

Returns the euclidean norm of a vector via the function.

_glas_srot
void _glas_srot(size_t n, ptrdiff_t incx, float* x, ptrdiff_t incy, float* y, float c, float s)

Applies a plane rotation.

_glas_srotm
void _glas_srotm(size_t n, ptrdiff_t incx, float* x, ptrdiff_t incy, float* y, float[5] sparam)

Applies a modified plane rotation.

_glas_sscal
void _glas_sscal(float a, size_t n, ptrdiff_t incx, float* x)

scal scales a vector by a constant.

_glas_sswap
void _glas_sswap(size_t n, ptrdiff_t incx, float* x, ptrdiff_t incy, float* y)

swap interchanges two vectors.

_glas_zaxpy
void _glas_zaxpy(cdouble a, size_t n, ptrdiff_t incx, const(cdouble)* x, ptrdiff_t incy, cdouble* y)

Constant times a vector plus a vector.

_glas_zcopy
void _glas_zcopy(size_t n, ptrdiff_t incx, const(cdouble)* x, ptrdiff_t incy, cdouble* y)

copy copies a vector, x, to a vector, y.

_glas_zdIscal
void _glas_zdIscal(idouble a, size_t n, ptrdiff_t incx, cdouble* x)

scal scales a vector by a constant.

_glas_zdotc
cdouble _glas_zdotc(size_t n, ptrdiff_t incx, const(cdouble)* x, ptrdiff_t incy, const(cdouble)* y)

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

_glas_zdotu
cdouble _glas_zdotu(size_t n, ptrdiff_t incx, const(cdouble)* x, ptrdiff_t incy, const(cdouble)* y)

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

_glas_zdrot
void _glas_zdrot(size_t n, ptrdiff_t incx, cdouble* x, ptrdiff_t incy, cdouble* y, double c, double s)

Applies a plane rotation.

_glas_zdscal
void _glas_zdscal(double a, size_t n, ptrdiff_t incx, cdouble* x)
_glas_zscal
void _glas_zscal(cdouble a, size_t n, ptrdiff_t incx, cdouble* x)

scal scales a vector by a constant.

_glas_zswap
void _glas_zswap(size_t n, ptrdiff_t incx, cdouble* x, ptrdiff_t incy, cdouble* y)

swap interchanges two vectors.

glas_caxpy
void glas_caxpy(cfloat a, Slice!(SliceKind.universal, [1], const(cfloat)*) xsl, Slice!(SliceKind.universal, [1], float*) ysl)

Constant times a vector plus a vector.

glas_ccopy
void glas_ccopy(Slice!(SliceKind.universal, [1], const(cfloat)*) xsl, Slice!(SliceKind.universal, [1], float*) ysl)

copy copies a vector, x, to a vector, y.

glas_cdotc
cfloat glas_cdotc(Slice!(SliceKind.universal, [1], const(cfloat)*) xsl, Slice!(SliceKind.universal, [1], const(cfloat)*) ysl)

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

glas_cdotu
cfloat glas_cdotu(Slice!(SliceKind.universal, [1], const(cfloat)*) xsl, Slice!(SliceKind.universal, [1], const(cfloat)*) ysl)

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

glas_cgemm
void glas_cgemm(cfloat alpha, Slice!(SliceKind.universal, [2], const(cfloat)*) asl, Slice!(SliceKind.universal, [2], const(cfloat)*) bsl, cfloat beta, Slice!(SliceKind.universal, [2], cfloat*) csl, ulong settings)

Performs general matrix-matrix multiplication.

glas_csIscal
void glas_csIscal(ifloat a, Slice!(SliceKind.universal, [1], cfloat*) xsl)
glas_cscal
void glas_cscal(cfloat a, Slice!(SliceKind.universal, [1], cfloat*) xsl)

scal scales a vector by a constant.

glas_csrot
void glas_csrot(Slice!(SliceKind.universal, [1], cfloat*) xsl, Slice!(SliceKind.universal, [1], float*) ysl, float c, float s)

Applies a plane rotation.

glas_csscal
void glas_csscal(float a, Slice!(SliceKind.universal, [1], cfloat*) xsl)

scal scales a vector by a constant.

glas_cswap
void glas_cswap(Slice!(SliceKind.universal, [1], cfloat*) xsl, Slice!(SliceKind.universal, [1], float*) ysl)

swap interchanges two vectors.

glas_csymm
void glas_csymm(cfloat alpha, Slice!(SliceKind.universal, [2], const(cfloat)*) asl, Slice!(SliceKind.universal, [2], const(cfloat)*) bsl, cfloat beta, Slice!(SliceKind.universal, [2], cfloat*) csl, ulong settings)

Performs symmetric or hermitian matrix-matrix multiplication.

glas_dasum
double glas_dasum(Slice!(SliceKind.universal, [1], const(double)*) xsl)

Takes the sum of the absolute values.

glas_daxpy
void glas_daxpy(double a, Slice!(SliceKind.universal, [1], const(double)*) xsl, Slice!(SliceKind.universal, [1], double*) ysl)

Constant times a vector plus a vector.

glas_dcopy
void glas_dcopy(Slice!(SliceKind.universal, [1], const(double)*) xsl, Slice!(SliceKind.universal, [1], double*) ysl)

copy copies a vector, x, to a vector, y.

glas_ddot
double glas_ddot(Slice!(SliceKind.universal, [1], const(double)*) xsl, Slice!(SliceKind.universal, [1], const(double)*) ysl)

Forms the dot product of two vectors. Uses unrolled loops for increments equal to one.

glas_dgemm
void glas_dgemm(double alpha, Slice!(SliceKind.universal, [2], const(double)*) asl, Slice!(SliceKind.universal, [2], const(double)*) bsl, double beta, Slice!(SliceKind.universal, [2], double*) csl, ulong settings)

Performs general matrix-matrix multiplication.

glas_dnrm2
double glas_dnrm2(Slice!(SliceKind.universal, [1], const(double)*) xsl)

Returns the euclidean norm of a vector via the function.

glas_drot
void glas_drot(Slice!(SliceKind.universal, [1], double*) xsl, Slice!(SliceKind.universal, [1], double*) ysl, double c, double s)

Applies a plane rotation.

glas_drotm
void glas_drotm(Slice!(SliceKind.universal, [1], double*) xsl, Slice!(SliceKind.universal, [1], double*) ysl, double[5] sparam)

Applies a modified plane rotation.

glas_dscal
void glas_dscal(double a, Slice!(SliceKind.universal, [1], double*) xsl)

scal scales a vector by a constant.

glas_dsdot
double glas_dsdot(Slice!(SliceKind.universal, [1], const(float)*) xsl, Slice!(SliceKind.universal, [1], const(float)*) ysl)

Compute the inner product of two vectors with extended precision accumulation and result. Uses unrolled loops for increments equal to one.

glas_dswap
void glas_dswap(Slice!(SliceKind.universal, [1], double*) xsl, Slice!(SliceKind.universal, [1], double*) ysl)

swap interchanges two vectors.

glas_dsymm
void glas_dsymm(double alpha, Slice!(SliceKind.universal, [2], const(double)*) asl, Slice!(SliceKind.universal, [2], const(double)*) bsl, double beta, Slice!(SliceKind.universal, [2], double*) csl, ulong settings)

Performs symmetric or hermitian matrix-matrix multiplication.

glas_dzasum
double glas_dzasum(Slice!(SliceKind.universal, [1], const(cdouble)*) xsl)

Takes the sum of the absolute values.

glas_dznrm2
double glas_dznrm2(Slice!(SliceKind.universal, [1], const(cdouble)*) xsl)

Returns the euclidean norm of a vector via the function.

glas_error
string glas_error(int error_code)
glas_icamax
ptrdiff_t glas_icamax(Slice!(SliceKind.universal, [1], const(cfloat)*) xsl)
glas_idamax
ptrdiff_t glas_idamax(Slice!(SliceKind.universal, [1], const(double)*) xsl)

Finds the index of the first element having maximum |Re(.)| + |Im(.)|.

glas_isamax
ptrdiff_t glas_isamax(Slice!(SliceKind.universal, [1], const(float)*) xsl)
glas_izamax
ptrdiff_t glas_izamax(Slice!(SliceKind.universal, [1], const(cdouble)*) xsl)

Finds the index of the first element having maximum |Re(.)| + |Im(.)|.

glas_sasum
float glas_sasum(Slice!(SliceKind.universal, [1], const(float)*) xsl)

Takes the sum of the absolute values.

glas_saxpy
void glas_saxpy(float a, Slice!(SliceKind.universal, [1], const(float)*) xsl, Slice!(SliceKind.universal, [1], float*) ysl)

Constant times a vector plus a vector.

glas_scasum
float glas_scasum(Slice!(SliceKind.universal, [1], const(cfloat)*) xsl)

Takes the sum of the absolute values.

glas_scnrm2
float glas_scnrm2(Slice!(SliceKind.universal, [1], const(cfloat)*) xsl)

Returns the euclidean norm of a vector via the function.

glas_scopy
void glas_scopy(Slice!(SliceKind.universal, [1], const(float)*) xsl, Slice!(SliceKind.universal, [1], float*) ysl)

copy copies a vector, x, to a vector, y.

glas_sdot
float glas_sdot(Slice!(SliceKind.universal, [1], const(float)*) xsl, Slice!(SliceKind.universal, [1], const(float)*) ysl)

Forms the dot product of two vectors. Uses unrolled loops for increments equal to one.

glas_sgemm
void glas_sgemm(float alpha, Slice!(SliceKind.universal, [2], const(float)*) asl, Slice!(SliceKind.universal, [2], const(float)*) bsl, float beta, Slice!(SliceKind.universal, [2], float*) csl, ulong settings)

Performs general matrix-matrix multiplication.

glas_snrm2
float glas_snrm2(Slice!(SliceKind.universal, [1], const(float)*) xsl)

Returns the euclidean norm of a vector via the function.

glas_srot
void glas_srot(Slice!(SliceKind.universal, [1], float*) xsl, Slice!(SliceKind.universal, [1], float*) ysl, float c, float s)

Applies a plane rotation.

glas_srotm
void glas_srotm(Slice!(SliceKind.universal, [1], float*) xsl, Slice!(SliceKind.universal, [1], float*) ysl, float[5] sparam)

Applies a modified plane rotation.

glas_sscal
void glas_sscal(float a, Slice!(SliceKind.universal, [1], float*) xsl)

scal scales a vector by a constant.

glas_sswap
void glas_sswap(Slice!(SliceKind.universal, [1], float*) xsl, Slice!(SliceKind.universal, [1], float*) ysl)

swap interchanges two vectors.

glas_ssymm
void glas_ssymm(float alpha, Slice!(SliceKind.universal, [2], const(float)*) asl, Slice!(SliceKind.universal, [2], const(float)*) bsl, float beta, Slice!(SliceKind.universal, [2], float*) csl, ulong settings)

Performs symmetric or hermitian matrix-matrix multiplication.

glas_validate_gemm
int glas_validate_gemm(Structure!2 as, Structure!2 bs, Structure!2 cs, ulong settings)

Validates input data for GEMM operations.

glas_validate_symm
int glas_validate_symm(Structure!2 as, Structure!2 bs, Structure!2 cs, ulong settings)

Validates input data for SYMM operations.

glas_zaxpy
void glas_zaxpy(cdouble a, Slice!(SliceKind.universal, [1], const(cdouble)*) xsl, Slice!(SliceKind.universal, [1], cdouble*) ysl)

Constant times a vector plus a vector.

glas_zcopy
void glas_zcopy(Slice!(SliceKind.universal, [1], const(cdouble)*) xsl, Slice!(SliceKind.universal, [1], cdouble*) ysl)

copy copies a vector, x, to a vector, y.

glas_zdIscal
void glas_zdIscal(idouble a, Slice!(SliceKind.universal, [1], cdouble*) xsl)

scal scales a vector by a constant.

glas_zdotc
cdouble glas_zdotc(Slice!(SliceKind.universal, [1], const(cdouble)*) xsl, Slice!(SliceKind.universal, [1], const(cdouble)*) ysl)

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

glas_zdotu
cdouble glas_zdotu(Slice!(SliceKind.universal, [1], const(cdouble)*) xsl, Slice!(SliceKind.universal, [1], const(cdouble)*) ysl)

Forms the dot product of two complex vectors. Uses unrolled loops for increments equal to one.

glas_zdrot
void glas_zdrot(Slice!(SliceKind.universal, [1], cdouble*) xsl, Slice!(SliceKind.universal, [1], cdouble*) ysl, double c, double s)

Applies a plane rotation.

glas_zdscal
void glas_zdscal(double a, Slice!(SliceKind.universal, [1], cdouble*) xsl)

scal scales a vector by a constant.

glas_zgemm
void glas_zgemm(cdouble alpha, Slice!(SliceKind.universal, [2], const(cdouble)*) asl, Slice!(SliceKind.universal, [2], const(cdouble)*) bsl, cdouble beta, Slice!(SliceKind.universal, [2], cdouble*) csl, ulong settings)

Performs general matrix-matrix multiplication.

glas_zscal
void glas_zscal(cdouble a, Slice!(SliceKind.universal, [1], cdouble*) xsl)

scal scales a vector by a constant.

glas_zswap
void glas_zswap(Slice!(SliceKind.universal, [1], cdouble*) xsl, Slice!(SliceKind.universal, [1], cdouble*) ysl)

swap interchanges two vectors.

glas_zsymm
void glas_zsymm(cdouble alpha, Slice!(SliceKind.universal, [2], const(cdouble)*) asl, Slice!(SliceKind.universal, [2], const(cdouble)*) bsl, cdouble beta, Slice!(SliceKind.universal, [2], cdouble*) csl, ulong settings)

Performs symmetric or hermitian matrix-matrix multiplication.

Variables

ConjA
enum ulong ConjA;

Specifies if the matrix asl stores conjugated elements.

ConjB
enum ulong ConjB;

Specifies if the matrix bsl stores conjugated elements.

Left
enum ulong Left;

Specifies if the symmetric/hermitian matrix A appears on the left in the operation.

Lower
enum ulong Lower;

Specifies if the lower triangular part of the symmetric matrix A is to be referenced.

Right
enum ulong Right;

Specifies if the symmetric/hermitian matrix A appears on the left in the operation.

Upper
enum ulong Upper;

Specifies if the upper triangular part of the symmetric matrix A is to be referenced.

Meta

Authors

Ilya Yaroshenko

Transposition

GLAS does not require transposition parameters. Use transposed to perform zero cost ndslice transposition.

Note: ndslice uses is row major representation.