use blas_sys::fortran as ffi;
use libc::c_char;
use {c32, c64};
#[inline]
pub fn srotg(a: &mut f32, b: &mut f32, c: &mut f32, s: &mut f32) {
unsafe {
ffi::srotg_(a, b, c, s)
}
}
#[inline]
pub fn srotmg(d1: &mut f32, d2: &mut f32, x1: &mut f32, y1: f32, param: &mut [f32]) {
unsafe {
ffi::srotmg_(d1, d2, x1, &y1, param.as_mut_ptr())
}
}
#[inline]
pub fn srot(n: i32, x: &mut [f32], incx: i32, y: &mut [f32], incy: i32, c: f32, s: f32) {
unsafe {
ffi::srot_(&n, x.as_mut_ptr(), &incx, y.as_mut_ptr(), &incy, &c, &s)
}
}
#[inline]
pub fn srotm(n: i32, x: &mut [f32], incx: i32, y: &mut [f32], incy: i32, param: &[f32]) {
unsafe {
ffi::srotm_(&n, x.as_mut_ptr(), &incx, y.as_mut_ptr(), &incy, param.as_ptr())
}
}
#[inline]
pub fn sswap(n: i32, x: &mut [f32], incx: i32, y: &mut [f32], incy: i32) {
unsafe {
ffi::sswap_(&n, x.as_mut_ptr(), &incx, y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn sscal(n: i32, a: f32, x: &mut [f32], incx: i32) {
unsafe {
ffi::sscal_(&n, &a, x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn scopy(n: i32, x: &[f32], incx: i32, y: &mut [f32], incy: i32) {
unsafe {
ffi::scopy_(&n, x.as_ptr(), &incx, y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn saxpy(n: i32, alpha: f32, x: &[f32], incx: i32, y: &mut [f32], incy: i32) {
unsafe {
ffi::saxpy_(&n, &alpha, x.as_ptr(), &incx, y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn sdot(n: i32, x: &[f32], incx: i32, y: &[f32], incy: i32) -> f32 {
unsafe {
ffi::sdot_(&n, x.as_ptr(), &incx, y.as_ptr(), &incy)
}
}
#[inline]
pub fn sdsdot(n: i32, sb: &[f32], x: &[f32], incx: i32, y: &[f32], incy: i32) -> f32 {
unsafe {
ffi::sdsdot_(&n, sb.as_ptr(), x.as_ptr(), &incx, y.as_ptr(), &incy)
}
}
#[inline]
pub fn snrm2(n: i32, x: &[f32], incx: i32) -> f32 {
unsafe {
ffi::snrm2_(&n, x.as_ptr(), &incx)
}
}
#[inline]
pub fn scnrm2(n: i32, x: &[c32], incx: i32) -> f32 {
unsafe {
ffi::scnrm2_(&n, x.as_ptr() as *const _, &incx)
}
}
#[inline]
pub fn sasum(n: i32, x: &[f32], incx: i32) -> f32 {
unsafe {
ffi::sasum_(&n, x.as_ptr(), &incx)
}
}
#[inline]
pub fn isamax(n: i32, x: &[f32], incx: i32) -> usize {
unsafe {
ffi::isamax_(&n, x.as_ptr(), &incx) as usize
}
}
#[inline]
pub fn drotg(a: &mut f64, b: &mut f64, c: &mut f64, s: &mut f64) {
unsafe {
ffi::drotg_(a, b, c, s)
}
}
#[inline]
pub fn drotmg(d1: &mut f64, d2: &mut f64, x1: &mut f64, y1: f64, param: &mut [f64]) {
unsafe {
ffi::drotmg_(d1, d2, x1, &y1, param.as_mut_ptr())
}
}
#[inline]
pub fn drot(n: i32, x: &mut [f64], incx: i32, y: &mut [f64], incy: i32, c: f64, s: f64) {
unsafe {
ffi::drot_(&n, x.as_mut_ptr(), &incx, y.as_mut_ptr(), &incy, &c, &s)
}
}
#[inline]
pub fn drotm(n: i32, x: &mut [f64], incx: i32, y: &mut [f64], incy: i32, param: &[f64]) {
unsafe {
ffi::drotm_(&n, x.as_mut_ptr(), &incx, y.as_mut_ptr(), &incy, param.as_ptr())
}
}
#[inline]
pub fn dswap(n: i32, x: &mut [f64], incx: i32, y: &mut [f64], incy: i32) {
unsafe {
ffi::dswap_(&n, x.as_mut_ptr(), &incx, y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn dscal(n: i32, a: f64, x: &mut [f64], incx: i32) {
unsafe {
ffi::dscal_(&n, &a, x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn dcopy(n: i32, x: &[f64], incx: i32, y: &mut [f64], incy: i32) {
unsafe {
ffi::dcopy_(&n, x.as_ptr(), &incx, y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn daxpy(n: i32, alpha: f64, x: &[f64], incx: i32, y: &mut [f64], incy: i32) {
unsafe {
ffi::daxpy_(&n, &alpha, x.as_ptr(), &incx, y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn ddot(n: i32, x: &[f64], incx: i32, y: &[f64], incy: i32) -> f64 {
unsafe {
ffi::ddot_(&n, x.as_ptr(), &incx, y.as_ptr(), &incy)
}
}
#[inline]
pub fn dsdot(n: i32, x: &[f32], incx: i32, y: &[f32], incy: i32) -> f64 {
unsafe {
ffi::dsdot_(&n, x.as_ptr(), &incx, y.as_ptr(), &incy)
}
}
#[inline]
pub fn dnrm2(n: i32, x: &[f64], incx: i32) -> f64 {
unsafe {
ffi::dnrm2_(&n, x.as_ptr(), &incx)
}
}
#[inline]
pub fn dznrm2(n: i32, x: &[c64], incx: i32) -> f64 {
unsafe {
ffi::dznrm2_(&n, x.as_ptr() as *const _, &incx)
}
}
#[inline]
pub fn dasum(n: i32, x: &[f64], incx: i32) -> f64 {
unsafe {
ffi::dasum_(&n, x.as_ptr(), &incx)
}
}
#[inline]
pub fn idamax(n: i32, x: &[f64], incx: i32) -> usize {
unsafe {
ffi::idamax_(&n, x.as_ptr(), &incx) as usize
}
}
#[inline]
pub fn crotg(a: &mut c32, b: c32, c: &mut f32, s: &mut c32) {
unsafe {
ffi::crotg_(a as *mut _ as *mut _, &b as *const _ as *const _, c, s as *mut _ as *mut _)
}
}
#[inline]
pub fn csrot(n: i32, x: &mut [c32], incx: i32, y: &mut [c32], incy: i32, c: f32, s: f32) {
unsafe {
ffi::csrot_(&n, x.as_mut_ptr() as *mut _, &incx, y.as_mut_ptr() as *mut _, &incy, &c, &s)
}
}
#[inline]
pub fn cswap(n: i32, x: &mut [c32], incx: i32, y: &mut [c32], incy: i32) {
unsafe {
ffi::cswap_(&n, x.as_mut_ptr() as *mut _, &incx, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn cscal(n: i32, a: c32, x: &mut [c32], incx: i32) {
unsafe {
ffi::cscal_(&n, &a as *const _ as *const _, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn csscal(n: i32, a: f32, x: &mut [c32], incx: i32) {
unsafe {
ffi::csscal_(&n, &a, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ccopy(n: i32, x: &[c32], incx: i32, y: &mut [c32], incy: i32) {
unsafe {
ffi::ccopy_(&n, x.as_ptr() as *const _, &incx, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn caxpy(n: i32, alpha: c32, x: &[c32], incx: i32, y: &mut [c32], incy: i32) {
unsafe {
ffi::caxpy_(&n, &alpha as *const _ as *const _, x.as_ptr() as *const _, &incx,
y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn cdotu(pres: &mut [c32], n: i32, x: &[c32], incx: i32, y: &[c32], incy: i32) {
unsafe {
ffi::cdotu_(pres.as_mut_ptr() as *mut _, &n, x.as_ptr() as *const _, &incx,
y.as_ptr() as *const _, &incy)
}
}
#[inline]
pub fn cdotc(pres: &mut [c32], n: i32, x: &[c32], incx: i32, y: &[c32], incy: i32) {
unsafe {
ffi::cdotc_(pres.as_mut_ptr() as *mut _, &n, x.as_ptr() as *const _, &incx,
y.as_ptr() as *const _, &incy)
}
}
#[inline]
pub fn scasum(n: i32, x: &[c32], incx: i32) -> f32 {
unsafe {
ffi::scasum_(&n, x.as_ptr() as *const _, &incx)
}
}
#[inline]
pub fn icamax(n: i32, x: &[c32], incx: i32) -> usize {
unsafe {
ffi::icamax_(&n, x.as_ptr() as *const _, &incx) as usize
}
}
#[inline]
pub fn zrotg(a: &mut c64, b: c64, c: &mut f64, s: &mut c64) {
unsafe {
ffi::zrotg_(a as *mut _ as *mut _, &b as *const _ as *const _, c, s as *mut _ as *mut _)
}
}
#[inline]
pub fn zdrot(n: i32, x: &mut [c64], incx: i32, y: &mut [c64], incy: i32, c: f64, s: f64) {
unsafe {
ffi::zdrot_(&n, x.as_mut_ptr() as *mut _, &incx, y.as_mut_ptr() as *mut _, &incy, &c, &s)
}
}
#[inline]
pub fn zswap(n: i32, x: &mut [c64], incx: i32, y: &mut [c64], incy: i32) {
unsafe {
ffi::zswap_(&n, x.as_mut_ptr() as *mut _, &incx, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn zscal(n: i32, a: c64, x: &mut [c64], incx: i32) {
unsafe {
ffi::zscal_(&n, &a as *const _ as *const _, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn zdscal(n: i32, a: f64, x: &mut [c64], incx: i32) {
unsafe {
ffi::zdscal_(&n, &a, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn zcopy(n: i32, x: &[c64], incx: i32, y: &mut [c64], incy: i32) {
unsafe {
ffi::zcopy_(&n, x.as_ptr() as *const _, &incx, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn zaxpy(n: i32, alpha: c64, x: &[c64], incx: i32, y: &mut [c64], incy: i32) {
unsafe {
ffi::zaxpy_(&n, &alpha as *const _ as *const _, x.as_ptr() as *const _, &incx,
y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn zdotu(pres: &mut [c64], n: i32, x: &[c64], incx: i32, y: &[c64], incy: i32) {
unsafe {
ffi::zdotu_(pres.as_mut_ptr() as *mut _, &n, x.as_ptr() as *const _, &incx,
y.as_ptr() as *const _, &incy)
}
}
#[inline]
pub fn zdotc(pres: &mut [c64], n: i32, x: &[c64], incx: i32, y: &[c64], incy: i32) {
unsafe {
ffi::zdotc_(pres.as_mut_ptr() as *mut _, &n, x.as_ptr() as *const _, &incx,
y.as_ptr() as *const _, &incy)
}
}
#[inline]
pub fn dzasum(n: i32, x: &[c64], incx: i32) -> f64 {
unsafe {
ffi::dzasum_(&n, x.as_ptr() as *const _, &incx)
}
}
#[inline]
pub fn izamax(n: i32, x: &[c64], incx: i32) -> usize {
unsafe {
ffi::izamax_(&n, x.as_ptr() as *const _, &incx) as usize
}
}
#[inline]
pub fn sgemv(trans: u8, m: i32, n: i32, alpha: f32, a: &[f32], lda: i32, x: &[f32], incx: i32,
beta: f32, y: &mut [f32], incy: i32) {
unsafe {
ffi::sgemv_(&(trans as c_char), &m, &n, &alpha, a.as_ptr(), &lda, x.as_ptr(), &incx, &beta,
y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn sgbmv(trans: u8, m: i32, n: i32, kl: i32, ku: i32, alpha: f32, a: &[f32], lda: i32,
x: &[f32], incx: i32, beta: f32, y: &mut [f32], incy: i32) {
unsafe {
ffi::sgbmv_(&(trans as c_char), &m, &n, &kl, &ku, &alpha, a.as_ptr(), &lda, x.as_ptr(),
&incx, &beta, y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn ssymv(uplo: u8, n: i32, alpha: f32, a: &[f32], lda: i32, x: &[f32], incx: i32, beta: f32,
y: &mut [f32], incy: i32) {
unsafe {
ffi::ssymv_(&(uplo as c_char), &n, &alpha, a.as_ptr(), &lda, x.as_ptr(), &incx, &beta,
y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn ssbmv(uplo: u8, n: i32, k: i32, alpha: f32, a: &[f32], lda: i32, x: &[f32], incx: i32,
beta: f32, y: &mut [f32], incy: i32) {
unsafe {
ffi::ssbmv_(&(uplo as c_char), &n, &k, &alpha, a.as_ptr(), &lda, x.as_ptr(), &incx, &beta,
y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn sspmv(uplo: u8, n: i32, alpha: f32, ap: &[f32], x: &[f32], incx: i32, beta: f32,
y: &mut [f32], incy: i32) {
unsafe {
ffi::sspmv_(&(uplo as c_char), &n, &alpha, ap.as_ptr(), x.as_ptr(), &incx, &beta,
y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn strmv(uplo: u8, transa: u8, diag: u8, n: i32, a: &[f32], lda: i32, b: &mut [f32],
incx: i32) {
unsafe {
ffi::strmv_(&(uplo as c_char), &(transa as c_char), &(diag as c_char), &n, a.as_ptr(),
&lda, b.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn stbmv(uplo: u8, trans: u8, diag: u8, n: i32, k: i32, a: &[f32], lda: i32, x: &mut [f32],
incx: i32) {
unsafe {
ffi::stbmv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, &k, a.as_ptr(),
&lda, x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn stpmv(uplo: u8, trans: u8, diag: u8, n: i32, ap: &[f32], x: &mut [f32], incx: i32) {
unsafe {
ffi::stpmv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, ap.as_ptr(),
x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn strsv(uplo: u8, trans: u8, diag: u8, n: i32, a: &[f32], lda: i32, x: &mut [f32],
incx: i32) {
unsafe {
ffi::strsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, a.as_ptr(), &lda,
x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn stbsv(uplo: u8, trans: u8, diag: u8, n: i32, k: i32, a: &[f32], lda: i32, x: &mut [f32],
incx: i32) {
unsafe {
ffi::stbsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, &k, a.as_ptr(),
&lda, x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn stpsv(uplo: u8, trans: u8, diag: u8, n: i32, ap: &[f32], x: &mut [f32], incx: i32) {
unsafe {
ffi::stpsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, ap.as_ptr(),
x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn sger(m: i32, n: i32, alpha: f32, x: &[f32], incx: i32, y: &[f32], incy: i32, a: &mut [f32],
lda: i32) {
unsafe {
ffi::sger_(&m, &n, &alpha, x.as_ptr(), &incx, y.as_ptr(), &incy, a.as_mut_ptr(), &lda)
}
}
#[inline]
pub fn ssyr(uplo: u8, n: i32, alpha: f32, x: &[f32], incx: i32, a: &mut [f32], lda: i32) {
unsafe {
ffi::ssyr_(&(uplo as c_char), &n, &alpha, x.as_ptr(), &incx, a.as_mut_ptr(), &lda)
}
}
#[inline]
pub fn sspr(uplo: u8, n: i32, alpha: f32, x: &[f32], incx: i32, ap: &mut [f32]) {
unsafe {
ffi::sspr_(&(uplo as c_char), &n, &alpha, x.as_ptr(), &incx, ap.as_mut_ptr())
}
}
#[inline]
pub fn ssyr2(uplo: u8, n: i32, alpha: f32, x: &[f32], incx: i32, y: &[f32], incy: i32,
a: &mut [f32], lda: i32) {
unsafe {
ffi::ssyr2_(&(uplo as c_char), &n, &alpha, x.as_ptr(), &incx, y.as_ptr(), &incy,
a.as_mut_ptr(), &lda)
}
}
#[inline]
pub fn sspr2(uplo: u8, n: i32, alpha: f32, x: &[f32], incx: i32, y: &[f32], incy: i32,
ap: &mut [f32]) {
unsafe {
ffi::sspr2_(&(uplo as c_char), &n, &alpha, x.as_ptr(), &incx, y.as_ptr(), &incy,
ap.as_mut_ptr())
}
}
#[inline]
pub fn dgemv(trans: u8, m: i32, n: i32, alpha: f64, a: &[f64], lda: i32, x: &[f64], incx: i32,
beta: f64, y: &mut [f64], incy: i32) {
unsafe {
ffi::dgemv_(&(trans as c_char), &m, &n, &alpha, a.as_ptr(), &lda, x.as_ptr(), &incx, &beta,
y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn dgbmv(trans: u8, m: i32, n: i32, kl: i32, ku: i32, alpha: f64, a: &[f64], lda: i32,
x: &[f64], incx: i32, beta: f64, y: &mut [f64], incy: i32) {
unsafe {
ffi::dgbmv_(&(trans as c_char), &m, &n, &kl, &ku, &alpha, a.as_ptr(), &lda, x.as_ptr(),
&incx, &beta, y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn dsymv(uplo: u8, n: i32, alpha: f64, a: &[f64], lda: i32, x: &[f64], incx: i32, beta: f64,
y: &mut [f64], incy: i32) {
unsafe {
ffi::dsymv_(&(uplo as c_char), &n, &alpha, a.as_ptr(), &lda, x.as_ptr(), &incx, &beta,
y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn dsbmv(uplo: u8, n: i32, k: i32, alpha: f64, a: &[f64], lda: i32, x: &[f64], incx: i32,
beta: f64, y: &mut [f64], incy: i32) {
unsafe {
ffi::dsbmv_(&(uplo as c_char), &n, &k, &alpha, a.as_ptr(), &lda, x.as_ptr(), &incx, &beta,
y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn dspmv(uplo: u8, n: i32, alpha: f64, ap: &[f64], x: &[f64], incx: i32, beta: f64,
y: &mut [f64], incy: i32) {
unsafe {
ffi::dspmv_(&(uplo as c_char), &n, &alpha, ap.as_ptr(), x.as_ptr(), &incx, &beta,
y.as_mut_ptr(), &incy)
}
}
#[inline]
pub fn dtrmv(uplo: u8, transa: u8, diag: u8, n: i32, a: &[f64], lda: i32, b: &mut [f64],
incx: i32) {
unsafe {
ffi::dtrmv_(&(uplo as c_char), &(transa as c_char), &(diag as c_char), &n, a.as_ptr(),
&lda, b.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn dtbmv(uplo: u8, trans: u8, diag: u8, n: i32, k: i32, a: &[f64], lda: i32, x: &mut [f64],
incx: i32) {
unsafe {
ffi::dtbmv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, &k, a.as_ptr(),
&lda, x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn dtpmv(uplo: u8, trans: u8, diag: u8, n: i32, ap: &[f64], x: &mut [f64], incx: i32) {
unsafe {
ffi::dtpmv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, ap.as_ptr(),
x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn dtrsv(uplo: u8, trans: u8, diag: u8, n: i32, a: &[f64], lda: i32, x: &mut [f64],
incx: i32) {
unsafe {
ffi::dtrsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, a.as_ptr(), &lda,
x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn dtbsv(uplo: u8, trans: u8, diag: u8, n: i32, k: i32, a: &[f64], lda: i32, x: &mut [f64],
incx: i32) {
unsafe {
ffi::dtbsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, &k, a.as_ptr(),
&lda, x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn dtpsv(uplo: u8, trans: u8, diag: u8, n: i32, ap: &[f64], x: &mut [f64], incx: i32) {
unsafe {
ffi::dtpsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, ap.as_ptr(),
x.as_mut_ptr(), &incx)
}
}
#[inline]
pub fn dger(m: i32, n: i32, alpha: f64, x: &[f64], incx: i32, y: &[f64], incy: i32, a: &mut [f64],
lda: i32) {
unsafe {
ffi::dger_(&m, &n, &alpha, x.as_ptr(), &incx, y.as_ptr(), &incy, a.as_mut_ptr(), &lda)
}
}
#[inline]
pub fn dsyr(uplo: u8, n: i32, alpha: f64, x: &[f64], incx: i32, a: &mut [f64], lda: i32) {
unsafe {
ffi::dsyr_(&(uplo as c_char), &n, &alpha, x.as_ptr(), &incx, a.as_mut_ptr(), &lda)
}
}
#[inline]
pub fn dspr(uplo: u8, n: i32, alpha: f64, x: &[f64], incx: i32, ap: &mut [f64]) {
unsafe {
ffi::dspr_(&(uplo as c_char), &n, &alpha, x.as_ptr(), &incx, ap.as_mut_ptr())
}
}
#[inline]
pub fn dsyr2(uplo: u8, n: i32, alpha: f64, x: &[f64], incx: i32, y: &[f64], incy: i32,
a: &mut [f64], lda: i32) {
unsafe {
ffi::dsyr2_(&(uplo as c_char), &n, &alpha, x.as_ptr(), &incx, y.as_ptr(), &incy,
a.as_mut_ptr(), &lda)
}
}
#[inline]
pub fn dspr2(uplo: u8, n: i32, alpha: f64, x: &[f64], incx: i32, y: &[f64], incy: i32,
ap: &mut [f64]) {
unsafe {
ffi::dspr2_(&(uplo as c_char), &n, &alpha, x.as_ptr(), &incx, y.as_ptr(), &incy,
ap.as_mut_ptr())
}
}
#[inline]
pub fn cgemv(trans: u8, m: i32, n: i32, alpha: c32, a: &[c32], lda: i32, x: &[c32], incx: i32,
beta: c32, y: &mut [c32], incy: i32) {
unsafe {
ffi::cgemv_(&(trans as c_char), &m, &n, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, x.as_ptr() as *const _, &incx,
&beta as *const _ as *const _, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn cgbmv(trans: u8, m: i32, n: i32, kl: i32, ku: i32, alpha: c32, a: &[c32], lda: i32,
x: &[c32], incx: i32, beta: c32, y: &mut [c32], incy: i32) {
unsafe {
ffi::cgbmv_(&(trans as c_char), &m, &n, &kl, &ku, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, x.as_ptr() as *const _, &incx,
&beta as *const _ as *const _, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn chemv(uplo: u8, n: i32, alpha: c32, a: &[c32], lda: i32, x: &[c32], incx: i32, beta: c32,
y: &mut [c32], incy: i32) {
unsafe {
ffi::chemv_(&(uplo as c_char), &n, &alpha as *const _ as *const _, a.as_ptr() as *const _,
&lda, x.as_ptr() as *const _, &incx, &beta as *const _ as *const _,
y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn chbmv(uplo: u8, n: i32, k: i32, alpha: c32, a: &[c32], lda: i32, x: &[c32], incx: i32,
beta: c32, y: &mut [c32], incy: i32) {
unsafe {
ffi::chbmv_(&(uplo as c_char), &n, &k, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, x.as_ptr() as *const _, &incx,
&beta as *const _ as *const _, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn chpmv(uplo: u8, n: i32, alpha: c32, ap: &[c32], x: &[c32], incx: i32, beta: c32,
y: &mut [c32], incy: i32) {
unsafe {
ffi::chpmv_(&(uplo as c_char), &n, &alpha as *const _ as *const _, ap.as_ptr() as *const _,
x.as_ptr() as *const _, &incx, &beta as *const _ as *const _,
y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn ctrmv(uplo: u8, transa: u8, diag: u8, n: i32, a: &[c32], lda: i32, b: &mut [c32],
incx: i32) {
unsafe {
ffi::ctrmv_(&(uplo as c_char), &(transa as c_char), &(diag as c_char), &n,
a.as_ptr() as *const _, &lda, b.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ctbmv(uplo: u8, trans: u8, diag: u8, n: i32, k: i32, a: &[c32], lda: i32, x: &mut [c32],
incx: i32) {
unsafe {
ffi::ctbmv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, &k,
a.as_ptr() as *const _, &lda, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ctpmv(uplo: u8, trans: u8, diag: u8, n: i32, ap: &[c32], x: &mut [c32], incx: i32) {
unsafe {
ffi::ctpmv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n,
ap.as_ptr() as *const _, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ctrsv(uplo: u8, trans: u8, diag: u8, n: i32, a: &[c32], lda: i32, x: &mut [c32],
incx: i32) {
unsafe {
ffi::ctrsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n,
a.as_ptr() as *const _, &lda, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ctbsv(uplo: u8, trans: u8, diag: u8, n: i32, k: i32, a: &[c32], lda: i32, x: &mut [c32],
incx: i32) {
unsafe {
ffi::ctbsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, &k,
a.as_ptr() as *const _, &lda, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ctpsv(uplo: u8, trans: u8, diag: u8, n: i32, ap: &[c32], x: &mut [c32], incx: i32) {
unsafe {
ffi::ctpsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n,
ap.as_ptr() as *const _, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn cgeru(m: i32, n: i32, alpha: c32, x: &[c32], incx: i32, y: &[c32], incy: i32, a: &mut [c32],
lda: i32) {
unsafe {
ffi::cgeru_(&m, &n, &alpha as *const _ as *const _, x.as_ptr() as *const _, &incx,
y.as_ptr() as *const _, &incy, a.as_mut_ptr() as *mut _, &lda)
}
}
#[inline]
pub fn cgerc(m: i32, n: i32, alpha: c32, x: &[c32], incx: i32, y: &[c32], incy: i32, a: &mut [c32],
lda: i32) {
unsafe {
ffi::cgerc_(&m, &n, &alpha as *const _ as *const _, x.as_ptr() as *const _, &incx,
y.as_ptr() as *const _, &incy, a.as_mut_ptr() as *mut _, &lda)
}
}
#[inline]
pub fn cher(uplo: u8, n: i32, alpha: f32, x: &[c32], incx: i32, a: &mut [c32], lda: i32) {
unsafe {
ffi::cher_(&(uplo as c_char), &n, &alpha, x.as_ptr() as *const _, &incx,
a.as_mut_ptr() as *mut _, &lda)
}
}
#[inline]
pub fn chpr(uplo: u8, n: i32, alpha: f32, x: &[c32], incx: i32, ap: &mut [c32]) {
unsafe {
ffi::chpr_(&(uplo as c_char), &n, &alpha, x.as_ptr() as *const _, &incx,
ap.as_mut_ptr() as *mut _)
}
}
#[inline]
pub fn chpr2(uplo: u8, n: i32, alpha: c32, x: &[c32], incx: i32, y: &[c32], incy: i32,
ap: &mut [c32]) {
unsafe {
ffi::chpr2_(&(uplo as c_char), &n, &alpha as *const _ as *const _, x.as_ptr() as *const _,
&incx, y.as_ptr() as *const _, &incy, ap.as_mut_ptr() as *mut _)
}
}
#[inline]
pub fn cher2(uplo: u8, n: i32, alpha: c32, x: &[c32], incx: i32, y: &[c32], incy: i32,
a: &mut [c32], lda: i32) {
unsafe {
ffi::cher2_(&(uplo as c_char), &n, &alpha as *const _ as *const _, x.as_ptr() as *const _,
&incx, y.as_ptr() as *const _, &incy, a.as_mut_ptr() as *mut _, &lda)
}
}
#[inline]
pub fn zgemv(trans: u8, m: i32, n: i32, alpha: c64, a: &[c64], lda: i32, x: &[c64], incx: i32,
beta: c64, y: &mut [c64], incy: i32) {
unsafe {
ffi::zgemv_(&(trans as c_char), &m, &n, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, x.as_ptr() as *const _, &incx,
&beta as *const _ as *const _, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn zgbmv(trans: u8, m: i32, n: i32, kl: i32, ku: i32, alpha: c64, a: &[c64], lda: i32,
x: &[c64], incx: i32, beta: c64, y: &mut [c64], incy: i32) {
unsafe {
ffi::zgbmv_(&(trans as c_char), &m, &n, &kl, &ku, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, x.as_ptr() as *const _, &incx,
&beta as *const _ as *const _, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn zhemv(uplo: u8, n: i32, alpha: c64, a: &[c64], lda: i32, x: &[c64], incx: i32, beta: c64,
y: &mut [c64], incy: i32) {
unsafe {
ffi::zhemv_(&(uplo as c_char), &n, &alpha as *const _ as *const _, a.as_ptr() as *const _,
&lda, x.as_ptr() as *const _, &incx, &beta as *const _ as *const _,
y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn zhbmv(uplo: u8, n: i32, k: i32, alpha: c64, a: &[c64], lda: i32, x: &[c64], incx: i32,
beta: c64, y: &mut [c64], incy: i32) {
unsafe {
ffi::zhbmv_(&(uplo as c_char), &n, &k, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, x.as_ptr() as *const _, &incx,
&beta as *const _ as *const _, y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn zhpmv(uplo: u8, n: i32, alpha: c64, ap: &[c64], x: &[c64], incx: i32, beta: c64,
y: &mut [c64], incy: i32) {
unsafe {
ffi::zhpmv_(&(uplo as c_char), &n, &alpha as *const _ as *const _, ap.as_ptr() as *const _,
x.as_ptr() as *const _, &incx, &beta as *const _ as *const _,
y.as_mut_ptr() as *mut _, &incy)
}
}
#[inline]
pub fn ztrmv(uplo: u8, transa: u8, diag: u8, n: i32, a: &[c64], lda: i32, b: &mut [c64],
incx: i32) {
unsafe {
ffi::ztrmv_(&(uplo as c_char), &(transa as c_char), &(diag as c_char), &n,
a.as_ptr() as *const _, &lda, b.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ztbmv(uplo: u8, trans: u8, diag: u8, n: i32, k: i32, a: &[c64], lda: i32, x: &mut [c64],
incx: i32) {
unsafe {
ffi::ztbmv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, &k,
a.as_ptr() as *const _, &lda, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ztpmv(uplo: u8, trans: u8, diag: u8, n: i32, ap: &[c64], x: &mut [c64], incx: i32) {
unsafe {
ffi::ztpmv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n,
ap.as_ptr() as *const _, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ztrsv(uplo: u8, trans: u8, diag: u8, n: i32, a: &[c64], lda: i32, x: &mut [c64],
incx: i32) {
unsafe {
ffi::ztrsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n,
a.as_ptr() as *const _, &lda, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ztbsv(uplo: u8, trans: u8, diag: u8, n: i32, k: i32, a: &[c64], lda: i32, x: &mut [c64],
incx: i32) {
unsafe {
ffi::ztbsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n, &k,
a.as_ptr() as *const _, &lda, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn ztpsv(uplo: u8, trans: u8, diag: u8, n: i32, ap: &[c64], x: &mut [c64], incx: i32) {
unsafe {
ffi::ztpsv_(&(uplo as c_char), &(trans as c_char), &(diag as c_char), &n,
ap.as_ptr() as *const _, x.as_mut_ptr() as *mut _, &incx)
}
}
#[inline]
pub fn zgeru(m: i32, n: i32, alpha: c64, x: &[c64], incx: i32, y: &[c64], incy: i32, a: &mut [c64],
lda: i32) {
unsafe {
ffi::zgeru_(&m, &n, &alpha as *const _ as *const _, x.as_ptr() as *const _, &incx,
y.as_ptr() as *const _, &incy, a.as_mut_ptr() as *mut _, &lda)
}
}
#[inline]
pub fn zgerc(m: i32, n: i32, alpha: c64, x: &[c64], incx: i32, y: &[c64], incy: i32, a: &mut [c64],
lda: i32) {
unsafe {
ffi::zgerc_(&m, &n, &alpha as *const _ as *const _, x.as_ptr() as *const _, &incx,
y.as_ptr() as *const _, &incy, a.as_mut_ptr() as *mut _, &lda)
}
}
#[inline]
pub fn zher(uplo: u8, n: i32, alpha: f64, x: &[c64], incx: i32, a: &mut [c64], lda: i32) {
unsafe {
ffi::zher_(&(uplo as c_char), &n, &alpha, x.as_ptr() as *const _, &incx,
a.as_mut_ptr() as *mut _, &lda)
}
}
#[inline]
pub fn zhpr(uplo: u8, n: i32, alpha: f64, x: &[c64], incx: i32, ap: &mut [c64]) {
unsafe {
ffi::zhpr_(&(uplo as c_char), &n, &alpha, x.as_ptr() as *const _, &incx,
ap.as_mut_ptr() as *mut _)
}
}
#[inline]
pub fn zher2(uplo: u8, n: i32, alpha: c64, x: &[c64], incx: i32, y: &[c64], incy: i32,
a: &mut [c64], lda: i32) {
unsafe {
ffi::zher2_(&(uplo as c_char), &n, &alpha as *const _ as *const _, x.as_ptr() as *const _,
&incx, y.as_ptr() as *const _, &incy, a.as_mut_ptr() as *mut _, &lda)
}
}
#[inline]
pub fn zhpr2(uplo: u8, n: i32, alpha: c64, x: &[c64], incx: i32, y: &[c64], incy: i32,
ap: &mut [c64]) {
unsafe {
ffi::zhpr2_(&(uplo as c_char), &n, &alpha as *const _ as *const _, x.as_ptr() as *const _,
&incx, y.as_ptr() as *const _, &incy, ap.as_mut_ptr() as *mut _)
}
}
#[inline]
pub fn sgemm(transa: u8, transb: u8, m: i32, n: i32, k: i32, alpha: f32, a: &[f32], lda: i32,
b: &[f32], ldb: i32, beta: f32, c: &mut [f32], ldc: i32) {
unsafe {
ffi::sgemm_(&(transa as c_char), &(transb as c_char), &m, &n, &k, &alpha, a.as_ptr(), &lda,
b.as_ptr(), &ldb, &beta, c.as_mut_ptr(), &ldc)
}
}
#[inline]
pub fn ssymm(side: u8, uplo: u8, m: i32, n: i32, alpha: f32, a: &[f32], lda: i32, b: &[f32],
ldb: i32, beta: f32, c: &mut [f32], ldc: i32) {
unsafe {
ffi::ssymm_(&(side as c_char), &(uplo as c_char), &m, &n, &alpha, a.as_ptr(), &lda,
b.as_ptr(), &ldb, &beta, c.as_mut_ptr(), &ldc)
}
}
#[inline]
pub fn ssyrk(uplo: u8, trans: u8, n: i32, k: i32, alpha: f32, a: &[f32], lda: i32, beta: f32,
c: &mut [f32], ldc: i32) {
unsafe {
ffi::ssyrk_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha, a.as_ptr(), &lda, &beta,
c.as_mut_ptr(), &ldc)
}
}
#[inline]
pub fn ssyr2k(uplo: u8, trans: u8, n: i32, k: i32, alpha: f32, a: &[f32], lda: i32, b: &[f32],
ldb: i32, beta: f32, c: &mut [f32], ldc: i32) {
unsafe {
ffi::ssyr2k_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha, a.as_ptr(), &lda,
b.as_ptr(), &ldb, &beta, c.as_mut_ptr(), &ldc)
}
}
#[inline]
pub fn strmm(side: u8, uplo: u8, transa: u8, diag: u8, m: i32, n: i32, alpha: f32, a: &[f32],
lda: i32, b: &mut [f32], ldb: i32) {
unsafe {
ffi::strmm_(&(side as c_char), &(uplo as c_char), &(transa as c_char), &(diag as c_char),
&m, &n, &alpha, a.as_ptr(), &lda, b.as_mut_ptr(), &ldb)
}
}
#[inline]
pub fn strsm(side: u8, uplo: u8, transa: u8, diag: u8, m: i32, n: i32, alpha: f32, a: &[f32],
lda: i32, b: &mut [f32], ldb: i32) {
unsafe {
ffi::strsm_(&(side as c_char), &(uplo as c_char), &(transa as c_char), &(diag as c_char),
&m, &n, &alpha, a.as_ptr(), &lda, b.as_mut_ptr(), &ldb)
}
}
#[inline]
pub fn dgemm(transa: u8, transb: u8, m: i32, n: i32, k: i32, alpha: f64, a: &[f64], lda: i32,
b: &[f64], ldb: i32, beta: f64, c: &mut [f64], ldc: i32) {
unsafe {
ffi::dgemm_(&(transa as c_char), &(transb as c_char), &m, &n, &k, &alpha, a.as_ptr(), &lda,
b.as_ptr(), &ldb, &beta, c.as_mut_ptr(), &ldc)
}
}
#[inline]
pub fn dsymm(side: u8, uplo: u8, m: i32, n: i32, alpha: f64, a: &[f64], lda: i32, b: &[f64],
ldb: i32, beta: f64, c: &mut [f64], ldc: i32) {
unsafe {
ffi::dsymm_(&(side as c_char), &(uplo as c_char), &m, &n, &alpha, a.as_ptr(), &lda,
b.as_ptr(), &ldb, &beta, c.as_mut_ptr(), &ldc)
}
}
#[inline]
pub fn dsyrk(uplo: u8, trans: u8, n: i32, k: i32, alpha: f64, a: &[f64], lda: i32, beta: f64,
c: &mut [f64], ldc: i32) {
unsafe {
ffi::dsyrk_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha, a.as_ptr(), &lda, &beta,
c.as_mut_ptr(), &ldc)
}
}
#[inline]
pub fn dsyr2k(uplo: u8, trans: u8, n: i32, k: i32, alpha: f64, a: &[f64], lda: i32, b: &[f64],
ldb: i32, beta: f64, c: &mut [f64], ldc: i32) {
unsafe {
ffi::dsyr2k_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha, a.as_ptr(), &lda,
b.as_ptr(), &ldb, &beta, c.as_mut_ptr(), &ldc)
}
}
#[inline]
pub fn dtrmm(side: u8, uplo: u8, transa: u8, diag: u8, m: i32, n: i32, alpha: f64, a: &[f64],
lda: i32, b: &mut [f64], ldb: i32) {
unsafe {
ffi::dtrmm_(&(side as c_char), &(uplo as c_char), &(transa as c_char), &(diag as c_char),
&m, &n, &alpha, a.as_ptr(), &lda, b.as_mut_ptr(), &ldb)
}
}
#[inline]
pub fn dtrsm(side: u8, uplo: u8, transa: u8, diag: u8, m: i32, n: i32, alpha: f64, a: &[f64],
lda: i32, b: &mut [f64], ldb: i32) {
unsafe {
ffi::dtrsm_(&(side as c_char), &(uplo as c_char), &(transa as c_char), &(diag as c_char),
&m, &n, &alpha, a.as_ptr(), &lda, b.as_mut_ptr(), &ldb)
}
}
#[inline]
pub fn cgemm(transa: u8, transb: u8, m: i32, n: i32, k: i32, alpha: c32, a: &[c32], lda: i32,
b: &[c32], ldb: i32, beta: c32, c: &mut [c32], ldc: i32) {
unsafe {
ffi::cgemm_(&(transa as c_char), &(transb as c_char), &m, &n, &k,
&alpha as *const _ as *const _, a.as_ptr() as *const _, &lda,
b.as_ptr() as *const _, &ldb, &beta as *const _ as *const _,
c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn csymm(side: u8, uplo: u8, m: i32, n: i32, alpha: c32, a: &[c32], lda: i32, b: &[c32],
ldb: i32, beta: c32, c: &mut [c32], ldc: i32) {
unsafe {
ffi::csymm_(&(side as c_char), &(uplo as c_char), &m, &n, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, b.as_ptr() as *const _, &ldb,
&beta as *const _ as *const _, c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn chemm(side: u8, uplo: u8, m: i32, n: i32, alpha: c32, a: &[c32], lda: i32, b: &[c32],
ldb: i32, beta: c32, c: &mut [c32], ldc: i32) {
unsafe {
ffi::chemm_(&(side as c_char), &(uplo as c_char), &m, &n, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, b.as_ptr() as *const _, &ldb,
&beta as *const _ as *const _, c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn csyrk(uplo: u8, trans: u8, n: i32, k: i32, alpha: c32, a: &[c32], lda: i32, beta: c32,
c: &mut [c32], ldc: i32) {
unsafe {
ffi::csyrk_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, &beta as *const _ as *const _,
c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn cherk(uplo: u8, trans: u8, n: i32, k: i32, alpha: f32, a: &[c32], lda: i32, beta: f32,
c: &mut [c32], ldc: i32) {
unsafe {
ffi::cherk_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha, a.as_ptr() as *const _,
&lda, &beta, c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn csyr2k(uplo: u8, trans: u8, n: i32, k: i32, alpha: c32, a: &[c32], lda: i32, b: &[c32],
ldb: i32, beta: c32, c: &mut [c32], ldc: i32) {
unsafe {
ffi::csyr2k_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, b.as_ptr() as *const _, &ldb,
&beta as *const _ as *const _, c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn cher2k(uplo: u8, trans: u8, n: i32, k: i32, alpha: c32, a: &[c32], lda: i32, b: &[c32],
ldb: i32, beta: f32, c: &mut [c32], ldc: i32) {
unsafe {
ffi::cher2k_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, b.as_ptr() as *const _, &ldb, &beta,
c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn ctrmm(side: u8, uplo: u8, transa: u8, diag: u8, m: i32, n: i32, alpha: c32, a: &[c32],
lda: i32, b: &mut [c32], ldb: i32) {
unsafe {
ffi::ctrmm_(&(side as c_char), &(uplo as c_char), &(transa as c_char), &(diag as c_char),
&m, &n, &alpha as *const _ as *const _, a.as_ptr() as *const _, &lda,
b.as_mut_ptr() as *mut _, &ldb)
}
}
#[inline]
pub fn ctrsm(side: u8, uplo: u8, transa: u8, diag: u8, m: i32, n: i32, alpha: c32, a: &[c32],
lda: i32, b: &mut [c32], ldb: i32) {
unsafe {
ffi::ctrsm_(&(side as c_char), &(uplo as c_char), &(transa as c_char), &(diag as c_char),
&m, &n, &alpha as *const _ as *const _, a.as_ptr() as *const _, &lda,
b.as_mut_ptr() as *mut _, &ldb)
}
}
#[inline]
pub fn zgemm(transa: u8, transb: u8, m: i32, n: i32, k: i32, alpha: c64, a: &[c64], lda: i32,
b: &[c64], ldb: i32, beta: c64, c: &mut [c64], ldc: i32) {
unsafe {
ffi::zgemm_(&(transa as c_char), &(transb as c_char), &m, &n, &k,
&alpha as *const _ as *const _, a.as_ptr() as *const _, &lda,
b.as_ptr() as *const _, &ldb, &beta as *const _ as *const _,
c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn zsymm(side: u8, uplo: u8, m: i32, n: i32, alpha: c64, a: &[c64], lda: i32, b: &[c64],
ldb: i32, beta: c64, c: &mut [c64], ldc: i32) {
unsafe {
ffi::zsymm_(&(side as c_char), &(uplo as c_char), &m, &n, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, b.as_ptr() as *const _, &ldb,
&beta as *const _ as *const _, c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn zhemm(side: u8, uplo: u8, m: i32, n: i32, alpha: c64, a: &[c64], lda: i32, b: &[c64],
ldb: i32, beta: c64, c: &mut [c64], ldc: i32) {
unsafe {
ffi::zhemm_(&(side as c_char), &(uplo as c_char), &m, &n, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, b.as_ptr() as *const _, &ldb,
&beta as *const _ as *const _, c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn zsyrk(uplo: u8, trans: u8, n: i32, k: i32, alpha: c64, a: &[c64], lda: i32, beta: c64,
c: &mut [c64], ldc: i32) {
unsafe {
ffi::zsyrk_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, &beta as *const _ as *const _,
c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn zherk(uplo: u8, trans: u8, n: i32, k: i32, alpha: f64, a: &[c64], lda: i32, beta: f64,
c: &mut [c64], ldc: i32) {
unsafe {
ffi::zherk_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha, a.as_ptr() as *const _,
&lda, &beta, c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn zsyr2k(uplo: u8, trans: u8, n: i32, k: i32, alpha: c64, a: &[c64], lda: i32, b: &[c64],
ldb: i32, beta: c64, c: &mut [c64], ldc: i32) {
unsafe {
ffi::zsyr2k_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, b.as_ptr() as *const _, &ldb,
&beta as *const _ as *const _, c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn zher2k(uplo: u8, trans: u8, n: i32, k: i32, alpha: c64, a: &[c64], lda: i32, b: &[c64],
ldb: i32, beta: f64, c: &mut [c64], ldc: i32) {
unsafe {
ffi::zher2k_(&(uplo as c_char), &(trans as c_char), &n, &k, &alpha as *const _ as *const _,
a.as_ptr() as *const _, &lda, b.as_ptr() as *const _, &ldb, &beta,
c.as_mut_ptr() as *mut _, &ldc)
}
}
#[inline]
pub fn ztrmm(side: u8, uplo: u8, transa: u8, diag: u8, m: i32, n: i32, alpha: c64, a: &[c64],
lda: i32, b: &mut [c64], ldb: i32) {
unsafe {
ffi::ztrmm_(&(side as c_char), &(uplo as c_char), &(transa as c_char), &(diag as c_char),
&m, &n, &alpha as *const _ as *const _, a.as_ptr() as *const _, &lda,
b.as_mut_ptr() as *mut _, &ldb)
}
}
#[inline]
pub fn ztrsm(side: u8, uplo: u8, transa: u8, diag: u8, m: i32, n: i32, alpha: c64, a: &[c64],
lda: i32, b: &mut [c64], ldb: i32) {
unsafe {
ffi::ztrsm_(&(side as c_char), &(uplo as c_char), &(transa as c_char), &(diag as c_char),
&m, &n, &alpha as *const _ as *const _, a.as_ptr() as *const _, &lda,
b.as_mut_ptr() as *mut _, &ldb)
}
}