The OpenD Programming Language

glas.ndslice

GLAS API

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

Source

See Source File

License

Boost License 1.0.

Copyright

Copyright © 2016-, Ilya Yaroshenko.

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.

glas modules