rgsl/
cblas.rs

1//
2// A rust binding for the GSL library by Guillaume Gomez (guillaume1.gomez@gmail.com)
3//
4
5#[derive(Clone, Copy)]
6pub struct Index(pub(crate) sys::CBLAS_INDEX_t);
7
8impl Index {
9    pub fn new(value: usize) -> Index {
10        Index(value)
11    }
12}
13
14pub mod level1 {
15    #[doc(alias = "cblas_sdsdot")]
16    pub fn sdsdot(N: i32, alpha: f32, x: &[f32], incx: i32, y: &[f32], incy: i32) -> f32 {
17        unsafe { ::sys::cblas_sdsdot(N, alpha, x.as_ptr(), incx, y.as_ptr(), incy) }
18    }
19
20    #[doc(alias = "cblas_dsdot")]
21    pub fn dsdot(N: i32, x: &[f32], incx: i32, y: &[f32], incy: i32) -> f64 {
22        unsafe { ::sys::cblas_dsdot(N, x.as_ptr(), incx, y.as_ptr(), incy) }
23    }
24
25    #[doc(alias = "cblas_sdot")]
26    pub fn sdot(N: i32, x: &[f32], incx: i32, y: &[f32], incy: i32) -> f32 {
27        unsafe { ::sys::cblas_sdot(N, x.as_ptr(), incx, y.as_ptr(), incy) }
28    }
29
30    #[doc(alias = "cblas_ddot")]
31    pub fn ddot(N: i32, x: &[f64], incx: i32, y: &[f64], incy: i32) -> f64 {
32        unsafe { ::sys::cblas_ddot(N, x.as_ptr(), incx, y.as_ptr(), incy) }
33    }
34
35    #[doc(alias = "cblas_cdotu_sub")]
36    pub fn cdotu_sub<T>(N: i32, x: &[T], incx: i32, y: &[T], incy: i32, dotu: &mut [T]) {
37        unsafe {
38            ::sys::cblas_cdotu_sub(
39                N,
40                x.as_ptr() as *const _,
41                incx,
42                y.as_ptr() as *const _,
43                incy,
44                dotu.as_mut_ptr() as *mut _,
45            )
46        }
47    }
48
49    #[doc(alias = "cblas_cdotc_sub")]
50    pub fn cdotc_sub<T>(N: i32, x: &[T], incx: i32, y: &[T], incy: i32, dotc: &mut [T]) {
51        unsafe {
52            ::sys::cblas_cdotc_sub(
53                N,
54                x.as_ptr() as *const _,
55                incx,
56                y.as_ptr() as *const _,
57                incy,
58                dotc.as_mut_ptr() as *mut _,
59            )
60        }
61    }
62
63    #[doc(alias = "cblas_zdotu_sub")]
64    pub fn zdotu_sub<T>(N: i32, x: &[T], incx: i32, y: &[T], incy: i32, dotu: &mut [T]) {
65        unsafe {
66            ::sys::cblas_zdotu_sub(
67                N,
68                x.as_ptr() as *const _,
69                incx,
70                y.as_ptr() as *const _,
71                incy,
72                dotu.as_mut_ptr() as *mut _,
73            )
74        }
75    }
76
77    #[doc(alias = "cblas_zdotc_sub")]
78    pub fn zdotc_sub<T>(N: i32, x: &[T], incx: i32, y: &[T], incy: i32, dotc: &mut [T]) {
79        unsafe {
80            ::sys::cblas_zdotc_sub(
81                N,
82                x.as_ptr() as *const _,
83                incx,
84                y.as_ptr() as *const _,
85                incy,
86                dotc.as_mut_ptr() as *mut _,
87            )
88        }
89    }
90
91    #[doc(alias = "cblas_snrm2")]
92    pub fn snrm2(N: i32, x: &[f32], incx: i32) -> f32 {
93        unsafe { ::sys::cblas_snrm2(N, x.as_ptr(), incx) }
94    }
95
96    #[doc(alias = "cblas_sasum")]
97    pub fn sasum(N: i32, x: &[f32], incx: i32) -> f32 {
98        unsafe { ::sys::cblas_sasum(N, x.as_ptr(), incx) }
99    }
100
101    #[doc(alias = "cblas_dnrm2")]
102    pub fn dnrm2(N: i32, x: &[f64], incx: i32) -> f64 {
103        unsafe { ::sys::cblas_dnrm2(N, x.as_ptr(), incx) }
104    }
105
106    #[doc(alias = "cblas_dasum")]
107    pub fn dasum(N: i32, x: &[f64], incx: i32) -> f64 {
108        unsafe { ::sys::cblas_dasum(N, x.as_ptr(), incx) }
109    }
110
111    #[doc(alias = "cblas_scnrm2")]
112    pub fn scnrm2<T>(N: i32, x: &[T], incx: i32) -> f32 {
113        unsafe { ::sys::cblas_scnrm2(N, x.as_ptr() as *const _, incx) }
114    }
115
116    #[doc(alias = "cblas_scasum")]
117    pub fn scasum<T>(N: i32, x: &[T], incx: i32) -> f32 {
118        unsafe { ::sys::cblas_scasum(N, x.as_ptr() as *const _, incx) }
119    }
120
121    #[doc(alias = "cblas_dznrm2")]
122    pub fn dznrm2<T>(N: i32, x: &[T], incx: i32) -> f64 {
123        unsafe { ::sys::cblas_dznrm2(N, x.as_ptr() as *const _, incx) }
124    }
125
126    #[doc(alias = "cblas_dzasum")]
127    pub fn dzasum<T>(N: i32, x: &[T], incx: i32) -> f64 {
128        unsafe { ::sys::cblas_dzasum(N, x.as_ptr() as *const _, incx) }
129    }
130
131    #[doc(alias = "cblas_isamax")]
132    pub fn isamax(N: i32, x: &[f32], incx: i32) -> crate::cblas::Index {
133        crate::cblas::Index(unsafe { ::sys::cblas_isamax(N, x.as_ptr(), incx) })
134    }
135
136    #[doc(alias = "cblas_idamax")]
137    pub fn idamax(N: i32, x: &[f64], incx: i32) -> crate::cblas::Index {
138        crate::cblas::Index(unsafe { ::sys::cblas_idamax(N, x.as_ptr(), incx) })
139    }
140
141    #[doc(alias = "cblas_icamax")]
142    pub fn icamax<T>(N: i32, x: &[T], incx: i32) -> crate::cblas::Index {
143        crate::cblas::Index(unsafe { ::sys::cblas_icamax(N, x.as_ptr() as *const _, incx) })
144    }
145
146    #[doc(alias = "cblas_izamax")]
147    pub fn izamax<T>(N: i32, x: &[T], incx: i32) -> crate::cblas::Index {
148        crate::cblas::Index(unsafe { ::sys::cblas_izamax(N, x.as_ptr() as *const _, incx) })
149    }
150
151    #[doc(alias = "cblas_sswap")]
152    pub fn sswap(N: i32, x: &mut [f32], incx: i32, y: &mut [f32], incy: i32) {
153        unsafe { ::sys::cblas_sswap(N, x.as_mut_ptr(), incx, y.as_mut_ptr(), incy) }
154    }
155
156    #[doc(alias = "cblas_scopy")]
157    pub fn scopy(N: i32, x: &[f32], incx: i32, y: &mut [f32], incy: i32) {
158        unsafe { ::sys::cblas_scopy(N, x.as_ptr(), incx, y.as_mut_ptr(), incy) }
159    }
160
161    #[doc(alias = "cblas_saxpy")]
162    pub fn saxpy(N: i32, alpha: f32, x: &[f32], incx: i32, y: &mut [f32], incy: i32) {
163        unsafe { ::sys::cblas_saxpy(N, alpha, x.as_ptr(), incx, y.as_mut_ptr(), incy) }
164    }
165
166    #[doc(alias = "cblas_dswap")]
167    pub fn dswap(N: i32, x: &mut [f64], incx: i32, y: &mut [f64], incy: i32) {
168        unsafe { ::sys::cblas_dswap(N, x.as_mut_ptr(), incx, y.as_mut_ptr(), incy) }
169    }
170
171    #[doc(alias = "cblas_dcopy")]
172    pub fn dcopy(N: i32, x: &[f64], incx: i32, y: &mut [f64], incy: i32) {
173        unsafe { ::sys::cblas_dcopy(N, x.as_ptr(), incx, y.as_mut_ptr(), incy) }
174    }
175
176    #[doc(alias = "cblas_daxpy")]
177    pub fn daxpy(N: i32, alpha: f64, x: &[f64], incx: i32, y: &mut [f64], incy: i32) {
178        unsafe { ::sys::cblas_daxpy(N, alpha, x.as_ptr(), incx, y.as_mut_ptr(), incy) }
179    }
180
181    #[doc(alias = "cblas_cswap")]
182    pub fn cswap<T>(N: i32, x: &mut [T], incx: i32, y: &mut [T], incy: i32) {
183        unsafe {
184            ::sys::cblas_cswap(
185                N,
186                x.as_mut_ptr() as *mut _,
187                incx,
188                y.as_mut_ptr() as *mut _,
189                incy,
190            )
191        }
192    }
193
194    #[doc(alias = "cblas_ccopy")]
195    pub fn ccopy<T>(N: i32, x: &[T], incx: i32, y: &mut [T], incy: i32) {
196        unsafe {
197            ::sys::cblas_ccopy(
198                N,
199                x.as_ptr() as *const _,
200                incx,
201                y.as_mut_ptr() as *mut _,
202                incy,
203            )
204        }
205    }
206
207    #[doc(alias = "cblas_caxpy")]
208    pub fn caxpy<T>(N: i32, alpha: &[T], x: &[T], incx: i32, y: &mut [T], incy: i32) {
209        unsafe {
210            ::sys::cblas_caxpy(
211                N,
212                alpha.as_ptr() as *const _,
213                x.as_ptr() as *const _,
214                incx,
215                y.as_mut_ptr() as *mut _,
216                incy,
217            )
218        }
219    }
220
221    #[doc(alias = "cblas_zswap")]
222    pub fn zswap<T>(N: i32, x: &mut [T], incx: i32, y: &mut [T], incy: i32) {
223        unsafe {
224            ::sys::cblas_zswap(
225                N,
226                x.as_mut_ptr() as *mut _,
227                incx,
228                y.as_mut_ptr() as *mut _,
229                incy,
230            )
231        }
232    }
233
234    #[doc(alias = "cblas_zcopy")]
235    pub fn zcopy<T>(N: i32, x: &[T], incx: i32, y: &mut [T], incy: i32) {
236        unsafe {
237            ::sys::cblas_zcopy(
238                N,
239                x.as_ptr() as *const _,
240                incx,
241                y.as_mut_ptr() as *mut _,
242                incy,
243            )
244        }
245    }
246
247    #[doc(alias = "cblas_zaxpy")]
248    pub fn zaxpy<T>(N: i32, alpha: &[T], x: &[T], incx: i32, y: &mut [T], incy: i32) {
249        unsafe {
250            ::sys::cblas_zaxpy(
251                N,
252                alpha.as_ptr() as *const _,
253                x.as_ptr() as *const _,
254                incx,
255                y.as_mut_ptr() as *mut _,
256                incy,
257            )
258        }
259    }
260
261    #[doc(alias = "cblas_srotg")]
262    pub fn srotg(a: &mut [f32], b: &mut [f32], c: &mut [f32], s: &mut [f32]) {
263        unsafe {
264            ::sys::cblas_srotg(
265                a.as_mut_ptr(),
266                b.as_mut_ptr(),
267                c.as_mut_ptr(),
268                s.as_mut_ptr(),
269            )
270        }
271    }
272
273    #[doc(alias = "cblas_srotmg")]
274    pub fn srotmg(d1: &mut [f32], d2: &mut [f32], b1: &mut [f32], b2: f32, P: &mut [f32]) {
275        unsafe {
276            ::sys::cblas_srotmg(
277                d1.as_mut_ptr(),
278                d2.as_mut_ptr(),
279                b1.as_mut_ptr(),
280                b2,
281                P.as_mut_ptr(),
282            )
283        }
284    }
285
286    #[doc(alias = "cblas_srot")]
287    pub fn srot(N: i32, x: &mut [f32], incx: i32, y: &mut [f32], incy: i32, c: f32, s: f32) {
288        unsafe { ::sys::cblas_srot(N, x.as_mut_ptr(), incx, y.as_mut_ptr(), incy, c, s) }
289    }
290
291    #[doc(alias = "cblas_srotm")]
292    pub fn srotm(N: i32, x: &mut [f32], incx: i32, y: &mut [f32], incy: i32, p: &[f32]) {
293        unsafe { ::sys::cblas_srotm(N, x.as_mut_ptr(), incx, y.as_mut_ptr(), incy, p.as_ptr()) }
294    }
295
296    #[doc(alias = "cblas_drotg")]
297    pub fn drotg(a: &mut [f64], b: &mut [f64], c: &mut [f64], s: &mut [f64]) {
298        unsafe {
299            ::sys::cblas_drotg(
300                a.as_mut_ptr(),
301                b.as_mut_ptr(),
302                c.as_mut_ptr(),
303                s.as_mut_ptr(),
304            )
305        }
306    }
307
308    #[doc(alias = "cblas_drotmg")]
309    pub fn drotmg(d1: &mut [f64], d2: &mut [f64], b1: &mut [f64], b2: f64, P: &mut [f64]) {
310        unsafe {
311            ::sys::cblas_drotmg(
312                d1.as_mut_ptr(),
313                d2.as_mut_ptr(),
314                b1.as_mut_ptr(),
315                b2,
316                P.as_mut_ptr(),
317            )
318        }
319    }
320
321    #[doc(alias = "cblas_drot")]
322    pub fn drot(N: i32, x: &mut [f64], incx: i32, y: &mut [f64], incy: i32, c: f64, s: f64) {
323        unsafe { ::sys::cblas_drot(N, x.as_mut_ptr(), incx, y.as_mut_ptr(), incy, c, s) }
324    }
325
326    #[doc(alias = "cblas_drotm")]
327    pub fn drotm(N: i32, x: &mut [f64], incx: i32, y: &mut [f64], incy: i32, p: &[f64]) {
328        unsafe { ::sys::cblas_drotm(N, x.as_mut_ptr(), incx, y.as_mut_ptr(), incy, p.as_ptr()) }
329    }
330
331    /// Multiple each element of a matrix/vector by a constant.
332    ///
333    /// __Postcondition__: Every incX'th element of X has been multiplied by a factor of alpha
334    ///
335    /// __Parameters__:
336    ///
337    /// * N : number of elements in x to scale
338    /// * alpha : factor to scale by
339    /// * X : pointer to the vector/matrix data
340    /// * incx : Amount to increment counter after each scaling, ie incX=2 mean to scale elements {1,3,...}
341    ///
342    /// Note that the allocated length of X must be incX*N-1 as N indicates the number of scaling operations to perform.
343    #[doc(alias = "cblas_sscal")]
344    pub fn sscal(N: i32, alpha: f32, x: &mut [f32], incx: i32) {
345        unsafe { ::sys::cblas_sscal(N, alpha, x.as_mut_ptr(), incx) }
346    }
347
348    /// Multiple each element of a matrix/vector by a constant.
349    #[doc(alias = "cblas_dscal")]
350    pub fn dscal(N: i32, alpha: f64, x: &mut [f64], incx: i32) {
351        unsafe { ::sys::cblas_dscal(N, alpha, x.as_mut_ptr(), incx) }
352    }
353
354    /// Multiple each element of a matrix/vector by a constant.
355    #[doc(alias = "cblas_cscal")]
356    pub fn cscal<T>(N: i32, alpha: &[T], x: &mut [T], incx: i32) {
357        unsafe {
358            ::sys::cblas_cscal(
359                N,
360                alpha.as_ptr() as *const _,
361                x.as_mut_ptr() as *mut _,
362                incx,
363            )
364        }
365    }
366
367    /// Multiple each element of a matrix/vector by a constant.
368    #[doc(alias = "cblas_zscal")]
369    pub fn zscal<T>(N: i32, alpha: &[T], x: &mut [T], incx: i32) {
370        unsafe {
371            ::sys::cblas_zscal(
372                N,
373                alpha.as_ptr() as *const _,
374                x.as_mut_ptr() as *mut _,
375                incx,
376            )
377        }
378    }
379
380    /// Multiple each element of a matrix/vector by a constant.
381    #[doc(alias = "cblas_csscal")]
382    pub fn csscal<T>(N: i32, alpha: f32, x: &mut [T], incx: i32) {
383        unsafe { ::sys::cblas_csscal(N, alpha, x.as_mut_ptr() as *mut _, incx) }
384    }
385
386    /// Multiple each element of a matrix/vector by a constant.
387    #[doc(alias = "cblas_zdscal")]
388    pub fn zdscal<T>(N: i32, alpha: f64, x: &mut [T], incx: i32) {
389        unsafe { ::sys::cblas_zdscal(N, alpha, x.as_mut_ptr() as *mut _, incx) }
390    }
391}
392
393pub mod level2 {
394    use crate::enums;
395
396    /// Multiplies a matrix and a vector.
397    ///
398    /// * order : Whether matrices are row major order (C-Style) for column major order (Fortran-style). One of enum CblasRowMajor or CblasColMajor
399    /// * transA :  Whether to transpose matrix A. One of enum CblasNoTrans, CBlasTrans.
400    /// * M : Rows in matrix A
401    /// * N : Columns in matrix A
402    /// * alpha : scalar factor for (sigma * op(A) * x)
403    /// * A : matrix A
404    /// * lda : The size of the first dimension of matrix A
405    /// * X : vector X
406    /// * incx : use every incX'th element of X
407    /// * beta : scalar factor y
408    /// * Y : vector Y
409    /// * incy : use every incY'th element of Y
410    ///
411    /// For parameter lda, if you are passing a matrix `A[m][n]`, the value of parameter lda should be m.
412    #[doc(alias = "cblas_sgemv")]
413    pub fn sgemv(
414        order: enums::CblasOrder,
415        transA: enums::CblasTranspose,
416        M: i32,
417        N: i32,
418        alpha: f32,
419        A: &[f32],
420        lda: i32,
421        X: &[f32],
422        incx: i32,
423        beta: f32,
424        Y: &mut [f32],
425        incy: i32,
426    ) {
427        unsafe {
428            ::sys::cblas_sgemv(
429                order.into(),
430                transA.into(),
431                M,
432                N,
433                alpha,
434                A.as_ptr(),
435                lda,
436                X.as_ptr(),
437                incx,
438                beta,
439                Y.as_mut_ptr(),
440                incy,
441            )
442        }
443    }
444
445    #[doc(alias = "cblas_sgbmv")]
446    pub fn sgbmv(
447        order: enums::CblasOrder,
448        transA: enums::CblasTranspose,
449        M: i32,
450        N: i32,
451        KL: i32,
452        KU: i32,
453        alpha: f32,
454        A: &[f32],
455        lda: i32,
456        X: &[f32],
457        incx: i32,
458        beta: f32,
459        Y: &mut [f32],
460        incy: i32,
461    ) {
462        unsafe {
463            ::sys::cblas_sgbmv(
464                order.into(),
465                transA.into(),
466                M,
467                N,
468                KL,
469                KU,
470                alpha,
471                A.as_ptr(),
472                lda,
473                X.as_ptr(),
474                incx,
475                beta,
476                Y.as_mut_ptr(),
477                incy,
478            )
479        }
480    }
481
482    #[doc(alias = "cblas_strmv")]
483    pub fn strmv(
484        order: enums::CblasOrder,
485        uplo: enums::CblasUplo,
486        transA: enums::CblasTranspose,
487        diag: enums::CblasDiag,
488        N: i32,
489        A: &[f32],
490        lda: i32,
491        X: &mut [f32],
492        incx: i32,
493    ) {
494        unsafe {
495            ::sys::cblas_strmv(
496                order.into(),
497                uplo.into(),
498                transA.into(),
499                diag.into(),
500                N,
501                A.as_ptr(),
502                lda,
503                X.as_mut_ptr(),
504                incx,
505            )
506        }
507    }
508
509    #[doc(alias = "cblas_stbmv")]
510    pub fn stbmv(
511        order: enums::CblasOrder,
512        uplo: enums::CblasUplo,
513        transA: enums::CblasTranspose,
514        diag: enums::CblasDiag,
515        N: i32,
516        K: i32,
517        A: &[f32],
518        lda: i32,
519        X: &mut [f32],
520        incx: i32,
521    ) {
522        unsafe {
523            ::sys::cblas_stbmv(
524                order.into(),
525                uplo.into(),
526                transA.into(),
527                diag.into(),
528                N,
529                K,
530                A.as_ptr(),
531                lda,
532                X.as_mut_ptr(),
533                incx,
534            )
535        }
536    }
537
538    #[doc(alias = "cblas_stpmv")]
539    pub fn stpmv(
540        order: enums::CblasOrder,
541        uplo: enums::CblasUplo,
542        transA: enums::CblasTranspose,
543        diag: enums::CblasDiag,
544        N: i32,
545        Ap: &[f32],
546        X: &mut [f32],
547        incx: i32,
548    ) {
549        unsafe {
550            ::sys::cblas_stpmv(
551                order.into(),
552                uplo.into(),
553                transA.into(),
554                diag.into(),
555                N,
556                Ap.as_ptr(),
557                X.as_mut_ptr(),
558                incx,
559            )
560        }
561    }
562
563    #[doc(alias = "cblas_strsv")]
564    pub fn strsv(
565        order: enums::CblasOrder,
566        uplo: enums::CblasUplo,
567        transA: enums::CblasTranspose,
568        diag: enums::CblasDiag,
569        N: i32,
570        A: &[f32],
571        lda: i32,
572        X: &mut [f32],
573        incx: i32,
574    ) {
575        unsafe {
576            ::sys::cblas_strsv(
577                order.into(),
578                uplo.into(),
579                transA.into(),
580                diag.into(),
581                N,
582                A.as_ptr(),
583                lda,
584                X.as_mut_ptr(),
585                incx,
586            )
587        }
588    }
589
590    #[doc(alias = "cblas_stbsv")]
591    pub fn stbsv(
592        order: enums::CblasOrder,
593        uplo: enums::CblasUplo,
594        transA: enums::CblasTranspose,
595        diag: enums::CblasDiag,
596        N: i32,
597        K: i32,
598        A: &[f32],
599        lda: i32,
600        X: &mut [f32],
601        incx: i32,
602    ) {
603        unsafe {
604            ::sys::cblas_stbsv(
605                order.into(),
606                uplo.into(),
607                transA.into(),
608                diag.into(),
609                N,
610                K,
611                A.as_ptr(),
612                lda,
613                X.as_mut_ptr(),
614                incx,
615            )
616        }
617    }
618
619    #[doc(alias = "cblas_stpsv")]
620    pub fn stpsv(
621        order: enums::CblasOrder,
622        uplo: enums::CblasUplo,
623        transA: enums::CblasTranspose,
624        diag: enums::CblasDiag,
625        N: i32,
626        Ap: &[f32],
627        X: &mut [f32],
628        incx: i32,
629    ) {
630        unsafe {
631            ::sys::cblas_stpsv(
632                order.into(),
633                uplo.into(),
634                transA.into(),
635                diag.into(),
636                N,
637                Ap.as_ptr(),
638                X.as_mut_ptr(),
639                incx,
640            )
641        }
642    }
643
644    #[doc(alias = "cblas_dgemv")]
645    pub fn dgemv(
646        order: enums::CblasOrder,
647        transA: enums::CblasTranspose,
648        M: i32,
649        N: i32,
650        alpha: f64,
651        A: &[f64],
652        lda: i32,
653        X: &[f64],
654        incx: i32,
655        beta: f64,
656        Y: &mut [f64],
657        incy: i32,
658    ) {
659        unsafe {
660            ::sys::cblas_dgemv(
661                order.into(),
662                transA.into(),
663                M,
664                N,
665                alpha,
666                A.as_ptr(),
667                lda,
668                X.as_ptr(),
669                incx,
670                beta,
671                Y.as_mut_ptr(),
672                incy,
673            )
674        }
675    }
676
677    #[doc(alias = "cblas_dgbmv")]
678    pub fn dgbmv(
679        order: enums::CblasOrder,
680        transA: enums::CblasTranspose,
681        M: i32,
682        N: i32,
683        KL: i32,
684        KU: i32,
685        alpha: f64,
686        A: &[f64],
687        lda: i32,
688        X: &[f64],
689        incx: i32,
690        beta: f64,
691        Y: &mut [f64],
692        incy: i32,
693    ) {
694        unsafe {
695            ::sys::cblas_dgbmv(
696                order.into(),
697                transA.into(),
698                M,
699                N,
700                KL,
701                KU,
702                alpha,
703                A.as_ptr(),
704                lda,
705                X.as_ptr(),
706                incx,
707                beta,
708                Y.as_mut_ptr(),
709                incy,
710            )
711        }
712    }
713
714    #[doc(alias = "cblas_dtrmv")]
715    pub fn dtrmv(
716        order: enums::CblasOrder,
717        uplo: enums::CblasUplo,
718        transA: enums::CblasTranspose,
719        diag: enums::CblasDiag,
720        N: i32,
721        A: &[f64],
722        lda: i32,
723        X: &mut [f64],
724        incx: i32,
725    ) {
726        unsafe {
727            ::sys::cblas_dtrmv(
728                order.into(),
729                uplo.into(),
730                transA.into(),
731                diag.into(),
732                N,
733                A.as_ptr(),
734                lda,
735                X.as_mut_ptr(),
736                incx,
737            )
738        }
739    }
740
741    #[doc(alias = "cblas_dtbmv")]
742    pub fn dtbmv(
743        order: enums::CblasOrder,
744        uplo: enums::CblasUplo,
745        transA: enums::CblasTranspose,
746        diag: enums::CblasDiag,
747        N: i32,
748        K: i32,
749        A: &[f64],
750        lda: i32,
751        X: &mut [f64],
752        incx: i32,
753    ) {
754        unsafe {
755            ::sys::cblas_dtbmv(
756                order.into(),
757                uplo.into(),
758                transA.into(),
759                diag.into(),
760                N,
761                K,
762                A.as_ptr(),
763                lda,
764                X.as_mut_ptr(),
765                incx,
766            )
767        }
768    }
769
770    #[doc(alias = "cblas_dtpmv")]
771    pub fn dtpmv(
772        order: enums::CblasOrder,
773        uplo: enums::CblasUplo,
774        transA: enums::CblasTranspose,
775        diag: enums::CblasDiag,
776        N: i32,
777        Ap: &[f64],
778        X: &mut [f64],
779        incx: i32,
780    ) {
781        unsafe {
782            ::sys::cblas_dtpmv(
783                order.into(),
784                uplo.into(),
785                transA.into(),
786                diag.into(),
787                N,
788                Ap.as_ptr(),
789                X.as_mut_ptr(),
790                incx,
791            )
792        }
793    }
794
795    #[doc(alias = "cblas_dtrsv")]
796    pub fn dtrsv(
797        order: enums::CblasOrder,
798        uplo: enums::CblasUplo,
799        transA: enums::CblasTranspose,
800        diag: enums::CblasDiag,
801        N: i32,
802        A: &[f64],
803        lda: i32,
804        X: &mut [f64],
805        incx: i32,
806    ) {
807        unsafe {
808            ::sys::cblas_dtrsv(
809                order.into(),
810                uplo.into(),
811                transA.into(),
812                diag.into(),
813                N,
814                A.as_ptr(),
815                lda,
816                X.as_mut_ptr(),
817                incx,
818            )
819        }
820    }
821
822    #[doc(alias = "cblas_dtbsv")]
823    pub fn dtbsv(
824        order: enums::CblasOrder,
825        uplo: enums::CblasUplo,
826        transA: enums::CblasTranspose,
827        diag: enums::CblasDiag,
828        N: i32,
829        K: i32,
830        A: &[f64],
831        lda: i32,
832        X: &mut [f64],
833        incx: i32,
834    ) {
835        unsafe {
836            ::sys::cblas_dtbsv(
837                order.into(),
838                uplo.into(),
839                transA.into(),
840                diag.into(),
841                N,
842                K,
843                A.as_ptr(),
844                lda,
845                X.as_mut_ptr(),
846                incx,
847            )
848        }
849    }
850
851    #[doc(alias = "cblas_dtpsv")]
852    pub fn dtpsv(
853        order: enums::CblasOrder,
854        uplo: enums::CblasUplo,
855        transA: enums::CblasTranspose,
856        diag: enums::CblasDiag,
857        N: i32,
858        Ap: &[f64],
859        X: &mut [f64],
860        incx: i32,
861    ) {
862        unsafe {
863            ::sys::cblas_dtpsv(
864                order.into(),
865                uplo.into(),
866                transA.into(),
867                diag.into(),
868                N,
869                Ap.as_ptr(),
870                X.as_mut_ptr(),
871                incx,
872            )
873        }
874    }
875
876    #[doc(alias = "cblas_cgemv")]
877    pub fn cgemv<T>(
878        order: enums::CblasOrder,
879        transA: enums::CblasTranspose,
880        M: i32,
881        N: i32,
882        alpha: &[T],
883        A: &[T],
884        lda: i32,
885        X: &[T],
886        incx: i32,
887        beta: &[T],
888        Y: &mut [T],
889        incy: i32,
890    ) {
891        unsafe {
892            ::sys::cblas_cgemv(
893                order.into(),
894                transA.into(),
895                M,
896                N,
897                alpha.as_ptr() as *const _,
898                A.as_ptr() as *const _,
899                lda,
900                X.as_ptr() as *const _,
901                incx,
902                beta.as_ptr() as *const _,
903                Y.as_mut_ptr() as *mut _,
904                incy,
905            )
906        }
907    }
908
909    #[doc(alias = "cblas_cgbmv")]
910    pub fn cgbmv<T>(
911        order: enums::CblasOrder,
912        transA: enums::CblasTranspose,
913        M: i32,
914        N: i32,
915        KL: i32,
916        KU: i32,
917        alpha: &[T],
918        A: &[T],
919        lda: i32,
920        X: &[T],
921        incx: i32,
922        beta: &[T],
923        Y: &mut [T],
924        incy: i32,
925    ) {
926        unsafe {
927            ::sys::cblas_cgbmv(
928                order.into(),
929                transA.into(),
930                M,
931                N,
932                KL,
933                KU,
934                alpha.as_ptr() as *const _,
935                A.as_ptr() as *const _,
936                lda,
937                X.as_ptr() as *const _,
938                incx,
939                beta.as_ptr() as *const _,
940                Y.as_mut_ptr() as *mut _,
941                incy,
942            )
943        }
944    }
945
946    #[doc(alias = "cblas_ctrmv")]
947    pub fn ctrmv<T>(
948        order: enums::CblasOrder,
949        uplo: enums::CblasUplo,
950        transA: enums::CblasTranspose,
951        diag: enums::CblasDiag,
952        N: i32,
953        A: &[T],
954        lda: i32,
955        X: &mut [T],
956        incx: i32,
957    ) {
958        unsafe {
959            ::sys::cblas_ctrmv(
960                order.into(),
961                uplo.into(),
962                transA.into(),
963                diag.into(),
964                N,
965                A.as_ptr() as *const _,
966                lda,
967                X.as_mut_ptr() as *mut _,
968                incx,
969            )
970        }
971    }
972
973    #[doc(alias = "cblas_ctbmv")]
974    pub fn ctbmv<T>(
975        order: enums::CblasOrder,
976        uplo: enums::CblasUplo,
977        transA: enums::CblasTranspose,
978        diag: enums::CblasDiag,
979        N: i32,
980        K: i32,
981        A: &[T],
982        lda: i32,
983        X: &mut [T],
984        incx: i32,
985    ) {
986        unsafe {
987            ::sys::cblas_ctbmv(
988                order.into(),
989                uplo.into(),
990                transA.into(),
991                diag.into(),
992                N,
993                K,
994                A.as_ptr() as *const _,
995                lda,
996                X.as_mut_ptr() as *mut _,
997                incx,
998            )
999        }
1000    }
1001
1002    #[doc(alias = "cblas_ctpmv")]
1003    pub fn ctpmv<T>(
1004        order: enums::CblasOrder,
1005        uplo: enums::CblasUplo,
1006        transA: enums::CblasTranspose,
1007        diag: enums::CblasDiag,
1008        N: i32,
1009        Ap: &[T],
1010        X: &mut [T],
1011        incx: i32,
1012    ) {
1013        unsafe {
1014            ::sys::cblas_ctpmv(
1015                order.into(),
1016                uplo.into(),
1017                transA.into(),
1018                diag.into(),
1019                N,
1020                Ap.as_ptr() as *const _,
1021                X.as_mut_ptr() as *mut _,
1022                incx,
1023            )
1024        }
1025    }
1026
1027    #[doc(alias = "cblas_ctrsv")]
1028    pub fn ctrsv<T>(
1029        order: enums::CblasOrder,
1030        uplo: enums::CblasUplo,
1031        transA: enums::CblasTranspose,
1032        diag: enums::CblasDiag,
1033        N: i32,
1034        A: &[T],
1035        lda: i32,
1036        X: &mut [T],
1037        incx: i32,
1038    ) {
1039        unsafe {
1040            ::sys::cblas_ctrsv(
1041                order.into(),
1042                uplo.into(),
1043                transA.into(),
1044                diag.into(),
1045                N,
1046                A.as_ptr() as *const _,
1047                lda,
1048                X.as_mut_ptr() as *mut _,
1049                incx,
1050            )
1051        }
1052    }
1053
1054    #[doc(alias = "cblas_ctbsv")]
1055    pub fn ctbsv<T>(
1056        order: enums::CblasOrder,
1057        uplo: enums::CblasUplo,
1058        transA: enums::CblasTranspose,
1059        diag: enums::CblasDiag,
1060        N: i32,
1061        K: i32,
1062        A: &[T],
1063        lda: i32,
1064        X: &mut [T],
1065        incx: i32,
1066    ) {
1067        unsafe {
1068            ::sys::cblas_ctbsv(
1069                order.into(),
1070                uplo.into(),
1071                transA.into(),
1072                diag.into(),
1073                N,
1074                K,
1075                A.as_ptr() as *const _,
1076                lda,
1077                X.as_mut_ptr() as *mut _,
1078                incx,
1079            )
1080        }
1081    }
1082
1083    #[doc(alias = "cblas_ctpsv")]
1084    pub fn ctpsv<T>(
1085        order: enums::CblasOrder,
1086        uplo: enums::CblasUplo,
1087        transA: enums::CblasTranspose,
1088        diag: enums::CblasDiag,
1089        N: i32,
1090        Ap: &[T],
1091        X: &mut [T],
1092        incx: i32,
1093    ) {
1094        unsafe {
1095            ::sys::cblas_ctpsv(
1096                order.into(),
1097                uplo.into(),
1098                transA.into(),
1099                diag.into(),
1100                N,
1101                Ap.as_ptr() as *const _,
1102                X.as_mut_ptr() as *mut _,
1103                incx,
1104            )
1105        }
1106    }
1107
1108    #[doc(alias = "cblas_zgemv")]
1109    pub fn zgemv<T>(
1110        order: enums::CblasOrder,
1111        transA: enums::CblasTranspose,
1112        M: i32,
1113        N: i32,
1114        alpha: &[T],
1115        A: &[T],
1116        lda: i32,
1117        X: &[T],
1118        incx: i32,
1119        beta: &[T],
1120        Y: &mut [T],
1121        incy: i32,
1122    ) {
1123        unsafe {
1124            ::sys::cblas_zgemv(
1125                order.into(),
1126                transA.into(),
1127                M,
1128                N,
1129                alpha.as_ptr() as *const _,
1130                A.as_ptr() as *const _,
1131                lda,
1132                X.as_ptr() as *const _,
1133                incx,
1134                beta.as_ptr() as *const _,
1135                Y.as_mut_ptr() as *mut _,
1136                incy,
1137            )
1138        }
1139    }
1140
1141    #[doc(alias = "cblas_zgbmv")]
1142    pub fn zgbmv<T>(
1143        order: enums::CblasOrder,
1144        transA: enums::CblasTranspose,
1145        M: i32,
1146        N: i32,
1147        KL: i32,
1148        KU: i32,
1149        alpha: &[T],
1150        A: &[T],
1151        lda: i32,
1152        X: &[T],
1153        incx: i32,
1154        beta: &[T],
1155        Y: &mut [T],
1156        incy: i32,
1157    ) {
1158        unsafe {
1159            ::sys::cblas_zgbmv(
1160                order.into(),
1161                transA.into(),
1162                M,
1163                N,
1164                KL,
1165                KU,
1166                alpha.as_ptr() as *const _,
1167                A.as_ptr() as *const _,
1168                lda,
1169                X.as_ptr() as *const _,
1170                incx,
1171                beta.as_ptr() as *const _,
1172                Y.as_mut_ptr() as *mut _,
1173                incy,
1174            )
1175        }
1176    }
1177
1178    #[doc(alias = "cblas_ztrmv")]
1179    pub fn ztrmv<T>(
1180        order: enums::CblasOrder,
1181        uplo: enums::CblasUplo,
1182        transA: enums::CblasTranspose,
1183        diag: enums::CblasDiag,
1184        N: i32,
1185        A: &[T],
1186        lda: i32,
1187        X: &mut [T],
1188        incx: i32,
1189    ) {
1190        unsafe {
1191            ::sys::cblas_ztrmv(
1192                order.into(),
1193                uplo.into(),
1194                transA.into(),
1195                diag.into(),
1196                N,
1197                A.as_ptr() as *const _,
1198                lda,
1199                X.as_mut_ptr() as *mut _,
1200                incx,
1201            )
1202        }
1203    }
1204
1205    #[doc(alias = "cblas_ztbmv")]
1206    pub fn ztbmv<T>(
1207        order: enums::CblasOrder,
1208        uplo: enums::CblasUplo,
1209        transA: enums::CblasTranspose,
1210        diag: enums::CblasDiag,
1211        N: i32,
1212        K: i32,
1213        A: &[T],
1214        lda: i32,
1215        X: &mut [T],
1216        incx: i32,
1217    ) {
1218        unsafe {
1219            ::sys::cblas_ztbmv(
1220                order.into(),
1221                uplo.into(),
1222                transA.into(),
1223                diag.into(),
1224                N,
1225                K,
1226                A.as_ptr() as *const _,
1227                lda,
1228                X.as_mut_ptr() as *mut _,
1229                incx,
1230            )
1231        }
1232    }
1233
1234    #[doc(alias = "cblas_ztpmv")]
1235    pub fn ztpmv<T>(
1236        order: enums::CblasOrder,
1237        uplo: enums::CblasUplo,
1238        transA: enums::CblasTranspose,
1239        diag: enums::CblasDiag,
1240        N: i32,
1241        Ap: &[T],
1242        X: &mut [T],
1243        incx: i32,
1244    ) {
1245        unsafe {
1246            ::sys::cblas_ztpmv(
1247                order.into(),
1248                uplo.into(),
1249                transA.into(),
1250                diag.into(),
1251                N,
1252                Ap.as_ptr() as *const _,
1253                X.as_mut_ptr() as *mut _,
1254                incx,
1255            )
1256        }
1257    }
1258
1259    #[doc(alias = "cblas_ztrsv")]
1260    pub fn ztrsv<T>(
1261        order: enums::CblasOrder,
1262        uplo: enums::CblasUplo,
1263        transA: enums::CblasTranspose,
1264        diag: enums::CblasDiag,
1265        N: i32,
1266        A: &[T],
1267        lda: i32,
1268        X: &mut [T],
1269        incx: i32,
1270    ) {
1271        unsafe {
1272            ::sys::cblas_ztrsv(
1273                order.into(),
1274                uplo.into(),
1275                transA.into(),
1276                diag.into(),
1277                N,
1278                A.as_ptr() as *const _,
1279                lda,
1280                X.as_mut_ptr() as *mut _,
1281                incx,
1282            )
1283        }
1284    }
1285
1286    #[doc(alias = "cblas_ztbsv")]
1287    pub fn ztbsv<T>(
1288        order: enums::CblasOrder,
1289        uplo: enums::CblasUplo,
1290        transA: enums::CblasTranspose,
1291        diag: enums::CblasDiag,
1292        N: i32,
1293        K: i32,
1294        A: &[T],
1295        lda: i32,
1296        X: &mut [T],
1297        incx: i32,
1298    ) {
1299        unsafe {
1300            ::sys::cblas_ztbsv(
1301                order.into(),
1302                uplo.into(),
1303                transA.into(),
1304                diag.into(),
1305                N,
1306                K,
1307                A.as_ptr() as *const _,
1308                lda,
1309                X.as_mut_ptr() as *mut _,
1310                incx,
1311            )
1312        }
1313    }
1314
1315    #[doc(alias = "cblas_ztpsv")]
1316    pub fn ztpsv<T>(
1317        order: enums::CblasOrder,
1318        uplo: enums::CblasUplo,
1319        transA: enums::CblasTranspose,
1320        diag: enums::CblasDiag,
1321        N: i32,
1322        Ap: &[T],
1323        X: &mut [T],
1324        incx: i32,
1325    ) {
1326        unsafe {
1327            ::sys::cblas_ztpsv(
1328                order.into(),
1329                uplo.into(),
1330                transA.into(),
1331                diag.into(),
1332                N,
1333                Ap.as_ptr() as *const _,
1334                X.as_mut_ptr() as *mut _,
1335                incx,
1336            )
1337        }
1338    }
1339
1340    #[doc(alias = "cblas_ssymv")]
1341    pub fn ssymv(
1342        order: enums::CblasOrder,
1343        uplo: enums::CblasUplo,
1344        N: i32,
1345        alpha: f32,
1346        A: &[f32],
1347        lda: i32,
1348        x: &[f32],
1349        incx: i32,
1350        beta: f32,
1351        y: &mut [f32],
1352        incy: i32,
1353    ) {
1354        unsafe {
1355            ::sys::cblas_ssymv(
1356                order.into(),
1357                uplo.into(),
1358                N,
1359                alpha,
1360                A.as_ptr(),
1361                lda,
1362                x.as_ptr(),
1363                incx,
1364                beta,
1365                y.as_mut_ptr(),
1366                incy,
1367            )
1368        }
1369    }
1370
1371    #[doc(alias = "cblas_ssbmv")]
1372    pub fn ssbmv(
1373        order: enums::CblasOrder,
1374        uplo: enums::CblasUplo,
1375        N: i32,
1376        K: i32,
1377        alpha: f32,
1378        A: &[f32],
1379        lda: i32,
1380        x: &[f32],
1381        incx: i32,
1382        beta: f32,
1383        y: &mut [f32],
1384        incy: i32,
1385    ) {
1386        unsafe {
1387            ::sys::cblas_ssbmv(
1388                order.into(),
1389                uplo.into(),
1390                N,
1391                K,
1392                alpha,
1393                A.as_ptr(),
1394                lda,
1395                x.as_ptr(),
1396                incx,
1397                beta,
1398                y.as_mut_ptr(),
1399                incy,
1400            )
1401        }
1402    }
1403
1404    #[doc(alias = "cblas_sspmv")]
1405    pub fn sspmv(
1406        order: enums::CblasOrder,
1407        uplo: enums::CblasUplo,
1408        N: i32,
1409        alpha: f32,
1410        Ap: &[f32],
1411        x: &[f32],
1412        incx: i32,
1413        beta: f32,
1414        y: &mut [f32],
1415        incy: i32,
1416    ) {
1417        unsafe {
1418            ::sys::cblas_sspmv(
1419                order.into(),
1420                uplo.into(),
1421                N,
1422                alpha,
1423                Ap.as_ptr(),
1424                x.as_ptr(),
1425                incx,
1426                beta,
1427                y.as_mut_ptr(),
1428                incy,
1429            )
1430        }
1431    }
1432
1433    #[doc(alias = "cblas_sger")]
1434    pub fn sger(
1435        order: enums::CblasOrder,
1436        M: i32,
1437        N: i32,
1438        alpha: f32,
1439        x: &[f32],
1440        incx: i32,
1441        y: &[f32],
1442        incy: i32,
1443        A: &mut [f32],
1444        lda: i32,
1445    ) {
1446        unsafe {
1447            ::sys::cblas_sger(
1448                order.into(),
1449                M,
1450                N,
1451                alpha,
1452                x.as_ptr(),
1453                incx,
1454                y.as_ptr(),
1455                incy,
1456                A.as_mut_ptr(),
1457                lda,
1458            )
1459        }
1460    }
1461
1462    #[doc(alias = "cblas_ssyr")]
1463    pub fn ssyr(
1464        order: enums::CblasOrder,
1465        uplo: enums::CblasUplo,
1466        N: i32,
1467        alpha: f32,
1468        x: &[f32],
1469        incx: i32,
1470        A: &mut [f32],
1471        lda: i32,
1472    ) {
1473        unsafe {
1474            ::sys::cblas_ssyr(
1475                order.into(),
1476                uplo.into(),
1477                N,
1478                alpha,
1479                x.as_ptr(),
1480                incx,
1481                A.as_mut_ptr(),
1482                lda,
1483            )
1484        }
1485    }
1486
1487    #[doc(alias = "cblas_sspr")]
1488    pub fn sspr(
1489        order: enums::CblasOrder,
1490        uplo: enums::CblasUplo,
1491        N: i32,
1492        alpha: f32,
1493        x: &[f32],
1494        incx: i32,
1495        Ap: &mut [f32],
1496    ) {
1497        unsafe {
1498            ::sys::cblas_sspr(
1499                order.into(),
1500                uplo.into(),
1501                N,
1502                alpha,
1503                x.as_ptr(),
1504                incx,
1505                Ap.as_mut_ptr(),
1506            )
1507        }
1508    }
1509
1510    #[doc(alias = "cblas_ssyr2")]
1511    pub fn ssyr2(
1512        order: enums::CblasOrder,
1513        uplo: enums::CblasUplo,
1514        N: i32,
1515        alpha: f32,
1516        x: &[f32],
1517        incx: i32,
1518        y: &[f32],
1519        incy: i32,
1520        A: &mut [f32],
1521        lda: i32,
1522    ) {
1523        unsafe {
1524            ::sys::cblas_ssyr2(
1525                order.into(),
1526                uplo.into(),
1527                N,
1528                alpha,
1529                x.as_ptr(),
1530                incx,
1531                y.as_ptr(),
1532                incy,
1533                A.as_mut_ptr(),
1534                lda,
1535            )
1536        }
1537    }
1538
1539    #[doc(alias = "cblas_sspr2")]
1540    pub fn sspr2(
1541        order: enums::CblasOrder,
1542        uplo: enums::CblasUplo,
1543        N: i32,
1544        alpha: f32,
1545        x: &[f32],
1546        incx: i32,
1547        y: &[f32],
1548        incy: i32,
1549        A: &mut [f32],
1550    ) {
1551        unsafe {
1552            ::sys::cblas_sspr2(
1553                order.into(),
1554                uplo.into(),
1555                N,
1556                alpha,
1557                x.as_ptr(),
1558                incx,
1559                y.as_ptr(),
1560                incy,
1561                A.as_mut_ptr(),
1562            )
1563        }
1564    }
1565
1566    #[doc(alias = "cblas_dsymv")]
1567    pub fn dsymv(
1568        order: enums::CblasOrder,
1569        uplo: enums::CblasUplo,
1570        N: i32,
1571        alpha: f64,
1572        A: &[f64],
1573        lda: i32,
1574        x: &[f64],
1575        incx: i32,
1576        beta: f64,
1577        y: &mut [f64],
1578        incy: i32,
1579    ) {
1580        unsafe {
1581            ::sys::cblas_dsymv(
1582                order.into(),
1583                uplo.into(),
1584                N,
1585                alpha,
1586                A.as_ptr(),
1587                lda,
1588                x.as_ptr(),
1589                incx,
1590                beta,
1591                y.as_mut_ptr(),
1592                incy,
1593            )
1594        }
1595    }
1596
1597    #[doc(alias = "cblas_dsbmv")]
1598    pub fn dsbmv(
1599        order: enums::CblasOrder,
1600        uplo: enums::CblasUplo,
1601        N: i32,
1602        K: i32,
1603        alpha: f64,
1604        A: &[f64],
1605        lda: i32,
1606        x: &[f64],
1607        incx: i32,
1608        beta: f64,
1609        y: &mut [f64],
1610        incy: i32,
1611    ) {
1612        unsafe {
1613            ::sys::cblas_dsbmv(
1614                order.into(),
1615                uplo.into(),
1616                N,
1617                K,
1618                alpha,
1619                A.as_ptr(),
1620                lda,
1621                x.as_ptr(),
1622                incx,
1623                beta,
1624                y.as_mut_ptr(),
1625                incy,
1626            )
1627        }
1628    }
1629
1630    #[doc(alias = "cblas_dspmv")]
1631    pub fn dspmv(
1632        order: enums::CblasOrder,
1633        uplo: enums::CblasUplo,
1634        N: i32,
1635        alpha: f64,
1636        Ap: &[f64],
1637        x: &[f64],
1638        incx: i32,
1639        beta: f64,
1640        y: &mut [f64],
1641        incy: i32,
1642    ) {
1643        unsafe {
1644            ::sys::cblas_dspmv(
1645                order.into(),
1646                uplo.into(),
1647                N,
1648                alpha,
1649                Ap.as_ptr(),
1650                x.as_ptr(),
1651                incx,
1652                beta,
1653                y.as_mut_ptr(),
1654                incy,
1655            )
1656        }
1657    }
1658
1659    #[doc(alias = "cblas_dger")]
1660    pub fn dger(
1661        order: enums::CblasOrder,
1662        M: i32,
1663        N: i32,
1664        alpha: f64,
1665        x: &[f64],
1666        incx: i32,
1667        y: &[f64],
1668        incy: i32,
1669        A: &mut [f64],
1670        lda: i32,
1671    ) {
1672        unsafe {
1673            ::sys::cblas_dger(
1674                order.into(),
1675                M,
1676                N,
1677                alpha,
1678                x.as_ptr(),
1679                incx,
1680                y.as_ptr(),
1681                incy,
1682                A.as_mut_ptr(),
1683                lda,
1684            )
1685        }
1686    }
1687
1688    #[doc(alias = "cblas_dsyr")]
1689    pub fn dsyr(
1690        order: enums::CblasOrder,
1691        uplo: enums::CblasUplo,
1692        N: i32,
1693        alpha: f64,
1694        x: &[f64],
1695        incx: i32,
1696        A: &mut [f64],
1697        lda: i32,
1698    ) {
1699        unsafe {
1700            ::sys::cblas_dsyr(
1701                order.into(),
1702                uplo.into(),
1703                N,
1704                alpha,
1705                x.as_ptr(),
1706                incx,
1707                A.as_mut_ptr(),
1708                lda,
1709            )
1710        }
1711    }
1712
1713    #[doc(alias = "cblas_dspr")]
1714    pub fn dspr(
1715        order: enums::CblasOrder,
1716        uplo: enums::CblasUplo,
1717        N: i32,
1718        alpha: f64,
1719        x: &[f64],
1720        incx: i32,
1721        Ap: &mut [f64],
1722    ) {
1723        unsafe {
1724            ::sys::cblas_dspr(
1725                order.into(),
1726                uplo.into(),
1727                N,
1728                alpha,
1729                x.as_ptr(),
1730                incx,
1731                Ap.as_mut_ptr(),
1732            )
1733        }
1734    }
1735
1736    #[doc(alias = "cblas_dsyr2")]
1737    pub fn dsyr2(
1738        order: enums::CblasOrder,
1739        uplo: enums::CblasUplo,
1740        N: i32,
1741        alpha: f64,
1742        x: &[f64],
1743        incx: i32,
1744        y: &[f64],
1745        incy: i32,
1746        A: &mut [f64],
1747        lda: i32,
1748    ) {
1749        unsafe {
1750            ::sys::cblas_dsyr2(
1751                order.into(),
1752                uplo.into(),
1753                N,
1754                alpha,
1755                x.as_ptr(),
1756                incx,
1757                y.as_ptr(),
1758                incy,
1759                A.as_mut_ptr(),
1760                lda,
1761            )
1762        }
1763    }
1764
1765    #[doc(alias = "cblas_dspr2")]
1766    pub fn dspr2(
1767        order: enums::CblasOrder,
1768        uplo: enums::CblasUplo,
1769        N: i32,
1770        alpha: f64,
1771        x: &[f64],
1772        incx: i32,
1773        y: &[f64],
1774        incy: i32,
1775        A: &mut [f64],
1776    ) {
1777        unsafe {
1778            ::sys::cblas_dspr2(
1779                order.into(),
1780                uplo.into(),
1781                N,
1782                alpha,
1783                x.as_ptr(),
1784                incx,
1785                y.as_ptr(),
1786                incy,
1787                A.as_mut_ptr(),
1788            )
1789        }
1790    }
1791
1792    #[doc(alias = "cblas_chemv")]
1793    pub fn chemv<T>(
1794        order: enums::CblasOrder,
1795        uplo: enums::CblasUplo,
1796        N: i32,
1797        alpha: &[T],
1798        A: &[T],
1799        lda: i32,
1800        x: &[T],
1801        incx: i32,
1802        beta: &[T],
1803        y: &mut [T],
1804        incy: i32,
1805    ) {
1806        unsafe {
1807            ::sys::cblas_chemv(
1808                order.into(),
1809                uplo.into(),
1810                N,
1811                alpha.as_ptr() as *const _,
1812                A.as_ptr() as *const _,
1813                lda,
1814                x.as_ptr() as *const _,
1815                incx,
1816                beta.as_ptr() as *const _,
1817                y.as_mut_ptr() as *mut _,
1818                incy,
1819            )
1820        }
1821    }
1822
1823    #[doc(alias = "cblas_chbmv")]
1824    pub fn chbmv<T>(
1825        order: enums::CblasOrder,
1826        uplo: enums::CblasUplo,
1827        N: i32,
1828        K: i32,
1829        alpha: &[T],
1830        A: &[T],
1831        lda: i32,
1832        x: &[T],
1833        incx: i32,
1834        beta: &[T],
1835        y: &mut [T],
1836        incy: i32,
1837    ) {
1838        unsafe {
1839            ::sys::cblas_chbmv(
1840                order.into(),
1841                uplo.into(),
1842                N,
1843                K,
1844                alpha.as_ptr() as *const _,
1845                A.as_ptr() as *const _,
1846                lda,
1847                x.as_ptr() as *const _,
1848                incx,
1849                beta.as_ptr() as *const _,
1850                y.as_mut_ptr() as *mut _,
1851                incy,
1852            )
1853        }
1854    }
1855
1856    #[doc(alias = "cblas_chpmv")]
1857    pub fn chpmv<T>(
1858        order: enums::CblasOrder,
1859        uplo: enums::CblasUplo,
1860        N: i32,
1861        alpha: &[T],
1862        Ap: &[T],
1863        x: &[T],
1864        incx: i32,
1865        beta: &[T],
1866        y: &mut [T],
1867        incy: i32,
1868    ) {
1869        unsafe {
1870            ::sys::cblas_chpmv(
1871                order.into(),
1872                uplo.into(),
1873                N,
1874                alpha.as_ptr() as *const _,
1875                Ap.as_ptr() as *const _,
1876                x.as_ptr() as *const _,
1877                incx,
1878                beta.as_ptr() as *const _,
1879                y.as_mut_ptr() as *mut _,
1880                incy,
1881            )
1882        }
1883    }
1884
1885    #[doc(alias = "cblas_cgeru")]
1886    pub fn cgeru<T>(
1887        order: enums::CblasOrder,
1888        M: i32,
1889        N: i32,
1890        alpha: &[T],
1891        x: &[T],
1892        incx: i32,
1893        y: &[T],
1894        incy: i32,
1895        A: &mut [T],
1896        lda: i32,
1897    ) {
1898        unsafe {
1899            ::sys::cblas_cgeru(
1900                order.into(),
1901                M,
1902                N,
1903                alpha.as_ptr() as *const _,
1904                x.as_ptr() as *const _,
1905                incx,
1906                y.as_ptr() as *const _,
1907                incy,
1908                A.as_mut_ptr() as *mut _,
1909                lda,
1910            )
1911        }
1912    }
1913
1914    #[doc(alias = "cblas_cgerc")]
1915    pub fn cgerc<T>(
1916        order: enums::CblasOrder,
1917        M: i32,
1918        N: i32,
1919        alpha: &[T],
1920        x: &[T],
1921        incx: i32,
1922        y: &[T],
1923        incy: i32,
1924        A: &mut [T],
1925        lda: i32,
1926    ) {
1927        unsafe {
1928            ::sys::cblas_cgerc(
1929                order.into(),
1930                M,
1931                N,
1932                alpha.as_ptr() as *const _,
1933                x.as_ptr() as *const _,
1934                incx,
1935                y.as_ptr() as *const _,
1936                incy,
1937                A.as_mut_ptr() as *mut _,
1938                lda,
1939            )
1940        }
1941    }
1942
1943    #[doc(alias = "cblas_cher")]
1944    pub fn cher<T>(
1945        order: enums::CblasOrder,
1946        uplo: enums::CblasUplo,
1947        N: i32,
1948        alpha: f32,
1949        x: &[T],
1950        incx: i32,
1951        A: &mut [T],
1952        lda: i32,
1953    ) {
1954        unsafe {
1955            ::sys::cblas_cher(
1956                order.into(),
1957                uplo.into(),
1958                N,
1959                alpha,
1960                x.as_ptr() as *const _,
1961                incx,
1962                A.as_mut_ptr() as *mut _,
1963                lda,
1964            )
1965        }
1966    }
1967
1968    #[doc(alias = "cblas_chpr")]
1969    pub fn chpr<T>(
1970        order: enums::CblasOrder,
1971        uplo: enums::CblasUplo,
1972        N: i32,
1973        alpha: f32,
1974        x: &[T],
1975        incx: i32,
1976        Ap: &mut [T],
1977    ) {
1978        unsafe {
1979            ::sys::cblas_chpr(
1980                order.into(),
1981                uplo.into(),
1982                N,
1983                alpha,
1984                x.as_ptr() as *const _,
1985                incx,
1986                Ap.as_mut_ptr() as *mut _,
1987            )
1988        }
1989    }
1990
1991    #[doc(alias = "cblas_cher2")]
1992    pub fn cher2<T>(
1993        order: enums::CblasOrder,
1994        uplo: enums::CblasUplo,
1995        N: i32,
1996        alpha: &[T],
1997        x: &[T],
1998        incx: i32,
1999        y: &[T],
2000        incy: i32,
2001        A: &mut [T],
2002        lda: i32,
2003    ) {
2004        unsafe {
2005            ::sys::cblas_cher2(
2006                order.into(),
2007                uplo.into(),
2008                N,
2009                alpha.as_ptr() as *const _,
2010                x.as_ptr() as *const _,
2011                incx,
2012                y.as_ptr() as *const _,
2013                incy,
2014                A.as_mut_ptr() as *mut _,
2015                lda,
2016            )
2017        }
2018    }
2019
2020    #[doc(alias = "cblas_chpr2")]
2021    pub fn chpr2<T>(
2022        order: enums::CblasOrder,
2023        uplo: enums::CblasUplo,
2024        N: i32,
2025        alpha: &[T],
2026        x: &[T],
2027        incx: i32,
2028        y: &[f64],
2029        incy: i32,
2030        Ap: &mut [f64],
2031    ) {
2032        unsafe {
2033            ::sys::cblas_chpr2(
2034                order.into(),
2035                uplo.into(),
2036                N,
2037                alpha.as_ptr() as *const _,
2038                x.as_ptr() as *const _,
2039                incx,
2040                y.as_ptr() as *const _,
2041                incy,
2042                Ap.as_mut_ptr() as *mut _,
2043            )
2044        }
2045    }
2046
2047    #[doc(alias = "cblas_zhemv")]
2048    pub fn zhemv<T>(
2049        order: enums::CblasOrder,
2050        uplo: enums::CblasUplo,
2051        N: i32,
2052        alpha: &[T],
2053        A: &[T],
2054        lda: i32,
2055        x: &[T],
2056        incx: i32,
2057        beta: &[T],
2058        y: &mut [T],
2059        incy: i32,
2060    ) {
2061        unsafe {
2062            ::sys::cblas_zhemv(
2063                order.into(),
2064                uplo.into(),
2065                N,
2066                alpha.as_ptr() as *const _,
2067                A.as_ptr() as *const _,
2068                lda,
2069                x.as_ptr() as *const _,
2070                incx,
2071                beta.as_ptr() as *const _,
2072                y.as_mut_ptr() as *mut _,
2073                incy,
2074            )
2075        }
2076    }
2077
2078    #[doc(alias = "cblas_zhbmv")]
2079    pub fn zhbmv<T>(
2080        order: enums::CblasOrder,
2081        uplo: enums::CblasUplo,
2082        N: i32,
2083        K: i32,
2084        alpha: &[T],
2085        A: &[T],
2086        lda: i32,
2087        x: &[T],
2088        incx: i32,
2089        beta: &[T],
2090        y: &mut [T],
2091        incy: i32,
2092    ) {
2093        unsafe {
2094            ::sys::cblas_zhbmv(
2095                order.into(),
2096                uplo.into(),
2097                N,
2098                K,
2099                alpha.as_ptr() as *const _,
2100                A.as_ptr() as *const _,
2101                lda,
2102                x.as_ptr() as *const _,
2103                incx,
2104                beta.as_ptr() as *const _,
2105                y.as_mut_ptr() as *mut _,
2106                incy,
2107            )
2108        }
2109    }
2110
2111    #[doc(alias = "cblas_zhpmv")]
2112    pub fn zhpmv<T>(
2113        order: enums::CblasOrder,
2114        uplo: enums::CblasUplo,
2115        N: i32,
2116        alpha: &[T],
2117        Ap: &[T],
2118        x: &[T],
2119        incx: i32,
2120        beta: &[T],
2121        y: &mut [T],
2122        incy: i32,
2123    ) {
2124        unsafe {
2125            ::sys::cblas_zhpmv(
2126                order.into(),
2127                uplo.into(),
2128                N,
2129                alpha.as_ptr() as *const _,
2130                Ap.as_ptr() as *const _,
2131                x.as_ptr() as *const _,
2132                incx,
2133                beta.as_ptr() as *const _,
2134                y.as_mut_ptr() as *mut _,
2135                incy,
2136            )
2137        }
2138    }
2139
2140    #[doc(alias = "cblas_zgeru")]
2141    pub fn zgeru<T>(
2142        order: enums::CblasOrder,
2143        M: i32,
2144        N: i32,
2145        alpha: &[T],
2146        x: &[T],
2147        incx: i32,
2148        y: &[T],
2149        incy: i32,
2150        A: &mut [T],
2151        lda: i32,
2152    ) {
2153        unsafe {
2154            ::sys::cblas_zgeru(
2155                order.into(),
2156                M,
2157                N,
2158                alpha.as_ptr() as *const _,
2159                x.as_ptr() as *const _,
2160                incx,
2161                y.as_ptr() as *const _,
2162                incy,
2163                A.as_mut_ptr() as *mut _,
2164                lda,
2165            )
2166        }
2167    }
2168
2169    #[doc(alias = "cblas_zgerc")]
2170    pub fn zgerc<T>(
2171        order: enums::CblasOrder,
2172        M: i32,
2173        N: i32,
2174        alpha: &[T],
2175        x: &[T],
2176        incx: i32,
2177        y: &[T],
2178        incy: i32,
2179        A: &mut [T],
2180        lda: i32,
2181    ) {
2182        unsafe {
2183            ::sys::cblas_zgerc(
2184                order.into(),
2185                M,
2186                N,
2187                alpha.as_ptr() as *const _,
2188                x.as_ptr() as *const _,
2189                incx,
2190                y.as_ptr() as *const _,
2191                incy,
2192                A.as_mut_ptr() as *mut _,
2193                lda,
2194            )
2195        }
2196    }
2197
2198    #[doc(alias = "cblas_zher")]
2199    pub fn zher<T>(
2200        order: enums::CblasOrder,
2201        uplo: enums::CblasUplo,
2202        N: i32,
2203        alpha: f64,
2204        x: &[T],
2205        incx: i32,
2206        A: &mut [T],
2207        lda: i32,
2208    ) {
2209        unsafe {
2210            ::sys::cblas_zher(
2211                order.into(),
2212                uplo.into(),
2213                N,
2214                alpha,
2215                x.as_ptr() as *const _,
2216                incx,
2217                A.as_mut_ptr() as *mut _,
2218                lda,
2219            )
2220        }
2221    }
2222
2223    #[doc(alias = "cblas_zhpr")]
2224    pub fn zhpr<T>(
2225        order: enums::CblasOrder,
2226        uplo: enums::CblasUplo,
2227        N: i32,
2228        alpha: f64,
2229        x: &[T],
2230        incx: i32,
2231        Ap: &mut [T],
2232    ) {
2233        unsafe {
2234            ::sys::cblas_zhpr(
2235                order.into(),
2236                uplo.into(),
2237                N,
2238                alpha,
2239                x.as_ptr() as *const _,
2240                incx,
2241                Ap.as_mut_ptr() as *mut _,
2242            )
2243        }
2244    }
2245
2246    #[doc(alias = "cblas_zher2")]
2247    pub fn zher2<T>(
2248        order: enums::CblasOrder,
2249        uplo: enums::CblasUplo,
2250        N: i32,
2251        alpha: &[T],
2252        x: &[T],
2253        incx: i32,
2254        y: &[T],
2255        incy: i32,
2256        A: &mut [T],
2257        lda: i32,
2258    ) {
2259        unsafe {
2260            ::sys::cblas_zher2(
2261                order.into(),
2262                uplo.into(),
2263                N,
2264                alpha.as_ptr() as *const _,
2265                x.as_ptr() as *const _,
2266                incx,
2267                y.as_ptr() as *const _,
2268                incy,
2269                A.as_mut_ptr() as *mut _,
2270                lda,
2271            )
2272        }
2273    }
2274
2275    #[doc(alias = "cblas_zhpr2")]
2276    pub fn zhpr2<T>(
2277        order: enums::CblasOrder,
2278        uplo: enums::CblasUplo,
2279        N: i32,
2280        alpha: &[T],
2281        x: &[T],
2282        incx: i32,
2283        y: &[f64],
2284        incy: i32,
2285        Ap: &mut [f64],
2286    ) {
2287        unsafe {
2288            ::sys::cblas_zhpr2(
2289                order.into(),
2290                uplo.into(),
2291                N,
2292                alpha.as_ptr() as *const _,
2293                x.as_ptr() as *const _,
2294                incx,
2295                y.as_ptr() as *const _,
2296                incy,
2297                Ap.as_mut_ptr() as *mut _,
2298            )
2299        }
2300    }
2301}
2302
2303pub mod level3 {
2304    use crate::enums;
2305
2306    /// General ::types::Matrix-MatrixF64 multiplication for single precision float.
2307    ///
2308    /// __Parameters:__
2309    ///
2310    /// * order : Whether matrices are row major order (C-Style) for column major order (Fortran-style). One of enum CblasRowMajor or CblasColMajor.
2311    /// * transA : Whether to transpose matrix A. One of enum CblasNoTrans, CBlasTrans, CBlasConjTrans.
2312    /// * transB : Whether to transpose matrix B. One of enum CblasNoTrans, CBlasTrans, CBlasConjTrans.
2313    /// * M : Rows in matrices A and C
2314    /// * N : Columns in Matrices B and C
2315    /// * K : Columns in matrix A and Rows in matrix B
2316    /// * alpha : scalar factor for op(A)op(B)
2317    /// * A : matrix A
2318    /// * lda : The size of the first dimension of matrix A
2319    /// * B : matrix B
2320    /// * ldb : The size of the first dimension of matrix B
2321    /// * beta : scalar factor for C
2322    /// * C : matrix C
2323    /// * ldc : The size of the first dimension of matrix C
2324    ///
2325    /// For parameters lda, ldb, and ldc, if you are passing a matrix `D[m][n]`, the value of parameter lda, ldb, or ldc should be m.
2326    #[doc(alias = "cblas_sgemm")]
2327    pub fn sgemm(
2328        order: enums::CblasOrder,
2329        transA: enums::CblasTranspose,
2330        transB: enums::CblasTranspose,
2331        M: i32,
2332        N: i32,
2333        K: i32,
2334        alpha: f32,
2335        A: &[f32],
2336        lda: i32,
2337        B: &[f32],
2338        ldb: i32,
2339        beta: f32,
2340        C: &mut [f32],
2341        ldc: i32,
2342    ) {
2343        unsafe {
2344            ::sys::cblas_sgemm(
2345                order.into(),
2346                transA.into(),
2347                transB.into(),
2348                M,
2349                N,
2350                K,
2351                alpha,
2352                A.as_ptr(),
2353                lda,
2354                B.as_ptr(),
2355                ldb,
2356                beta,
2357                C.as_mut_ptr(),
2358                ldc,
2359            )
2360        }
2361    }
2362
2363    /// Symmetric ::types::Matrix-MatrixF64 multiplication for single precision float.
2364    ///
2365    /// __Parameters:__
2366    ///
2367    /// * order : Whether matrices are row major order (C-Style) for column major order (Fortran-style). One of enum CblasRowMajor or CblasColMajor.
2368    /// * side : If CBlasSideLeft, perform (sigma(A)(B) + beta C). If CBlasSideRight, perform (sigma (B)(A) + beta C)
2369    /// * uplo : Indicates whether to use the upper (CBlasUpper) or lower (CBlasLower) triangle of matrix A
2370    /// * M : Rows in matrices A and C
2371    /// * N : Columns in Matrices B and C
2372    /// * alpha : scalar factor for op(A)op(B)
2373    /// * A : matrix A
2374    /// * lda : The size of the first dimension of matrix A
2375    /// * B : matrix B
2376    /// * ldb : The size of the first dimension of matrix B
2377    /// * beta : scalar factor for C
2378    /// * C : matrix C
2379    /// * ldc : The size of the first dimension of matrix C
2380    #[doc(alias = "cblas_ssymm")]
2381    pub fn ssymm(
2382        order: enums::CblasOrder,
2383        side: enums::CblasSide,
2384        uplo: enums::CblasUplo,
2385        M: i32,
2386        N: i32,
2387        alpha: f32,
2388        A: &[f32],
2389        lda: i32,
2390        B: &[f32],
2391        ldb: i32,
2392        beta: f32,
2393        C: &mut [f32],
2394        ldc: i32,
2395    ) {
2396        unsafe {
2397            ::sys::cblas_ssymm(
2398                order.into(),
2399                side.into(),
2400                uplo.into(),
2401                M,
2402                N,
2403                alpha,
2404                A.as_ptr(),
2405                lda,
2406                B.as_ptr(),
2407                ldb,
2408                beta,
2409                C.as_mut_ptr(),
2410                ldc,
2411            )
2412        }
2413    }
2414
2415    #[doc(alias = "cblas_ssyrk")]
2416    pub fn ssyrk(
2417        order: enums::CblasOrder,
2418        uplo: enums::CblasUplo,
2419        trans: enums::CblasTranspose,
2420        N: i32,
2421        K: i32,
2422        alpha: f32,
2423        A: &[f32],
2424        lda: i32,
2425        beta: f32,
2426        C: &mut [f32],
2427        ldc: i32,
2428    ) {
2429        unsafe {
2430            ::sys::cblas_ssyrk(
2431                order.into(),
2432                uplo.into(),
2433                trans.into(),
2434                N,
2435                K,
2436                alpha,
2437                A.as_ptr(),
2438                lda,
2439                beta,
2440                C.as_mut_ptr(),
2441                ldc,
2442            )
2443        }
2444    }
2445
2446    #[doc(alias = "cblas_ssyr2k")]
2447    pub fn ssyr2k(
2448        order: enums::CblasOrder,
2449        uplo: enums::CblasUplo,
2450        trans: enums::CblasTranspose,
2451        N: i32,
2452        K: i32,
2453        alpha: f32,
2454        A: &[f32],
2455        lda: i32,
2456        B: &[f32],
2457        ldb: i32,
2458        beta: f32,
2459        C: &mut [f32],
2460        ldc: i32,
2461    ) {
2462        unsafe {
2463            ::sys::cblas_ssyr2k(
2464                order.into(),
2465                uplo.into(),
2466                trans.into(),
2467                N,
2468                K,
2469                alpha,
2470                A.as_ptr(),
2471                lda,
2472                B.as_ptr(),
2473                ldb,
2474                beta,
2475                C.as_mut_ptr(),
2476                ldc,
2477            )
2478        }
2479    }
2480
2481    #[doc(alias = "cblas_strmm")]
2482    pub fn strmm(
2483        order: enums::CblasOrder,
2484        side: enums::CblasSide,
2485        uplo: enums::CblasUplo,
2486        transA: enums::CblasTranspose,
2487        diag: enums::CblasDiag,
2488        M: i32,
2489        N: i32,
2490        alpha: f32,
2491        A: &[f32],
2492        lda: i32,
2493        B: &mut [f32],
2494        ldb: i32,
2495    ) {
2496        unsafe {
2497            ::sys::cblas_strmm(
2498                order.into(),
2499                side.into(),
2500                uplo.into(),
2501                transA.into(),
2502                diag.into(),
2503                M,
2504                N,
2505                alpha,
2506                A.as_ptr(),
2507                lda,
2508                B.as_mut_ptr(),
2509                ldb,
2510            )
2511        }
2512    }
2513
2514    #[doc(alias = "cblas_strsm")]
2515    pub fn strsm(
2516        order: enums::CblasOrder,
2517        side: enums::CblasSide,
2518        uplo: enums::CblasUplo,
2519        transA: enums::CblasTranspose,
2520        diag: enums::CblasDiag,
2521        M: i32,
2522        N: i32,
2523        alpha: f32,
2524        A: &[f32],
2525        lda: i32,
2526        B: &mut [f32],
2527        ldb: i32,
2528    ) {
2529        unsafe {
2530            ::sys::cblas_strsm(
2531                order.into(),
2532                side.into(),
2533                uplo.into(),
2534                transA.into(),
2535                diag.into(),
2536                M,
2537                N,
2538                alpha,
2539                A.as_ptr(),
2540                lda,
2541                B.as_mut_ptr(),
2542                ldb,
2543            )
2544        }
2545    }
2546
2547    #[doc(alias = "cblas_dgemm")]
2548    pub fn dgemm(
2549        order: enums::CblasOrder,
2550        transA: enums::CblasTranspose,
2551        transB: enums::CblasTranspose,
2552        M: i32,
2553        N: i32,
2554        K: i32,
2555        alpha: f64,
2556        A: &[f64],
2557        lda: i32,
2558        B: &[f64],
2559        ldb: i32,
2560        beta: f64,
2561        C: &mut [f64],
2562        ldc: i32,
2563    ) {
2564        unsafe {
2565            ::sys::cblas_dgemm(
2566                order.into(),
2567                transA.into(),
2568                transB.into(),
2569                M,
2570                N,
2571                K,
2572                alpha,
2573                A.as_ptr(),
2574                lda,
2575                B.as_ptr(),
2576                ldb,
2577                beta,
2578                C.as_mut_ptr(),
2579                ldc,
2580            )
2581        }
2582    }
2583
2584    #[doc(alias = "cblas_dsymm")]
2585    pub fn dsymm(
2586        order: enums::CblasOrder,
2587        side: enums::CblasSide,
2588        uplo: enums::CblasUplo,
2589        M: i32,
2590        N: i32,
2591        alpha: f64,
2592        A: &[f64],
2593        lda: i32,
2594        B: &[f64],
2595        ldb: i32,
2596        beta: f64,
2597        C: &mut [f64],
2598        ldc: i32,
2599    ) {
2600        unsafe {
2601            ::sys::cblas_dsymm(
2602                order.into(),
2603                side.into(),
2604                uplo.into(),
2605                M,
2606                N,
2607                alpha,
2608                A.as_ptr(),
2609                lda,
2610                B.as_ptr(),
2611                ldb,
2612                beta,
2613                C.as_mut_ptr(),
2614                ldc,
2615            )
2616        }
2617    }
2618
2619    #[doc(alias = "cblas_dsyrk")]
2620    pub fn dsyrk(
2621        order: enums::CblasOrder,
2622        uplo: enums::CblasUplo,
2623        trans: enums::CblasTranspose,
2624        N: i32,
2625        K: i32,
2626        alpha: f64,
2627        A: &[f64],
2628        lda: i32,
2629        beta: f64,
2630        C: &mut [f64],
2631        ldc: i32,
2632    ) {
2633        unsafe {
2634            ::sys::cblas_dsyrk(
2635                order.into(),
2636                uplo.into(),
2637                trans.into(),
2638                N,
2639                K,
2640                alpha,
2641                A.as_ptr(),
2642                lda,
2643                beta,
2644                C.as_mut_ptr(),
2645                ldc,
2646            )
2647        }
2648    }
2649
2650    #[doc(alias = "cblas_dsyr2k")]
2651    pub fn dsyr2k(
2652        order: enums::CblasOrder,
2653        uplo: enums::CblasUplo,
2654        trans: enums::CblasTranspose,
2655        N: i32,
2656        K: i32,
2657        alpha: f64,
2658        A: &[f64],
2659        lda: i32,
2660        B: &[f64],
2661        ldb: i32,
2662        beta: f64,
2663        C: &mut [f64],
2664        ldc: i32,
2665    ) {
2666        unsafe {
2667            ::sys::cblas_dsyr2k(
2668                order.into(),
2669                uplo.into(),
2670                trans.into(),
2671                N,
2672                K,
2673                alpha,
2674                A.as_ptr(),
2675                lda,
2676                B.as_ptr(),
2677                ldb,
2678                beta,
2679                C.as_mut_ptr(),
2680                ldc,
2681            )
2682        }
2683    }
2684
2685    #[doc(alias = "cblas_dtrmm")]
2686    pub fn dtrmm(
2687        order: enums::CblasOrder,
2688        side: enums::CblasSide,
2689        uplo: enums::CblasUplo,
2690        transA: enums::CblasTranspose,
2691        diag: enums::CblasDiag,
2692        M: i32,
2693        N: i32,
2694        alpha: f64,
2695        A: &[f64],
2696        lda: i32,
2697        B: &mut [f64],
2698        ldb: i32,
2699    ) {
2700        unsafe {
2701            ::sys::cblas_dtrmm(
2702                order.into(),
2703                side.into(),
2704                uplo.into(),
2705                transA.into(),
2706                diag.into(),
2707                M,
2708                N,
2709                alpha,
2710                A.as_ptr(),
2711                lda,
2712                B.as_mut_ptr(),
2713                ldb,
2714            )
2715        }
2716    }
2717
2718    #[doc(alias = "cblas_dtrsm")]
2719    pub fn dtrsm(
2720        order: enums::CblasOrder,
2721        side: enums::CblasSide,
2722        uplo: enums::CblasUplo,
2723        transA: enums::CblasTranspose,
2724        diag: enums::CblasDiag,
2725        M: i32,
2726        N: i32,
2727        alpha: f64,
2728        A: &[f64],
2729        lda: i32,
2730        B: &mut [f64],
2731        ldb: i32,
2732    ) {
2733        unsafe {
2734            ::sys::cblas_dtrsm(
2735                order.into(),
2736                side.into(),
2737                uplo.into(),
2738                transA.into(),
2739                diag.into(),
2740                M,
2741                N,
2742                alpha,
2743                A.as_ptr(),
2744                lda,
2745                B.as_mut_ptr(),
2746                ldb,
2747            )
2748        }
2749    }
2750
2751    #[doc(alias = "cblas_cgemm")]
2752    pub fn cgemm<T>(
2753        order: enums::CblasOrder,
2754        transA: enums::CblasTranspose,
2755        transB: enums::CblasTranspose,
2756        M: i32,
2757        N: i32,
2758        K: i32,
2759        alpha: &[T],
2760        A: &[T],
2761        lda: i32,
2762        B: &[T],
2763        ldb: i32,
2764        beta: &[T],
2765        C: &mut [T],
2766        ldc: i32,
2767    ) {
2768        unsafe {
2769            ::sys::cblas_cgemm(
2770                order.into(),
2771                transA.into(),
2772                transB.into(),
2773                M,
2774                N,
2775                K,
2776                alpha.as_ptr() as *const _,
2777                A.as_ptr() as *const _,
2778                lda,
2779                B.as_ptr() as *const _,
2780                ldb,
2781                beta.as_ptr() as *const _,
2782                C.as_mut_ptr() as *mut _,
2783                ldc,
2784            )
2785        }
2786    }
2787
2788    #[doc(alias = "cblas_csymm")]
2789    pub fn csymm<T>(
2790        order: enums::CblasOrder,
2791        side: enums::CblasSide,
2792        uplo: enums::CblasUplo,
2793        M: i32,
2794        N: i32,
2795        alpha: &[T],
2796        A: &[T],
2797        lda: i32,
2798        B: &[T],
2799        ldb: i32,
2800        beta: &[T],
2801        C: &mut [T],
2802        ldc: i32,
2803    ) {
2804        unsafe {
2805            ::sys::cblas_csymm(
2806                order.into(),
2807                side.into(),
2808                uplo.into(),
2809                M,
2810                N,
2811                alpha.as_ptr() as *const _,
2812                A.as_ptr() as *const _,
2813                lda,
2814                B.as_ptr() as *const _,
2815                ldb,
2816                beta.as_ptr() as *const _,
2817                C.as_mut_ptr() as *mut _,
2818                ldc,
2819            )
2820        }
2821    }
2822
2823    #[doc(alias = "cblas_csyrk")]
2824    pub fn csyrk<T>(
2825        order: enums::CblasOrder,
2826        uplo: enums::CblasUplo,
2827        trans: enums::CblasTranspose,
2828        N: i32,
2829        K: i32,
2830        alpha: &[T],
2831        A: &[T],
2832        lda: i32,
2833        beta: &[T],
2834        C: &mut [T],
2835        ldc: i32,
2836    ) {
2837        unsafe {
2838            ::sys::cblas_csyrk(
2839                order.into(),
2840                uplo.into(),
2841                trans.into(),
2842                N,
2843                K,
2844                alpha.as_ptr() as *const _,
2845                A.as_ptr() as *const _,
2846                lda,
2847                beta.as_ptr() as *const _,
2848                C.as_mut_ptr() as *mut _,
2849                ldc,
2850            )
2851        }
2852    }
2853
2854    #[doc(alias = "cblas_csyr2k")]
2855    pub fn csyr2k<T>(
2856        order: enums::CblasOrder,
2857        uplo: enums::CblasUplo,
2858        trans: enums::CblasTranspose,
2859        N: i32,
2860        K: i32,
2861        alpha: &[T],
2862        A: &[T],
2863        lda: i32,
2864        B: &[T],
2865        ldb: i32,
2866        beta: &[T],
2867        C: &mut [T],
2868        ldc: i32,
2869    ) {
2870        unsafe {
2871            ::sys::cblas_csyr2k(
2872                order.into(),
2873                uplo.into(),
2874                trans.into(),
2875                N,
2876                K,
2877                alpha.as_ptr() as *const _,
2878                A.as_ptr() as *const _,
2879                lda,
2880                B.as_ptr() as *const _,
2881                ldb,
2882                beta.as_ptr() as *const _,
2883                C.as_mut_ptr() as *mut _,
2884                ldc,
2885            )
2886        }
2887    }
2888
2889    #[doc(alias = "cblas_ctrmm")]
2890    pub fn ctrmm<T>(
2891        order: enums::CblasOrder,
2892        side: enums::CblasSide,
2893        uplo: enums::CblasUplo,
2894        transA: enums::CblasTranspose,
2895        diag: enums::CblasDiag,
2896        M: i32,
2897        N: i32,
2898        alpha: &[T],
2899        A: &[T],
2900        lda: i32,
2901        B: &mut [T],
2902        ldb: i32,
2903    ) {
2904        unsafe {
2905            ::sys::cblas_ctrmm(
2906                order.into(),
2907                side.into(),
2908                uplo.into(),
2909                transA.into(),
2910                diag.into(),
2911                M,
2912                N,
2913                alpha.as_ptr() as *const _,
2914                A.as_ptr() as *const _,
2915                lda,
2916                B.as_mut_ptr() as *mut _,
2917                ldb,
2918            )
2919        }
2920    }
2921
2922    #[doc(alias = "cblas_ctrsm")]
2923    pub fn ctrsm<T>(
2924        order: enums::CblasOrder,
2925        side: enums::CblasSide,
2926        uplo: enums::CblasUplo,
2927        transA: enums::CblasTranspose,
2928        diag: enums::CblasDiag,
2929        M: i32,
2930        N: i32,
2931        alpha: &[T],
2932        A: &[T],
2933        lda: i32,
2934        B: &mut [T],
2935        ldb: i32,
2936    ) {
2937        unsafe {
2938            ::sys::cblas_ctrsm(
2939                order.into(),
2940                side.into(),
2941                uplo.into(),
2942                transA.into(),
2943                diag.into(),
2944                M,
2945                N,
2946                alpha.as_ptr() as *const _,
2947                A.as_ptr() as *const _,
2948                lda,
2949                B.as_mut_ptr() as *mut _,
2950                ldb,
2951            )
2952        }
2953    }
2954
2955    #[doc(alias = "cblas_zgemm")]
2956    pub fn zgemm<T>(
2957        order: enums::CblasOrder,
2958        transA: enums::CblasTranspose,
2959        transB: enums::CblasTranspose,
2960        M: i32,
2961        N: i32,
2962        K: i32,
2963        alpha: &[T],
2964        A: &[T],
2965        lda: i32,
2966        B: &[T],
2967        ldb: i32,
2968        beta: &[T],
2969        C: &mut [T],
2970        ldc: i32,
2971    ) {
2972        unsafe {
2973            ::sys::cblas_zgemm(
2974                order.into(),
2975                transA.into(),
2976                transB.into(),
2977                M,
2978                N,
2979                K,
2980                alpha.as_ptr() as *const _,
2981                A.as_ptr() as *const _,
2982                lda,
2983                B.as_ptr() as *const _,
2984                ldb,
2985                beta.as_ptr() as *const _,
2986                C.as_mut_ptr() as *mut _,
2987                ldc,
2988            )
2989        }
2990    }
2991
2992    #[doc(alias = "cblas_zsymm")]
2993    pub fn zsymm<T>(
2994        order: enums::CblasOrder,
2995        side: enums::CblasSide,
2996        uplo: enums::CblasUplo,
2997        M: i32,
2998        N: i32,
2999        alpha: &[T],
3000        A: &[T],
3001        lda: i32,
3002        B: &[T],
3003        ldb: i32,
3004        beta: &[T],
3005        C: &mut [T],
3006        ldc: i32,
3007    ) {
3008        unsafe {
3009            ::sys::cblas_zsymm(
3010                order.into(),
3011                side.into(),
3012                uplo.into(),
3013                M,
3014                N,
3015                alpha.as_ptr() as *const _,
3016                A.as_ptr() as *const _,
3017                lda,
3018                B.as_ptr() as *const _,
3019                ldb,
3020                beta.as_ptr() as *const _,
3021                C.as_mut_ptr() as *mut _,
3022                ldc,
3023            )
3024        }
3025    }
3026
3027    #[doc(alias = "cblas_zsyrk")]
3028    pub fn zsyrk<T>(
3029        order: enums::CblasOrder,
3030        uplo: enums::CblasUplo,
3031        trans: enums::CblasTranspose,
3032        N: i32,
3033        K: i32,
3034        alpha: &[T],
3035        A: &[T],
3036        lda: i32,
3037        beta: &[T],
3038        C: &mut [T],
3039        ldc: i32,
3040    ) {
3041        unsafe {
3042            ::sys::cblas_zsyrk(
3043                order.into(),
3044                uplo.into(),
3045                trans.into(),
3046                N,
3047                K,
3048                alpha.as_ptr() as *const _,
3049                A.as_ptr() as *const _,
3050                lda,
3051                beta.as_ptr() as *const _,
3052                C.as_mut_ptr() as *mut _,
3053                ldc,
3054            )
3055        }
3056    }
3057
3058    #[doc(alias = "cblas_zsyr2k")]
3059    pub fn zsyr2k<T>(
3060        order: enums::CblasOrder,
3061        uplo: enums::CblasUplo,
3062        trans: enums::CblasTranspose,
3063        N: i32,
3064        K: i32,
3065        alpha: &[T],
3066        A: &[T],
3067        lda: i32,
3068        B: &[T],
3069        ldb: i32,
3070        beta: &[T],
3071        C: &mut [T],
3072        ldc: i32,
3073    ) {
3074        unsafe {
3075            ::sys::cblas_zsyr2k(
3076                order.into(),
3077                uplo.into(),
3078                trans.into(),
3079                N,
3080                K,
3081                alpha.as_ptr() as *const _,
3082                A.as_ptr() as *const _,
3083                lda,
3084                B.as_ptr() as *const _,
3085                ldb,
3086                beta.as_ptr() as *const _,
3087                C.as_mut_ptr() as *mut _,
3088                ldc,
3089            )
3090        }
3091    }
3092
3093    #[doc(alias = "cblas_ztrmm")]
3094    pub fn ztrmm<T>(
3095        order: enums::CblasOrder,
3096        side: enums::CblasSide,
3097        uplo: enums::CblasUplo,
3098        transA: enums::CblasTranspose,
3099        diag: enums::CblasDiag,
3100        M: i32,
3101        N: i32,
3102        alpha: &[T],
3103        A: &[T],
3104        lda: i32,
3105        B: &mut [T],
3106        ldb: i32,
3107    ) {
3108        unsafe {
3109            ::sys::cblas_ztrmm(
3110                order.into(),
3111                side.into(),
3112                uplo.into(),
3113                transA.into(),
3114                diag.into(),
3115                M,
3116                N,
3117                alpha.as_ptr() as *const _,
3118                A.as_ptr() as *const _,
3119                lda,
3120                B.as_mut_ptr() as *mut _,
3121                ldb,
3122            )
3123        }
3124    }
3125
3126    #[doc(alias = "cblas_ztrsm")]
3127    pub fn ztrsm<T>(
3128        order: enums::CblasOrder,
3129        side: enums::CblasSide,
3130        uplo: enums::CblasUplo,
3131        transA: enums::CblasTranspose,
3132        diag: enums::CblasDiag,
3133        M: i32,
3134        N: i32,
3135        alpha: &[T],
3136        A: &[T],
3137        lda: i32,
3138        B: &mut [T],
3139        ldb: i32,
3140    ) {
3141        unsafe {
3142            ::sys::cblas_ztrsm(
3143                order.into(),
3144                side.into(),
3145                uplo.into(),
3146                transA.into(),
3147                diag.into(),
3148                M,
3149                N,
3150                alpha.as_ptr() as *const _,
3151                A.as_ptr() as *const _,
3152                lda,
3153                B.as_mut_ptr() as *mut _,
3154                ldb,
3155            )
3156        }
3157    }
3158
3159    #[doc(alias = "cblas_chemm")]
3160    pub fn chemm<T>(
3161        order: enums::CblasOrder,
3162        side: enums::CblasSide,
3163        uplo: enums::CblasUplo,
3164        M: i32,
3165        N: i32,
3166        alpha: &[T],
3167        A: &[T],
3168        lda: i32,
3169        B: &[T],
3170        ldb: i32,
3171        beta: &[T],
3172        C: &mut [T],
3173        ldc: i32,
3174    ) {
3175        unsafe {
3176            ::sys::cblas_chemm(
3177                order.into(),
3178                side.into(),
3179                uplo.into(),
3180                M,
3181                N,
3182                alpha.as_ptr() as *const _,
3183                A.as_ptr() as *const _,
3184                lda,
3185                B.as_ptr() as *const _,
3186                ldb,
3187                beta.as_ptr() as *const _,
3188                C.as_mut_ptr() as *mut _,
3189                ldc,
3190            )
3191        }
3192    }
3193
3194    #[doc(alias = "cblas_cherk")]
3195    pub fn cherk<T>(
3196        order: enums::CblasOrder,
3197        uplo: enums::CblasUplo,
3198        trans: enums::CblasTranspose,
3199        N: i32,
3200        K: i32,
3201        alpha: f32,
3202        A: &[T],
3203        lda: i32,
3204        beta: f32,
3205        C: &mut [T],
3206        ldc: i32,
3207    ) {
3208        unsafe {
3209            ::sys::cblas_cherk(
3210                order.into(),
3211                uplo.into(),
3212                trans.into(),
3213                N,
3214                K,
3215                alpha,
3216                A.as_ptr() as *const _,
3217                lda,
3218                beta,
3219                C.as_mut_ptr() as *mut _,
3220                ldc,
3221            )
3222        }
3223    }
3224
3225    #[doc(alias = "cblas_cher2k")]
3226    pub fn cher2k<T>(
3227        order: enums::CblasOrder,
3228        uplo: enums::CblasUplo,
3229        trans: enums::CblasTranspose,
3230        N: i32,
3231        K: i32,
3232        alpha: &[T],
3233        A: &[T],
3234        lda: i32,
3235        B: &[T],
3236        ldb: i32,
3237        beta: f32,
3238        C: &mut [T],
3239        ldc: i32,
3240    ) {
3241        unsafe {
3242            ::sys::cblas_cher2k(
3243                order.into(),
3244                uplo.into(),
3245                trans.into(),
3246                N,
3247                K,
3248                alpha.as_ptr() as *const _,
3249                A.as_ptr() as *const _,
3250                lda,
3251                B.as_ptr() as *const _,
3252                ldb,
3253                beta,
3254                C.as_mut_ptr() as *mut _,
3255                ldc,
3256            )
3257        }
3258    }
3259
3260    #[doc(alias = "cblas_zhemm")]
3261    pub fn zhemm<T>(
3262        order: enums::CblasOrder,
3263        side: enums::CblasSide,
3264        uplo: enums::CblasUplo,
3265        M: i32,
3266        N: i32,
3267        alpha: &[T],
3268        A: &[T],
3269        lda: i32,
3270        B: &[T],
3271        ldb: i32,
3272        beta: &[T],
3273        C: &mut [T],
3274        ldc: i32,
3275    ) {
3276        unsafe {
3277            ::sys::cblas_zhemm(
3278                order.into(),
3279                side.into(),
3280                uplo.into(),
3281                M,
3282                N,
3283                alpha.as_ptr() as *const _,
3284                A.as_ptr() as *const _,
3285                lda,
3286                B.as_ptr() as *const _,
3287                ldb,
3288                beta.as_ptr() as *const _,
3289                C.as_mut_ptr() as *mut _,
3290                ldc,
3291            )
3292        }
3293    }
3294
3295    #[doc(alias = "cblas_zherk")]
3296    pub fn zherk<T>(
3297        order: enums::CblasOrder,
3298        uplo: enums::CblasUplo,
3299        trans: enums::CblasTranspose,
3300        N: i32,
3301        K: i32,
3302        alpha: f64,
3303        A: &[T],
3304        lda: i32,
3305        beta: f64,
3306        C: &mut [T],
3307        ldc: i32,
3308    ) {
3309        unsafe {
3310            ::sys::cblas_zherk(
3311                order.into(),
3312                uplo.into(),
3313                trans.into(),
3314                N,
3315                K,
3316                alpha,
3317                A.as_ptr() as *const _,
3318                lda,
3319                beta,
3320                C.as_mut_ptr() as *mut _,
3321                ldc,
3322            )
3323        }
3324    }
3325
3326    #[doc(alias = "cblas_zher2k")]
3327    pub fn zher2k<T>(
3328        order: enums::CblasOrder,
3329        uplo: enums::CblasUplo,
3330        trans: enums::CblasTranspose,
3331        N: i32,
3332        K: i32,
3333        alpha: &[T],
3334        A: &[T],
3335        lda: i32,
3336        B: &[T],
3337        ldb: i32,
3338        beta: f64,
3339        C: &mut [T],
3340        ldc: i32,
3341    ) {
3342        unsafe {
3343            ::sys::cblas_zher2k(
3344                order.into(),
3345                uplo.into(),
3346                trans.into(),
3347                N,
3348                K,
3349                alpha.as_ptr() as *const _,
3350                A.as_ptr() as *const _,
3351                lda,
3352                B.as_ptr() as *const _,
3353                ldb,
3354                beta,
3355                C.as_mut_ptr() as *mut _,
3356                ldc,
3357            )
3358        }
3359    }
3360}
rgsl/cblas.rs

rgsl/
cblas.rs
