lapack/
lib.rs

1//! Wrappers for [LAPACK] \(Fortran).
2//!
3//! ## [Architecture]
4//!
5//! ## Example
6//!
7//! ```no_run
8//! use lapack::*;
9//!
10//! let n = 3;
11//! let mut a = vec![3.0, 1.0, 1.0, 1.0, 3.0, 1.0, 1.0, 1.0, 3.0];
12//! let mut w = vec![0.0; n as usize];
13//! let mut work = vec![0.0; 4 * n as usize];
14//! let lwork = 4 * n;
15//! let mut info = 0;
16//!
17//! unsafe {
18//!     dsyev(b'V', b'U', n, &mut a, n, &mut w, &mut work, lwork, &mut info);
19//! }
20//!
21//! assert!(info == 0);
22//! for (one, another) in w.iter().zip(&[2.0, 2.0, 5.0]) {
23//!     assert!((one - another).abs() < 1e-14);
24//! }
25//! ```
26//!
27//! [architecture]: https://blas-lapack-rs.github.io/architecture
28//! [lapack]: https://en.wikipedia.org/wiki/LAPACK
29
30extern crate lapack_sys as ffi;
31extern crate libc;
32extern crate num_complex as num;
33
34use libc::c_char;
35use std::mem::transmute;
36
37/// A complex number with 32-bit parts
38#[allow(non_camel_case_types)]
39pub type c32 = num::Complex<f32>;
40
41/// A complex number with 64-bit parts
42#[allow(non_camel_case_types)]
43pub type c64 = num::Complex<f64>;
44
45pub type Select2F32 = Option<extern "C" fn(*const f32, *const f32) -> i32>;
46pub type Select3F32 = Option<extern "C" fn(*const f32, *const f32, *const f32) -> i32>;
47
48pub type Select2F64 = Option<extern "C" fn(*const f64, *const f64) -> i32>;
49pub type Select3F64 = Option<extern "C" fn(*const f64, *const f64, *const f64) -> i32>;
50
51pub type Select1C32 = Option<extern "C" fn(*const c32) -> i32>;
52pub type Select2C32 = Option<extern "C" fn(*const c32, *const c32) -> i32>;
53
54pub type Select1C64 = Option<extern "C" fn(*const c64) -> i32>;
55pub type Select2C64 = Option<extern "C" fn(*const c64, *const c64) -> i32>;
56
57// The rest is generated using `bin/generate.py` and formatted using `rustfmt`.
58// Therefore, all the changes should be made in `bin/generate.py`.
59
60#[inline]
61pub unsafe fn sgetrf(m: i32, n: i32, a: &mut [f32], lda: i32, ipiv: &mut [i32], info: &mut i32) {
62    ffi::sgetrf_(&m, &n, a.as_mut_ptr(), &lda, ipiv.as_mut_ptr(), info)
63}
64
65#[inline]
66pub unsafe fn dgetrf(m: i32, n: i32, a: &mut [f64], lda: i32, ipiv: &mut [i32], info: &mut i32) {
67    ffi::dgetrf_(&m, &n, a.as_mut_ptr(), &lda, ipiv.as_mut_ptr(), info)
68}
69
70#[inline]
71pub unsafe fn cgetrf(m: i32, n: i32, a: &mut [c32], lda: i32, ipiv: &mut [i32], info: &mut i32) {
72    ffi::cgetrf_(
73        &m,
74        &n,
75        a.as_mut_ptr() as *mut _,
76        &lda,
77        ipiv.as_mut_ptr(),
78        info,
79    )
80}
81
82#[inline]
83pub unsafe fn zgetrf(m: i32, n: i32, a: &mut [c64], lda: i32, ipiv: &mut [i32], info: &mut i32) {
84    ffi::zgetrf_(
85        &m,
86        &n,
87        a.as_mut_ptr() as *mut _,
88        &lda,
89        ipiv.as_mut_ptr(),
90        info,
91    )
92}
93
94#[inline]
95pub unsafe fn sgetrf2(m: i32, n: i32, a: &mut [f32], lda: i32, ipiv: &mut [i32], info: &mut i32) {
96    ffi::sgetrf2_(&m, &n, a.as_mut_ptr(), &lda, ipiv.as_mut_ptr(), info)
97}
98
99#[inline]
100pub unsafe fn dgetrf2(m: i32, n: i32, a: &mut [f64], lda: i32, ipiv: &mut [i32], info: &mut i32) {
101    ffi::dgetrf2_(&m, &n, a.as_mut_ptr(), &lda, ipiv.as_mut_ptr(), info)
102}
103
104#[inline]
105pub unsafe fn cgetrf2(m: i32, n: i32, a: &mut [c32], lda: i32, ipiv: &mut [i32], info: &mut i32) {
106    ffi::cgetrf2_(
107        &m,
108        &n,
109        a.as_mut_ptr() as *mut _,
110        &lda,
111        ipiv.as_mut_ptr(),
112        info,
113    )
114}
115
116#[inline]
117pub unsafe fn zgetrf2(m: i32, n: i32, a: &mut [c64], lda: i32, ipiv: &mut [i32], info: &mut i32) {
118    ffi::zgetrf2_(
119        &m,
120        &n,
121        a.as_mut_ptr() as *mut _,
122        &lda,
123        ipiv.as_mut_ptr(),
124        info,
125    )
126}
127
128#[inline]
129pub unsafe fn sgbtrf(
130    m: i32,
131    n: i32,
132    kl: i32,
133    ku: i32,
134    ab: &mut [f32],
135    ldab: i32,
136    ipiv: &mut [i32],
137    info: &mut i32,
138) {
139    ffi::sgbtrf_(
140        &m,
141        &n,
142        &kl,
143        &ku,
144        ab.as_mut_ptr(),
145        &ldab,
146        ipiv.as_mut_ptr(),
147        info,
148    )
149}
150
151#[inline]
152pub unsafe fn dgbtrf(
153    m: i32,
154    n: i32,
155    kl: i32,
156    ku: i32,
157    ab: &mut [f64],
158    ldab: i32,
159    ipiv: &mut [i32],
160    info: &mut i32,
161) {
162    ffi::dgbtrf_(
163        &m,
164        &n,
165        &kl,
166        &ku,
167        ab.as_mut_ptr(),
168        &ldab,
169        ipiv.as_mut_ptr(),
170        info,
171    )
172}
173
174#[inline]
175pub unsafe fn cgbtrf(
176    m: i32,
177    n: i32,
178    kl: i32,
179    ku: i32,
180    ab: &mut [c32],
181    ldab: i32,
182    ipiv: &mut [i32],
183    info: &mut i32,
184) {
185    ffi::cgbtrf_(
186        &m,
187        &n,
188        &kl,
189        &ku,
190        ab.as_mut_ptr() as *mut _,
191        &ldab,
192        ipiv.as_mut_ptr(),
193        info,
194    )
195}
196
197#[inline]
198pub unsafe fn zgbtrf(
199    m: i32,
200    n: i32,
201    kl: i32,
202    ku: i32,
203    ab: &mut [c64],
204    ldab: i32,
205    ipiv: &mut [i32],
206    info: &mut i32,
207) {
208    ffi::zgbtrf_(
209        &m,
210        &n,
211        &kl,
212        &ku,
213        ab.as_mut_ptr() as *mut _,
214        &ldab,
215        ipiv.as_mut_ptr(),
216        info,
217    )
218}
219
220#[inline]
221pub unsafe fn sgttrf(
222    n: i32,
223    dl: &mut [f32],
224    d: &mut [f32],
225    du: &mut [f32],
226    du2: &mut [f32],
227    ipiv: &mut [i32],
228    info: &mut i32,
229) {
230    ffi::sgttrf_(
231        &n,
232        dl.as_mut_ptr(),
233        d.as_mut_ptr(),
234        du.as_mut_ptr(),
235        du2.as_mut_ptr(),
236        ipiv.as_mut_ptr(),
237        info,
238    )
239}
240
241#[inline]
242pub unsafe fn dgttrf(
243    n: i32,
244    dl: &mut [f64],
245    d: &mut [f64],
246    du: &mut [f64],
247    du2: &mut [f64],
248    ipiv: &mut [i32],
249    info: &mut i32,
250) {
251    ffi::dgttrf_(
252        &n,
253        dl.as_mut_ptr(),
254        d.as_mut_ptr(),
255        du.as_mut_ptr(),
256        du2.as_mut_ptr(),
257        ipiv.as_mut_ptr(),
258        info,
259    )
260}
261
262#[inline]
263pub unsafe fn cgttrf(
264    n: i32,
265    dl: &mut [c32],
266    d: &mut [c32],
267    du: &mut [c32],
268    du2: &mut [c32],
269    ipiv: &mut [i32],
270    info: &mut i32,
271) {
272    ffi::cgttrf_(
273        &n,
274        dl.as_mut_ptr() as *mut _,
275        d.as_mut_ptr() as *mut _,
276        du.as_mut_ptr() as *mut _,
277        du2.as_mut_ptr() as *mut _,
278        ipiv.as_mut_ptr(),
279        info,
280    )
281}
282
283#[inline]
284pub unsafe fn zgttrf(
285    n: i32,
286    dl: &mut [c64],
287    d: &mut [c64],
288    du: &mut [c64],
289    du2: &mut [c64],
290    ipiv: &mut [i32],
291    info: &mut i32,
292) {
293    ffi::zgttrf_(
294        &n,
295        dl.as_mut_ptr() as *mut _,
296        d.as_mut_ptr() as *mut _,
297        du.as_mut_ptr() as *mut _,
298        du2.as_mut_ptr() as *mut _,
299        ipiv.as_mut_ptr(),
300        info,
301    )
302}
303
304#[inline]
305pub unsafe fn spotrf2(uplo: u8, n: i32, a: &mut [f32], lda: i32, info: &mut i32) {
306    ffi::spotrf2_(&(uplo as c_char), &n, a.as_mut_ptr(), &lda, info)
307}
308
309#[inline]
310pub unsafe fn dpotrf2(uplo: u8, n: i32, a: &mut [f64], lda: i32, info: &mut i32) {
311    ffi::dpotrf2_(&(uplo as c_char), &n, a.as_mut_ptr(), &lda, info)
312}
313
314#[inline]
315pub unsafe fn cpotrf2(uplo: u8, n: i32, a: &mut [c32], lda: i32, info: &mut i32) {
316    ffi::cpotrf2_(&(uplo as c_char), &n, a.as_mut_ptr() as *mut _, &lda, info)
317}
318
319#[inline]
320pub unsafe fn zpotrf2(uplo: u8, n: i32, a: &mut [c64], lda: i32, info: &mut i32) {
321    ffi::zpotrf2_(&(uplo as c_char), &n, a.as_mut_ptr() as *mut _, &lda, info)
322}
323
324#[inline]
325pub unsafe fn spotrf(uplo: u8, n: i32, a: &mut [f32], lda: i32, info: &mut i32) {
326    ffi::spotrf_(&(uplo as c_char), &n, a.as_mut_ptr(), &lda, info)
327}
328
329#[inline]
330pub unsafe fn dpotrf(uplo: u8, n: i32, a: &mut [f64], lda: i32, info: &mut i32) {
331    ffi::dpotrf_(&(uplo as c_char), &n, a.as_mut_ptr(), &lda, info)
332}
333
334#[inline]
335pub unsafe fn cpotrf(uplo: u8, n: i32, a: &mut [c32], lda: i32, info: &mut i32) {
336    ffi::cpotrf_(&(uplo as c_char), &n, a.as_mut_ptr() as *mut _, &lda, info)
337}
338
339#[inline]
340pub unsafe fn zpotrf(uplo: u8, n: i32, a: &mut [c64], lda: i32, info: &mut i32) {
341    ffi::zpotrf_(&(uplo as c_char), &n, a.as_mut_ptr() as *mut _, &lda, info)
342}
343
344#[inline]
345pub unsafe fn dpstrf(
346    uplo: u8,
347    n: i32,
348    a: &mut [f64],
349    lda: i32,
350    piv: &mut [i32],
351    rank: &mut i32,
352    tol: f64,
353    work: &mut [f64],
354    info: &mut i32,
355) {
356    ffi::dpstrf_(
357        &(uplo as c_char),
358        &n,
359        a.as_mut_ptr(),
360        &lda,
361        piv.as_mut_ptr(),
362        rank,
363        &tol,
364        work.as_mut_ptr(),
365        info,
366    )
367}
368
369#[inline]
370pub unsafe fn spstrf(
371    uplo: u8,
372    n: i32,
373    a: &mut [f32],
374    lda: i32,
375    piv: &mut [i32],
376    rank: &mut i32,
377    tol: f32,
378    work: &mut [f32],
379    info: &mut i32,
380) {
381    ffi::spstrf_(
382        &(uplo as c_char),
383        &n,
384        a.as_mut_ptr(),
385        &lda,
386        piv.as_mut_ptr(),
387        rank,
388        &tol,
389        work.as_mut_ptr(),
390        info,
391    )
392}
393
394#[inline]
395pub unsafe fn zpstrf(
396    uplo: u8,
397    n: i32,
398    a: &mut [c64],
399    lda: i32,
400    piv: &mut [i32],
401    rank: &mut i32,
402    tol: f64,
403    work: &mut [f64],
404    info: &mut i32,
405) {
406    ffi::zpstrf_(
407        &(uplo as c_char),
408        &n,
409        a.as_mut_ptr() as *mut _,
410        &lda,
411        piv.as_mut_ptr(),
412        rank,
413        &tol,
414        work.as_mut_ptr(),
415        info,
416    )
417}
418
419#[inline]
420pub unsafe fn cpstrf(
421    uplo: u8,
422    n: i32,
423    a: &mut [c32],
424    lda: i32,
425    piv: &mut [i32],
426    rank: &mut i32,
427    tol: f32,
428    work: &mut [f32],
429    info: &mut i32,
430) {
431    ffi::cpstrf_(
432        &(uplo as c_char),
433        &n,
434        a.as_mut_ptr() as *mut _,
435        &lda,
436        piv.as_mut_ptr(),
437        rank,
438        &tol,
439        work.as_mut_ptr(),
440        info,
441    )
442}
443
444#[inline]
445pub unsafe fn dpftrf(transr: u8, uplo: u8, n: i32, a: &mut [f64], info: &mut i32) {
446    ffi::dpftrf_(
447        &(transr as c_char),
448        &(uplo as c_char),
449        &n,
450        a.as_mut_ptr(),
451        info,
452    )
453}
454
455#[inline]
456pub unsafe fn spftrf(transr: u8, uplo: u8, n: i32, a: &mut [f32], info: &mut i32) {
457    ffi::spftrf_(
458        &(transr as c_char),
459        &(uplo as c_char),
460        &n,
461        a.as_mut_ptr(),
462        info,
463    )
464}
465
466#[inline]
467pub unsafe fn zpftrf(transr: u8, uplo: u8, n: i32, a: &mut [c64], info: &mut i32) {
468    ffi::zpftrf_(
469        &(transr as c_char),
470        &(uplo as c_char),
471        &n,
472        a.as_mut_ptr() as *mut _,
473        info,
474    )
475}
476
477#[inline]
478pub unsafe fn cpftrf(transr: u8, uplo: u8, n: i32, a: &mut [c32], info: &mut i32) {
479    ffi::cpftrf_(
480        &(transr as c_char),
481        &(uplo as c_char),
482        &n,
483        a.as_mut_ptr() as *mut _,
484        info,
485    )
486}
487
488#[inline]
489pub unsafe fn spptrf(uplo: u8, n: i32, ap: &mut [f32], info: &mut i32) {
490    ffi::spptrf_(&(uplo as c_char), &n, ap.as_mut_ptr(), info)
491}
492
493#[inline]
494pub unsafe fn dpptrf(uplo: u8, n: i32, ap: &mut [f64], info: &mut i32) {
495    ffi::dpptrf_(&(uplo as c_char), &n, ap.as_mut_ptr(), info)
496}
497
498#[inline]
499pub unsafe fn cpptrf(uplo: u8, n: i32, ap: &mut [c32], info: &mut i32) {
500    ffi::cpptrf_(&(uplo as c_char), &n, ap.as_mut_ptr() as *mut _, info)
501}
502
503#[inline]
504pub unsafe fn zpptrf(uplo: u8, n: i32, ap: &mut [c64], info: &mut i32) {
505    ffi::zpptrf_(&(uplo as c_char), &n, ap.as_mut_ptr() as *mut _, info)
506}
507
508#[inline]
509pub unsafe fn spbtrf(uplo: u8, n: i32, kd: i32, ab: &mut [f32], ldab: i32, info: &mut i32) {
510    ffi::spbtrf_(&(uplo as c_char), &n, &kd, ab.as_mut_ptr(), &ldab, info)
511}
512
513#[inline]
514pub unsafe fn dpbtrf(uplo: u8, n: i32, kd: i32, ab: &mut [f64], ldab: i32, info: &mut i32) {
515    ffi::dpbtrf_(&(uplo as c_char), &n, &kd, ab.as_mut_ptr(), &ldab, info)
516}
517
518#[inline]
519pub unsafe fn cpbtrf(uplo: u8, n: i32, kd: i32, ab: &mut [c32], ldab: i32, info: &mut i32) {
520    ffi::cpbtrf_(
521        &(uplo as c_char),
522        &n,
523        &kd,
524        ab.as_mut_ptr() as *mut _,
525        &ldab,
526        info,
527    )
528}
529
530#[inline]
531pub unsafe fn zpbtrf(uplo: u8, n: i32, kd: i32, ab: &mut [c64], ldab: i32, info: &mut i32) {
532    ffi::zpbtrf_(
533        &(uplo as c_char),
534        &n,
535        &kd,
536        ab.as_mut_ptr() as *mut _,
537        &ldab,
538        info,
539    )
540}
541
542#[inline]
543pub unsafe fn spttrf(n: i32, d: &mut [f32], e: &mut [f32], info: &mut i32) {
544    ffi::spttrf_(&n, d.as_mut_ptr(), e.as_mut_ptr(), info)
545}
546
547#[inline]
548pub unsafe fn dpttrf(n: i32, d: &mut [f64], e: &mut [f64], info: &mut i32) {
549    ffi::dpttrf_(&n, d.as_mut_ptr(), e.as_mut_ptr(), info)
550}
551
552#[inline]
553pub unsafe fn cpttrf(n: i32, d: &mut [f32], e: &mut [c32], info: &mut i32) {
554    ffi::cpttrf_(&n, d.as_mut_ptr(), e.as_mut_ptr() as *mut _, info)
555}
556
557#[inline]
558pub unsafe fn zpttrf(n: i32, d: &mut [f64], e: &mut [c64], info: &mut i32) {
559    ffi::zpttrf_(&n, d.as_mut_ptr(), e.as_mut_ptr() as *mut _, info)
560}
561
562#[inline]
563pub unsafe fn ssytrf(
564    uplo: u8,
565    n: i32,
566    a: &mut [f32],
567    lda: i32,
568    ipiv: &mut [i32],
569    work: &mut [f32],
570    lwork: i32,
571    info: &mut i32,
572) {
573    ffi::ssytrf_(
574        &(uplo as c_char),
575        &n,
576        a.as_mut_ptr(),
577        &lda,
578        ipiv.as_mut_ptr(),
579        work.as_mut_ptr(),
580        &lwork,
581        info,
582    )
583}
584
585#[inline]
586pub unsafe fn dsytrf(
587    uplo: u8,
588    n: i32,
589    a: &mut [f64],
590    lda: i32,
591    ipiv: &mut [i32],
592    work: &mut [f64],
593    lwork: i32,
594    info: &mut i32,
595) {
596    ffi::dsytrf_(
597        &(uplo as c_char),
598        &n,
599        a.as_mut_ptr(),
600        &lda,
601        ipiv.as_mut_ptr(),
602        work.as_mut_ptr(),
603        &lwork,
604        info,
605    )
606}
607
608#[inline]
609pub unsafe fn csytrf(
610    uplo: u8,
611    n: i32,
612    a: &mut [c32],
613    lda: i32,
614    ipiv: &mut [i32],
615    work: &mut [c32],
616    lwork: i32,
617    info: &mut i32,
618) {
619    ffi::csytrf_(
620        &(uplo as c_char),
621        &n,
622        a.as_mut_ptr() as *mut _,
623        &lda,
624        ipiv.as_mut_ptr(),
625        work.as_mut_ptr() as *mut _,
626        &lwork,
627        info,
628    )
629}
630
631#[inline]
632pub unsafe fn zsytrf(
633    uplo: u8,
634    n: i32,
635    a: &mut [c64],
636    lda: i32,
637    ipiv: &mut [i32],
638    work: &mut [c64],
639    lwork: i32,
640    info: &mut i32,
641) {
642    ffi::zsytrf_(
643        &(uplo as c_char),
644        &n,
645        a.as_mut_ptr() as *mut _,
646        &lda,
647        ipiv.as_mut_ptr(),
648        work.as_mut_ptr() as *mut _,
649        &lwork,
650        info,
651    )
652}
653
654#[inline]
655pub unsafe fn chetrf(
656    uplo: u8,
657    n: i32,
658    a: &mut [c32],
659    lda: i32,
660    ipiv: &mut [i32],
661    work: &mut [c32],
662    lwork: i32,
663    info: &mut i32,
664) {
665    ffi::chetrf_(
666        &(uplo as c_char),
667        &n,
668        a.as_mut_ptr() as *mut _,
669        &lda,
670        ipiv.as_mut_ptr(),
671        work.as_mut_ptr() as *mut _,
672        &lwork,
673        info,
674    )
675}
676
677#[inline]
678pub unsafe fn zhetrf(
679    uplo: u8,
680    n: i32,
681    a: &mut [c64],
682    lda: i32,
683    ipiv: &mut [i32],
684    work: &mut [c64],
685    lwork: i32,
686    info: &mut i32,
687) {
688    ffi::zhetrf_(
689        &(uplo as c_char),
690        &n,
691        a.as_mut_ptr() as *mut _,
692        &lda,
693        ipiv.as_mut_ptr(),
694        work.as_mut_ptr() as *mut _,
695        &lwork,
696        info,
697    )
698}
699
700#[inline]
701pub unsafe fn ssptrf(uplo: u8, n: i32, ap: &mut [f32], ipiv: &mut [i32], info: &mut i32) {
702    ffi::ssptrf_(
703        &(uplo as c_char),
704        &n,
705        ap.as_mut_ptr(),
706        ipiv.as_mut_ptr(),
707        info,
708    )
709}
710
711#[inline]
712pub unsafe fn dsptrf(uplo: u8, n: i32, ap: &mut [f64], ipiv: &mut [i32], info: &mut i32) {
713    ffi::dsptrf_(
714        &(uplo as c_char),
715        &n,
716        ap.as_mut_ptr(),
717        ipiv.as_mut_ptr(),
718        info,
719    )
720}
721
722#[inline]
723pub unsafe fn csptrf(uplo: u8, n: i32, ap: &mut [c32], ipiv: &mut [i32], info: &mut i32) {
724    ffi::csptrf_(
725        &(uplo as c_char),
726        &n,
727        ap.as_mut_ptr() as *mut _,
728        ipiv.as_mut_ptr(),
729        info,
730    )
731}
732
733#[inline]
734pub unsafe fn zsptrf(uplo: u8, n: i32, ap: &mut [c64], ipiv: &mut [i32], info: &mut i32) {
735    ffi::zsptrf_(
736        &(uplo as c_char),
737        &n,
738        ap.as_mut_ptr() as *mut _,
739        ipiv.as_mut_ptr(),
740        info,
741    )
742}
743
744#[inline]
745pub unsafe fn chptrf(uplo: u8, n: i32, ap: &mut [c32], ipiv: &mut [i32], info: &mut i32) {
746    ffi::chptrf_(
747        &(uplo as c_char),
748        &n,
749        ap.as_mut_ptr() as *mut _,
750        ipiv.as_mut_ptr(),
751        info,
752    )
753}
754
755#[inline]
756pub unsafe fn zhptrf(uplo: u8, n: i32, ap: &mut [c64], ipiv: &mut [i32], info: &mut i32) {
757    ffi::zhptrf_(
758        &(uplo as c_char),
759        &n,
760        ap.as_mut_ptr() as *mut _,
761        ipiv.as_mut_ptr(),
762        info,
763    )
764}
765
766#[inline]
767pub unsafe fn sgetrs(
768    trans: u8,
769    n: i32,
770    nrhs: i32,
771    a: &[f32],
772    lda: i32,
773    ipiv: &[i32],
774    b: &mut [f32],
775    ldb: i32,
776    info: &mut i32,
777) {
778    ffi::sgetrs_(
779        &(trans as c_char),
780        &n,
781        &nrhs,
782        a.as_ptr(),
783        &lda,
784        ipiv.as_ptr(),
785        b.as_mut_ptr(),
786        &ldb,
787        info,
788    )
789}
790
791#[inline]
792pub unsafe fn dgetrs(
793    trans: u8,
794    n: i32,
795    nrhs: i32,
796    a: &[f64],
797    lda: i32,
798    ipiv: &[i32],
799    b: &mut [f64],
800    ldb: i32,
801    info: &mut i32,
802) {
803    ffi::dgetrs_(
804        &(trans as c_char),
805        &n,
806        &nrhs,
807        a.as_ptr(),
808        &lda,
809        ipiv.as_ptr(),
810        b.as_mut_ptr(),
811        &ldb,
812        info,
813    )
814}
815
816#[inline]
817pub unsafe fn cgetrs(
818    trans: u8,
819    n: i32,
820    nrhs: i32,
821    a: &[c32],
822    lda: i32,
823    ipiv: &[i32],
824    b: &mut [c32],
825    ldb: i32,
826    info: &mut i32,
827) {
828    ffi::cgetrs_(
829        &(trans as c_char),
830        &n,
831        &nrhs,
832        a.as_ptr() as *const _,
833        &lda,
834        ipiv.as_ptr(),
835        b.as_mut_ptr() as *mut _,
836        &ldb,
837        info,
838    )
839}
840
841#[inline]
842pub unsafe fn zgetrs(
843    trans: u8,
844    n: i32,
845    nrhs: i32,
846    a: &[c64],
847    lda: i32,
848    ipiv: &[i32],
849    b: &mut [c64],
850    ldb: i32,
851    info: &mut i32,
852) {
853    ffi::zgetrs_(
854        &(trans as c_char),
855        &n,
856        &nrhs,
857        a.as_ptr() as *const _,
858        &lda,
859        ipiv.as_ptr(),
860        b.as_mut_ptr() as *mut _,
861        &ldb,
862        info,
863    )
864}
865
866#[inline]
867pub unsafe fn sgbtrs(
868    trans: u8,
869    n: i32,
870    kl: i32,
871    ku: i32,
872    nrhs: i32,
873    ab: &[f32],
874    ldab: i32,
875    ipiv: &[i32],
876    b: &mut [f32],
877    ldb: i32,
878    info: &mut i32,
879) {
880    ffi::sgbtrs_(
881        &(trans as c_char),
882        &n,
883        &kl,
884        &ku,
885        &nrhs,
886        ab.as_ptr(),
887        &ldab,
888        ipiv.as_ptr(),
889        b.as_mut_ptr(),
890        &ldb,
891        info,
892    )
893}
894
895#[inline]
896pub unsafe fn dgbtrs(
897    trans: u8,
898    n: i32,
899    kl: i32,
900    ku: i32,
901    nrhs: i32,
902    ab: &[f64],
903    ldab: i32,
904    ipiv: &[i32],
905    b: &mut [f64],
906    ldb: i32,
907    info: &mut i32,
908) {
909    ffi::dgbtrs_(
910        &(trans as c_char),
911        &n,
912        &kl,
913        &ku,
914        &nrhs,
915        ab.as_ptr(),
916        &ldab,
917        ipiv.as_ptr(),
918        b.as_mut_ptr(),
919        &ldb,
920        info,
921    )
922}
923
924#[inline]
925pub unsafe fn cgbtrs(
926    trans: u8,
927    n: i32,
928    kl: i32,
929    ku: i32,
930    nrhs: i32,
931    ab: &[c32],
932    ldab: i32,
933    ipiv: &[i32],
934    b: &mut [c32],
935    ldb: i32,
936    info: &mut i32,
937) {
938    ffi::cgbtrs_(
939        &(trans as c_char),
940        &n,
941        &kl,
942        &ku,
943        &nrhs,
944        ab.as_ptr() as *const _,
945        &ldab,
946        ipiv.as_ptr(),
947        b.as_mut_ptr() as *mut _,
948        &ldb,
949        info,
950    )
951}
952
953#[inline]
954pub unsafe fn zgbtrs(
955    trans: u8,
956    n: i32,
957    kl: i32,
958    ku: i32,
959    nrhs: i32,
960    ab: &[c64],
961    ldab: i32,
962    ipiv: &[i32],
963    b: &mut [c64],
964    ldb: i32,
965    info: &mut i32,
966) {
967    ffi::zgbtrs_(
968        &(trans as c_char),
969        &n,
970        &kl,
971        &ku,
972        &nrhs,
973        ab.as_ptr() as *const _,
974        &ldab,
975        ipiv.as_ptr(),
976        b.as_mut_ptr() as *mut _,
977        &ldb,
978        info,
979    )
980}
981
982#[inline]
983pub unsafe fn sgttrs(
984    trans: u8,
985    n: i32,
986    nrhs: i32,
987    dl: &[f32],
988    d: &[f32],
989    du: &[f32],
990    du2: &[f32],
991    ipiv: &[i32],
992    b: &mut [f32],
993    ldb: i32,
994    info: &mut i32,
995) {
996    ffi::sgttrs_(
997        &(trans as c_char),
998        &n,
999        &nrhs,
1000        dl.as_ptr(),
1001        d.as_ptr(),
1002        du.as_ptr(),
1003        du2.as_ptr(),
1004        ipiv.as_ptr(),
1005        b.as_mut_ptr(),
1006        &ldb,
1007        info,
1008    )
1009}
1010
1011#[inline]
1012pub unsafe fn dgttrs(
1013    trans: u8,
1014    n: i32,
1015    nrhs: i32,
1016    dl: &[f64],
1017    d: &[f64],
1018    du: &[f64],
1019    du2: &[f64],
1020    ipiv: &[i32],
1021    b: &mut [f64],
1022    ldb: i32,
1023    info: &mut i32,
1024) {
1025    ffi::dgttrs_(
1026        &(trans as c_char),
1027        &n,
1028        &nrhs,
1029        dl.as_ptr(),
1030        d.as_ptr(),
1031        du.as_ptr(),
1032        du2.as_ptr(),
1033        ipiv.as_ptr(),
1034        b.as_mut_ptr(),
1035        &ldb,
1036        info,
1037    )
1038}
1039
1040#[inline]
1041pub unsafe fn cgttrs(
1042    trans: u8,
1043    n: i32,
1044    nrhs: i32,
1045    dl: &[c32],
1046    d: &[c32],
1047    du: &[c32],
1048    du2: &[c32],
1049    ipiv: &[i32],
1050    b: &mut [c32],
1051    ldb: i32,
1052    info: &mut i32,
1053) {
1054    ffi::cgttrs_(
1055        &(trans as c_char),
1056        &n,
1057        &nrhs,
1058        dl.as_ptr() as *const _,
1059        d.as_ptr() as *const _,
1060        du.as_ptr() as *const _,
1061        du2.as_ptr() as *const _,
1062        ipiv.as_ptr(),
1063        b.as_mut_ptr() as *mut _,
1064        &ldb,
1065        info,
1066    )
1067}
1068
1069#[inline]
1070pub unsafe fn zgttrs(
1071    trans: u8,
1072    n: i32,
1073    nrhs: i32,
1074    dl: &[c64],
1075    d: &[c64],
1076    du: &[c64],
1077    du2: &[c64],
1078    ipiv: &[i32],
1079    b: &mut [c64],
1080    ldb: i32,
1081    info: &mut i32,
1082) {
1083    ffi::zgttrs_(
1084        &(trans as c_char),
1085        &n,
1086        &nrhs,
1087        dl.as_ptr() as *const _,
1088        d.as_ptr() as *const _,
1089        du.as_ptr() as *const _,
1090        du2.as_ptr() as *const _,
1091        ipiv.as_ptr(),
1092        b.as_mut_ptr() as *mut _,
1093        &ldb,
1094        info,
1095    )
1096}
1097
1098#[inline]
1099pub unsafe fn spotrs(
1100    uplo: u8,
1101    n: i32,
1102    nrhs: i32,
1103    a: &[f32],
1104    lda: i32,
1105    b: &mut [f32],
1106    ldb: i32,
1107    info: &mut i32,
1108) {
1109    ffi::spotrs_(
1110        &(uplo as c_char),
1111        &n,
1112        &nrhs,
1113        a.as_ptr(),
1114        &lda,
1115        b.as_mut_ptr(),
1116        &ldb,
1117        info,
1118    )
1119}
1120
1121#[inline]
1122pub unsafe fn dpotrs(
1123    uplo: u8,
1124    n: i32,
1125    nrhs: i32,
1126    a: &[f64],
1127    lda: i32,
1128    b: &mut [f64],
1129    ldb: i32,
1130    info: &mut i32,
1131) {
1132    ffi::dpotrs_(
1133        &(uplo as c_char),
1134        &n,
1135        &nrhs,
1136        a.as_ptr(),
1137        &lda,
1138        b.as_mut_ptr(),
1139        &ldb,
1140        info,
1141    )
1142}
1143
1144#[inline]
1145pub unsafe fn cpotrs(
1146    uplo: u8,
1147    n: i32,
1148    nrhs: i32,
1149    a: &[c32],
1150    lda: i32,
1151    b: &mut [c32],
1152    ldb: i32,
1153    info: &mut i32,
1154) {
1155    ffi::cpotrs_(
1156        &(uplo as c_char),
1157        &n,
1158        &nrhs,
1159        a.as_ptr() as *const _,
1160        &lda,
1161        b.as_mut_ptr() as *mut _,
1162        &ldb,
1163        info,
1164    )
1165}
1166
1167#[inline]
1168pub unsafe fn zpotrs(
1169    uplo: u8,
1170    n: i32,
1171    nrhs: i32,
1172    a: &[c64],
1173    lda: i32,
1174    b: &mut [c64],
1175    ldb: i32,
1176    info: &mut i32,
1177) {
1178    ffi::zpotrs_(
1179        &(uplo as c_char),
1180        &n,
1181        &nrhs,
1182        a.as_ptr() as *const _,
1183        &lda,
1184        b.as_mut_ptr() as *mut _,
1185        &ldb,
1186        info,
1187    )
1188}
1189
1190#[inline]
1191pub unsafe fn dpftrs(
1192    transr: u8,
1193    uplo: u8,
1194    n: i32,
1195    nrhs: i32,
1196    a: &[f64],
1197    b: &mut [f64],
1198    ldb: i32,
1199    info: &mut i32,
1200) {
1201    ffi::dpftrs_(
1202        &(transr as c_char),
1203        &(uplo as c_char),
1204        &n,
1205        &nrhs,
1206        a.as_ptr(),
1207        b.as_mut_ptr(),
1208        &ldb,
1209        info,
1210    )
1211}
1212
1213#[inline]
1214pub unsafe fn spftrs(
1215    transr: u8,
1216    uplo: u8,
1217    n: i32,
1218    nrhs: i32,
1219    a: &[f32],
1220    b: &mut [f32],
1221    ldb: i32,
1222    info: &mut i32,
1223) {
1224    ffi::spftrs_(
1225        &(transr as c_char),
1226        &(uplo as c_char),
1227        &n,
1228        &nrhs,
1229        a.as_ptr(),
1230        b.as_mut_ptr(),
1231        &ldb,
1232        info,
1233    )
1234}
1235
1236#[inline]
1237pub unsafe fn zpftrs(
1238    transr: u8,
1239    uplo: u8,
1240    n: i32,
1241    nrhs: i32,
1242    a: &[c64],
1243    b: &mut [c64],
1244    ldb: i32,
1245    info: &mut i32,
1246) {
1247    ffi::zpftrs_(
1248        &(transr as c_char),
1249        &(uplo as c_char),
1250        &n,
1251        &nrhs,
1252        a.as_ptr() as *const _,
1253        b.as_mut_ptr() as *mut _,
1254        &ldb,
1255        info,
1256    )
1257}
1258
1259#[inline]
1260pub unsafe fn cpftrs(
1261    transr: u8,
1262    uplo: u8,
1263    n: i32,
1264    nrhs: i32,
1265    a: &[c32],
1266    b: &mut [c32],
1267    ldb: i32,
1268    info: &mut i32,
1269) {
1270    ffi::cpftrs_(
1271        &(transr as c_char),
1272        &(uplo as c_char),
1273        &n,
1274        &nrhs,
1275        a.as_ptr() as *const _,
1276        b.as_mut_ptr() as *mut _,
1277        &ldb,
1278        info,
1279    )
1280}
1281
1282#[inline]
1283pub unsafe fn spptrs(
1284    uplo: u8,
1285    n: i32,
1286    nrhs: i32,
1287    ap: &[f32],
1288    b: &mut [f32],
1289    ldb: i32,
1290    info: &mut i32,
1291) {
1292    ffi::spptrs_(
1293        &(uplo as c_char),
1294        &n,
1295        &nrhs,
1296        ap.as_ptr(),
1297        b.as_mut_ptr(),
1298        &ldb,
1299        info,
1300    )
1301}
1302
1303#[inline]
1304pub unsafe fn dpptrs(
1305    uplo: u8,
1306    n: i32,
1307    nrhs: i32,
1308    ap: &[f64],
1309    b: &mut [f64],
1310    ldb: i32,
1311    info: &mut i32,
1312) {
1313    ffi::dpptrs_(
1314        &(uplo as c_char),
1315        &n,
1316        &nrhs,
1317        ap.as_ptr(),
1318        b.as_mut_ptr(),
1319        &ldb,
1320        info,
1321    )
1322}
1323
1324#[inline]
1325pub unsafe fn cpptrs(
1326    uplo: u8,
1327    n: i32,
1328    nrhs: i32,
1329    ap: &[c32],
1330    b: &mut [c32],
1331    ldb: i32,
1332    info: &mut i32,
1333) {
1334    ffi::cpptrs_(
1335        &(uplo as c_char),
1336        &n,
1337        &nrhs,
1338        ap.as_ptr() as *const _,
1339        b.as_mut_ptr() as *mut _,
1340        &ldb,
1341        info,
1342    )
1343}
1344
1345#[inline]
1346pub unsafe fn zpptrs(
1347    uplo: u8,
1348    n: i32,
1349    nrhs: i32,
1350    ap: &[c64],
1351    b: &mut [c64],
1352    ldb: i32,
1353    info: &mut i32,
1354) {
1355    ffi::zpptrs_(
1356        &(uplo as c_char),
1357        &n,
1358        &nrhs,
1359        ap.as_ptr() as *const _,
1360        b.as_mut_ptr() as *mut _,
1361        &ldb,
1362        info,
1363    )
1364}
1365
1366#[inline]
1367pub unsafe fn spbtrs(
1368    uplo: u8,
1369    n: i32,
1370    kd: i32,
1371    nrhs: i32,
1372    ab: &[f32],
1373    ldab: i32,
1374    b: &mut [f32],
1375    ldb: i32,
1376    info: &mut i32,
1377) {
1378    ffi::spbtrs_(
1379        &(uplo as c_char),
1380        &n,
1381        &kd,
1382        &nrhs,
1383        ab.as_ptr(),
1384        &ldab,
1385        b.as_mut_ptr(),
1386        &ldb,
1387        info,
1388    )
1389}
1390
1391#[inline]
1392pub unsafe fn dpbtrs(
1393    uplo: u8,
1394    n: i32,
1395    kd: i32,
1396    nrhs: i32,
1397    ab: &[f64],
1398    ldab: i32,
1399    b: &mut [f64],
1400    ldb: i32,
1401    info: &mut i32,
1402) {
1403    ffi::dpbtrs_(
1404        &(uplo as c_char),
1405        &n,
1406        &kd,
1407        &nrhs,
1408        ab.as_ptr(),
1409        &ldab,
1410        b.as_mut_ptr(),
1411        &ldb,
1412        info,
1413    )
1414}
1415
1416#[inline]
1417pub unsafe fn cpbtrs(
1418    uplo: u8,
1419    n: i32,
1420    kd: i32,
1421    nrhs: i32,
1422    ab: &[c32],
1423    ldab: i32,
1424    b: &mut [c32],
1425    ldb: i32,
1426    info: &mut i32,
1427) {
1428    ffi::cpbtrs_(
1429        &(uplo as c_char),
1430        &n,
1431        &kd,
1432        &nrhs,
1433        ab.as_ptr() as *const _,
1434        &ldab,
1435        b.as_mut_ptr() as *mut _,
1436        &ldb,
1437        info,
1438    )
1439}
1440
1441#[inline]
1442pub unsafe fn zpbtrs(
1443    uplo: u8,
1444    n: i32,
1445    kd: i32,
1446    nrhs: i32,
1447    ab: &[c64],
1448    ldab: i32,
1449    b: &mut [c64],
1450    ldb: i32,
1451    info: &mut i32,
1452) {
1453    ffi::zpbtrs_(
1454        &(uplo as c_char),
1455        &n,
1456        &kd,
1457        &nrhs,
1458        ab.as_ptr() as *const _,
1459        &ldab,
1460        b.as_mut_ptr() as *mut _,
1461        &ldb,
1462        info,
1463    )
1464}
1465
1466#[inline]
1467pub unsafe fn spttrs(
1468    n: i32,
1469    nrhs: i32,
1470    d: &[f32],
1471    e: &[f32],
1472    b: &mut [f32],
1473    ldb: i32,
1474    info: &mut i32,
1475) {
1476    ffi::spttrs_(
1477        &n,
1478        &nrhs,
1479        d.as_ptr(),
1480        e.as_ptr(),
1481        b.as_mut_ptr(),
1482        &ldb,
1483        info,
1484    )
1485}
1486
1487#[inline]
1488pub unsafe fn dpttrs(
1489    n: i32,
1490    nrhs: i32,
1491    d: &[f64],
1492    e: &[f64],
1493    b: &mut [f64],
1494    ldb: i32,
1495    info: &mut i32,
1496) {
1497    ffi::dpttrs_(
1498        &n,
1499        &nrhs,
1500        d.as_ptr(),
1501        e.as_ptr(),
1502        b.as_mut_ptr(),
1503        &ldb,
1504        info,
1505    )
1506}
1507
1508#[inline]
1509pub unsafe fn cpttrs(
1510    uplo: u8,
1511    n: i32,
1512    nrhs: i32,
1513    d: &[f32],
1514    e: &[c32],
1515    b: &mut [c32],
1516    ldb: i32,
1517    info: &mut i32,
1518) {
1519    ffi::cpttrs_(
1520        &(uplo as c_char),
1521        &n,
1522        &nrhs,
1523        d.as_ptr(),
1524        e.as_ptr() as *const _,
1525        b.as_mut_ptr() as *mut _,
1526        &ldb,
1527        info,
1528    )
1529}
1530
1531#[inline]
1532pub unsafe fn zpttrs(
1533    uplo: u8,
1534    n: i32,
1535    nrhs: i32,
1536    d: &[f64],
1537    e: &[c64],
1538    b: &mut [c64],
1539    ldb: i32,
1540    info: &mut i32,
1541) {
1542    ffi::zpttrs_(
1543        &(uplo as c_char),
1544        &n,
1545        &nrhs,
1546        d.as_ptr(),
1547        e.as_ptr() as *const _,
1548        b.as_mut_ptr() as *mut _,
1549        &ldb,
1550        info,
1551    )
1552}
1553
1554#[inline]
1555pub unsafe fn ssytrs(
1556    uplo: u8,
1557    n: i32,
1558    nrhs: i32,
1559    a: &[f32],
1560    lda: i32,
1561    ipiv: &[i32],
1562    b: &mut [f32],
1563    ldb: i32,
1564    info: &mut i32,
1565) {
1566    ffi::ssytrs_(
1567        &(uplo as c_char),
1568        &n,
1569        &nrhs,
1570        a.as_ptr(),
1571        &lda,
1572        ipiv.as_ptr(),
1573        b.as_mut_ptr(),
1574        &ldb,
1575        info,
1576    )
1577}
1578
1579#[inline]
1580pub unsafe fn dsytrs(
1581    uplo: u8,
1582    n: i32,
1583    nrhs: i32,
1584    a: &[f64],
1585    lda: i32,
1586    ipiv: &[i32],
1587    b: &mut [f64],
1588    ldb: i32,
1589    info: &mut i32,
1590) {
1591    ffi::dsytrs_(
1592        &(uplo as c_char),
1593        &n,
1594        &nrhs,
1595        a.as_ptr(),
1596        &lda,
1597        ipiv.as_ptr(),
1598        b.as_mut_ptr(),
1599        &ldb,
1600        info,
1601    )
1602}
1603
1604#[inline]
1605pub unsafe fn csytrs(
1606    uplo: u8,
1607    n: i32,
1608    nrhs: i32,
1609    a: &[c32],
1610    lda: i32,
1611    ipiv: &[i32],
1612    b: &mut [c32],
1613    ldb: i32,
1614    info: &mut i32,
1615) {
1616    ffi::csytrs_(
1617        &(uplo as c_char),
1618        &n,
1619        &nrhs,
1620        a.as_ptr() as *const _,
1621        &lda,
1622        ipiv.as_ptr(),
1623        b.as_mut_ptr() as *mut _,
1624        &ldb,
1625        info,
1626    )
1627}
1628
1629#[inline]
1630pub unsafe fn zsytrs(
1631    uplo: u8,
1632    n: i32,
1633    nrhs: i32,
1634    a: &[c64],
1635    lda: i32,
1636    ipiv: &[i32],
1637    b: &mut [c64],
1638    ldb: i32,
1639    info: &mut i32,
1640) {
1641    ffi::zsytrs_(
1642        &(uplo as c_char),
1643        &n,
1644        &nrhs,
1645        a.as_ptr() as *const _,
1646        &lda,
1647        ipiv.as_ptr(),
1648        b.as_mut_ptr() as *mut _,
1649        &ldb,
1650        info,
1651    )
1652}
1653
1654#[inline]
1655pub unsafe fn chetrs(
1656    uplo: u8,
1657    n: i32,
1658    nrhs: i32,
1659    a: &[c32],
1660    lda: i32,
1661    ipiv: &[i32],
1662    b: &mut [c32],
1663    ldb: i32,
1664    info: &mut i32,
1665) {
1666    ffi::chetrs_(
1667        &(uplo as c_char),
1668        &n,
1669        &nrhs,
1670        a.as_ptr() as *const _,
1671        &lda,
1672        ipiv.as_ptr(),
1673        b.as_mut_ptr() as *mut _,
1674        &ldb,
1675        info,
1676    )
1677}
1678
1679#[inline]
1680pub unsafe fn zhetrs(
1681    uplo: u8,
1682    n: i32,
1683    nrhs: i32,
1684    a: &[c64],
1685    lda: i32,
1686    ipiv: &[i32],
1687    b: &mut [c64],
1688    ldb: i32,
1689    info: &mut i32,
1690) {
1691    ffi::zhetrs_(
1692        &(uplo as c_char),
1693        &n,
1694        &nrhs,
1695        a.as_ptr() as *const _,
1696        &lda,
1697        ipiv.as_ptr(),
1698        b.as_mut_ptr() as *mut _,
1699        &ldb,
1700        info,
1701    )
1702}
1703
1704#[inline]
1705pub unsafe fn ssptrs(
1706    uplo: u8,
1707    n: i32,
1708    nrhs: i32,
1709    ap: &[f32],
1710    ipiv: &[i32],
1711    b: &mut [f32],
1712    ldb: i32,
1713    info: &mut i32,
1714) {
1715    ffi::ssptrs_(
1716        &(uplo as c_char),
1717        &n,
1718        &nrhs,
1719        ap.as_ptr(),
1720        ipiv.as_ptr(),
1721        b.as_mut_ptr(),
1722        &ldb,
1723        info,
1724    )
1725}
1726
1727#[inline]
1728pub unsafe fn dsptrs(
1729    uplo: u8,
1730    n: i32,
1731    nrhs: i32,
1732    ap: &[f64],
1733    ipiv: &[i32],
1734    b: &mut [f64],
1735    ldb: i32,
1736    info: &mut i32,
1737) {
1738    ffi::dsptrs_(
1739        &(uplo as c_char),
1740        &n,
1741        &nrhs,
1742        ap.as_ptr(),
1743        ipiv.as_ptr(),
1744        b.as_mut_ptr(),
1745        &ldb,
1746        info,
1747    )
1748}
1749
1750#[inline]
1751pub unsafe fn csptrs(
1752    uplo: u8,
1753    n: i32,
1754    nrhs: i32,
1755    ap: &[c32],
1756    ipiv: &[i32],
1757    b: &mut [c32],
1758    ldb: i32,
1759    info: &mut i32,
1760) {
1761    ffi::csptrs_(
1762        &(uplo as c_char),
1763        &n,
1764        &nrhs,
1765        ap.as_ptr() as *const _,
1766        ipiv.as_ptr(),
1767        b.as_mut_ptr() as *mut _,
1768        &ldb,
1769        info,
1770    )
1771}
1772
1773#[inline]
1774pub unsafe fn zsptrs(
1775    uplo: u8,
1776    n: i32,
1777    nrhs: i32,
1778    ap: &[c64],
1779    ipiv: &[i32],
1780    b: &mut [c64],
1781    ldb: i32,
1782    info: &mut i32,
1783) {
1784    ffi::zsptrs_(
1785        &(uplo as c_char),
1786        &n,
1787        &nrhs,
1788        ap.as_ptr() as *const _,
1789        ipiv.as_ptr(),
1790        b.as_mut_ptr() as *mut _,
1791        &ldb,
1792        info,
1793    )
1794}
1795
1796#[inline]
1797pub unsafe fn chptrs(
1798    uplo: u8,
1799    n: i32,
1800    nrhs: i32,
1801    ap: &[c32],
1802    ipiv: &[i32],
1803    b: &mut [c32],
1804    ldb: i32,
1805    info: &mut i32,
1806) {
1807    ffi::chptrs_(
1808        &(uplo as c_char),
1809        &n,
1810        &nrhs,
1811        ap.as_ptr() as *const _,
1812        ipiv.as_ptr(),
1813        b.as_mut_ptr() as *mut _,
1814        &ldb,
1815        info,
1816    )
1817}
1818
1819#[inline]
1820pub unsafe fn zhptrs(
1821    uplo: u8,
1822    n: i32,
1823    nrhs: i32,
1824    ap: &[c64],
1825    ipiv: &[i32],
1826    b: &mut [c64],
1827    ldb: i32,
1828    info: &mut i32,
1829) {
1830    ffi::zhptrs_(
1831        &(uplo as c_char),
1832        &n,
1833        &nrhs,
1834        ap.as_ptr() as *const _,
1835        ipiv.as_ptr(),
1836        b.as_mut_ptr() as *mut _,
1837        &ldb,
1838        info,
1839    )
1840}
1841
1842#[inline]
1843pub unsafe fn strtrs(
1844    uplo: u8,
1845    trans: u8,
1846    diag: u8,
1847    n: i32,
1848    nrhs: i32,
1849    a: &[f32],
1850    lda: i32,
1851    b: &mut [f32],
1852    ldb: i32,
1853    info: &mut i32,
1854) {
1855    ffi::strtrs_(
1856        &(uplo as c_char),
1857        &(trans as c_char),
1858        &(diag as c_char),
1859        &n,
1860        &nrhs,
1861        a.as_ptr(),
1862        &lda,
1863        b.as_mut_ptr(),
1864        &ldb,
1865        info,
1866    )
1867}
1868
1869#[inline]
1870pub unsafe fn dtrtrs(
1871    uplo: u8,
1872    trans: u8,
1873    diag: u8,
1874    n: i32,
1875    nrhs: i32,
1876    a: &[f64],
1877    lda: i32,
1878    b: &mut [f64],
1879    ldb: i32,
1880    info: &mut i32,
1881) {
1882    ffi::dtrtrs_(
1883        &(uplo as c_char),
1884        &(trans as c_char),
1885        &(diag as c_char),
1886        &n,
1887        &nrhs,
1888        a.as_ptr(),
1889        &lda,
1890        b.as_mut_ptr(),
1891        &ldb,
1892        info,
1893    )
1894}
1895
1896#[inline]
1897pub unsafe fn ctrtrs(
1898    uplo: u8,
1899    trans: u8,
1900    diag: u8,
1901    n: i32,
1902    nrhs: i32,
1903    a: &[c32],
1904    lda: i32,
1905    b: &mut [c32],
1906    ldb: i32,
1907    info: &mut i32,
1908) {
1909    ffi::ctrtrs_(
1910        &(uplo as c_char),
1911        &(trans as c_char),
1912        &(diag as c_char),
1913        &n,
1914        &nrhs,
1915        a.as_ptr() as *const _,
1916        &lda,
1917        b.as_mut_ptr() as *mut _,
1918        &ldb,
1919        info,
1920    )
1921}
1922
1923#[inline]
1924pub unsafe fn ztrtrs(
1925    uplo: u8,
1926    trans: u8,
1927    diag: u8,
1928    n: i32,
1929    nrhs: i32,
1930    a: &[c64],
1931    lda: i32,
1932    b: &mut [c64],
1933    ldb: i32,
1934    info: &mut i32,
1935) {
1936    ffi::ztrtrs_(
1937        &(uplo as c_char),
1938        &(trans as c_char),
1939        &(diag as c_char),
1940        &n,
1941        &nrhs,
1942        a.as_ptr() as *const _,
1943        &lda,
1944        b.as_mut_ptr() as *mut _,
1945        &ldb,
1946        info,
1947    )
1948}
1949
1950#[inline]
1951pub unsafe fn stptrs(
1952    uplo: u8,
1953    trans: u8,
1954    diag: u8,
1955    n: i32,
1956    nrhs: i32,
1957    ap: &[f32],
1958    b: &mut [f32],
1959    ldb: i32,
1960    info: &mut i32,
1961) {
1962    ffi::stptrs_(
1963        &(uplo as c_char),
1964        &(trans as c_char),
1965        &(diag as c_char),
1966        &n,
1967        &nrhs,
1968        ap.as_ptr(),
1969        b.as_mut_ptr(),
1970        &ldb,
1971        info,
1972    )
1973}
1974
1975#[inline]
1976pub unsafe fn dtptrs(
1977    uplo: u8,
1978    trans: u8,
1979    diag: u8,
1980    n: i32,
1981    nrhs: i32,
1982    ap: &[f64],
1983    b: &mut [f64],
1984    ldb: i32,
1985    info: &mut i32,
1986) {
1987    ffi::dtptrs_(
1988        &(uplo as c_char),
1989        &(trans as c_char),
1990        &(diag as c_char),
1991        &n,
1992        &nrhs,
1993        ap.as_ptr(),
1994        b.as_mut_ptr(),
1995        &ldb,
1996        info,
1997    )
1998}
1999
2000#[inline]
2001pub unsafe fn ctptrs(
2002    uplo: u8,
2003    trans: u8,
2004    diag: u8,
2005    n: i32,
2006    nrhs: i32,
2007    ap: &[c32],
2008    b: &mut [c32],
2009    ldb: i32,
2010    info: &mut i32,
2011) {
2012    ffi::ctptrs_(
2013        &(uplo as c_char),
2014        &(trans as c_char),
2015        &(diag as c_char),
2016        &n,
2017        &nrhs,
2018        ap.as_ptr() as *const _,
2019        b.as_mut_ptr() as *mut _,
2020        &ldb,
2021        info,
2022    )
2023}
2024
2025#[inline]
2026pub unsafe fn ztptrs(
2027    uplo: u8,
2028    trans: u8,
2029    diag: u8,
2030    n: i32,
2031    nrhs: i32,
2032    ap: &[c64],
2033    b: &mut [c64],
2034    ldb: i32,
2035    info: &mut i32,
2036) {
2037    ffi::ztptrs_(
2038        &(uplo as c_char),
2039        &(trans as c_char),
2040        &(diag as c_char),
2041        &n,
2042        &nrhs,
2043        ap.as_ptr() as *const _,
2044        b.as_mut_ptr() as *mut _,
2045        &ldb,
2046        info,
2047    )
2048}
2049
2050#[inline]
2051pub unsafe fn stbtrs(
2052    uplo: u8,
2053    trans: u8,
2054    diag: u8,
2055    n: i32,
2056    kd: i32,
2057    nrhs: i32,
2058    ab: &[f32],
2059    ldab: i32,
2060    b: &mut [f32],
2061    ldb: i32,
2062    info: &mut i32,
2063) {
2064    ffi::stbtrs_(
2065        &(uplo as c_char),
2066        &(trans as c_char),
2067        &(diag as c_char),
2068        &n,
2069        &kd,
2070        &nrhs,
2071        ab.as_ptr(),
2072        &ldab,
2073        b.as_mut_ptr(),
2074        &ldb,
2075        info,
2076    )
2077}
2078
2079#[inline]
2080pub unsafe fn dtbtrs(
2081    uplo: u8,
2082    trans: u8,
2083    diag: u8,
2084    n: i32,
2085    kd: i32,
2086    nrhs: i32,
2087    ab: &[f64],
2088    ldab: i32,
2089    b: &mut [f64],
2090    ldb: i32,
2091    info: &mut i32,
2092) {
2093    ffi::dtbtrs_(
2094        &(uplo as c_char),
2095        &(trans as c_char),
2096        &(diag as c_char),
2097        &n,
2098        &kd,
2099        &nrhs,
2100        ab.as_ptr(),
2101        &ldab,
2102        b.as_mut_ptr(),
2103        &ldb,
2104        info,
2105    )
2106}
2107
2108#[inline]
2109pub unsafe fn ctbtrs(
2110    uplo: u8,
2111    trans: u8,
2112    diag: u8,
2113    n: i32,
2114    kd: i32,
2115    nrhs: i32,
2116    ab: &[c32],
2117    ldab: i32,
2118    b: &mut [c32],
2119    ldb: i32,
2120    info: &mut i32,
2121) {
2122    ffi::ctbtrs_(
2123        &(uplo as c_char),
2124        &(trans as c_char),
2125        &(diag as c_char),
2126        &n,
2127        &kd,
2128        &nrhs,
2129        ab.as_ptr() as *const _,
2130        &ldab,
2131        b.as_mut_ptr() as *mut _,
2132        &ldb,
2133        info,
2134    )
2135}
2136
2137#[inline]
2138pub unsafe fn ztbtrs(
2139    uplo: u8,
2140    trans: u8,
2141    diag: u8,
2142    n: i32,
2143    kd: i32,
2144    nrhs: i32,
2145    ab: &[c64],
2146    ldab: i32,
2147    b: &mut [c64],
2148    ldb: i32,
2149    info: &mut i32,
2150) {
2151    ffi::ztbtrs_(
2152        &(uplo as c_char),
2153        &(trans as c_char),
2154        &(diag as c_char),
2155        &n,
2156        &kd,
2157        &nrhs,
2158        ab.as_ptr() as *const _,
2159        &ldab,
2160        b.as_mut_ptr() as *mut _,
2161        &ldb,
2162        info,
2163    )
2164}
2165
2166#[inline]
2167pub unsafe fn sgecon(
2168    norm: u8,
2169    n: i32,
2170    a: &[f32],
2171    lda: i32,
2172    anorm: f32,
2173    rcond: &mut f32,
2174    work: &mut [f32],
2175    iwork: &mut [i32],
2176    info: &mut i32,
2177) {
2178    ffi::sgecon_(
2179        &(norm as c_char),
2180        &n,
2181        a.as_ptr(),
2182        &lda,
2183        &anorm,
2184        rcond,
2185        work.as_mut_ptr(),
2186        iwork.as_mut_ptr(),
2187        info,
2188    )
2189}
2190
2191#[inline]
2192pub unsafe fn dgecon(
2193    norm: u8,
2194    n: i32,
2195    a: &[f64],
2196    lda: i32,
2197    anorm: f64,
2198    rcond: &mut f64,
2199    work: &mut [f64],
2200    iwork: &mut [i32],
2201    info: &mut i32,
2202) {
2203    ffi::dgecon_(
2204        &(norm as c_char),
2205        &n,
2206        a.as_ptr(),
2207        &lda,
2208        &anorm,
2209        rcond,
2210        work.as_mut_ptr(),
2211        iwork.as_mut_ptr(),
2212        info,
2213    )
2214}
2215
2216#[inline]
2217pub unsafe fn cgecon(
2218    norm: u8,
2219    n: i32,
2220    a: &[c32],
2221    lda: i32,
2222    anorm: f32,
2223    rcond: &mut f32,
2224    work: &mut [c32],
2225    rwork: &mut [f32],
2226    info: &mut i32,
2227) {
2228    ffi::cgecon_(
2229        &(norm as c_char),
2230        &n,
2231        a.as_ptr() as *const _,
2232        &lda,
2233        &anorm,
2234        rcond,
2235        work.as_mut_ptr() as *mut _,
2236        rwork.as_mut_ptr(),
2237        info,
2238    )
2239}
2240
2241#[inline]
2242pub unsafe fn zgecon(
2243    norm: u8,
2244    n: i32,
2245    a: &[c64],
2246    lda: i32,
2247    anorm: f64,
2248    rcond: &mut f64,
2249    work: &mut [c64],
2250    rwork: &mut [f64],
2251    info: &mut i32,
2252) {
2253    ffi::zgecon_(
2254        &(norm as c_char),
2255        &n,
2256        a.as_ptr() as *const _,
2257        &lda,
2258        &anorm,
2259        rcond,
2260        work.as_mut_ptr() as *mut _,
2261        rwork.as_mut_ptr(),
2262        info,
2263    )
2264}
2265
2266#[inline]
2267pub unsafe fn sgbcon(
2268    norm: u8,
2269    n: i32,
2270    kl: i32,
2271    ku: i32,
2272    ab: &[f32],
2273    ldab: i32,
2274    ipiv: &[i32],
2275    anorm: f32,
2276    rcond: &mut f32,
2277    work: &mut [f32],
2278    iwork: &mut [i32],
2279    info: &mut i32,
2280) {
2281    ffi::sgbcon_(
2282        &(norm as c_char),
2283        &n,
2284        &kl,
2285        &ku,
2286        ab.as_ptr(),
2287        &ldab,
2288        ipiv.as_ptr(),
2289        &anorm,
2290        rcond,
2291        work.as_mut_ptr(),
2292        iwork.as_mut_ptr(),
2293        info,
2294    )
2295}
2296
2297#[inline]
2298pub unsafe fn dgbcon(
2299    norm: u8,
2300    n: i32,
2301    kl: i32,
2302    ku: i32,
2303    ab: &[f64],
2304    ldab: i32,
2305    ipiv: &[i32],
2306    anorm: f64,
2307    rcond: &mut f64,
2308    work: &mut [f64],
2309    iwork: &mut [i32],
2310    info: &mut i32,
2311) {
2312    ffi::dgbcon_(
2313        &(norm as c_char),
2314        &n,
2315        &kl,
2316        &ku,
2317        ab.as_ptr(),
2318        &ldab,
2319        ipiv.as_ptr(),
2320        &anorm,
2321        rcond,
2322        work.as_mut_ptr(),
2323        iwork.as_mut_ptr(),
2324        info,
2325    )
2326}
2327
2328#[inline]
2329pub unsafe fn cgbcon(
2330    norm: u8,
2331    n: i32,
2332    kl: i32,
2333    ku: i32,
2334    ab: &[c32],
2335    ldab: i32,
2336    ipiv: &[i32],
2337    anorm: f32,
2338    rcond: &mut f32,
2339    work: &mut [c32],
2340    rwork: &mut [f32],
2341    info: &mut i32,
2342) {
2343    ffi::cgbcon_(
2344        &(norm as c_char),
2345        &n,
2346        &kl,
2347        &ku,
2348        ab.as_ptr() as *const _,
2349        &ldab,
2350        ipiv.as_ptr(),
2351        &anorm,
2352        rcond,
2353        work.as_mut_ptr() as *mut _,
2354        rwork.as_mut_ptr(),
2355        info,
2356    )
2357}
2358
2359#[inline]
2360pub unsafe fn zgbcon(
2361    norm: u8,
2362    n: i32,
2363    kl: i32,
2364    ku: i32,
2365    ab: &[c64],
2366    ldab: i32,
2367    ipiv: &[i32],
2368    anorm: f64,
2369    rcond: &mut f64,
2370    work: &mut [c64],
2371    rwork: &mut [f64],
2372    info: &mut i32,
2373) {
2374    ffi::zgbcon_(
2375        &(norm as c_char),
2376        &n,
2377        &kl,
2378        &ku,
2379        ab.as_ptr() as *const _,
2380        &ldab,
2381        ipiv.as_ptr(),
2382        &anorm,
2383        rcond,
2384        work.as_mut_ptr() as *mut _,
2385        rwork.as_mut_ptr(),
2386        info,
2387    )
2388}
2389
2390#[inline]
2391pub unsafe fn sgtcon(
2392    norm: u8,
2393    n: i32,
2394    dl: &[f32],
2395    d: &[f32],
2396    du: &[f32],
2397    du2: &[f32],
2398    ipiv: &[i32],
2399    anorm: f32,
2400    rcond: &mut f32,
2401    work: &mut [f32],
2402    iwork: &mut [i32],
2403    info: &mut i32,
2404) {
2405    ffi::sgtcon_(
2406        &(norm as c_char),
2407        &n,
2408        dl.as_ptr(),
2409        d.as_ptr(),
2410        du.as_ptr(),
2411        du2.as_ptr(),
2412        ipiv.as_ptr(),
2413        &anorm,
2414        rcond,
2415        work.as_mut_ptr(),
2416        iwork.as_mut_ptr(),
2417        info,
2418    )
2419}
2420
2421#[inline]
2422pub unsafe fn dgtcon(
2423    norm: u8,
2424    n: i32,
2425    dl: &[f64],
2426    d: &[f64],
2427    du: &[f64],
2428    du2: &[f64],
2429    ipiv: &[i32],
2430    anorm: f64,
2431    rcond: &mut f64,
2432    work: &mut [f64],
2433    iwork: &mut [i32],
2434    info: &mut i32,
2435) {
2436    ffi::dgtcon_(
2437        &(norm as c_char),
2438        &n,
2439        dl.as_ptr(),
2440        d.as_ptr(),
2441        du.as_ptr(),
2442        du2.as_ptr(),
2443        ipiv.as_ptr(),
2444        &anorm,
2445        rcond,
2446        work.as_mut_ptr(),
2447        iwork.as_mut_ptr(),
2448        info,
2449    )
2450}
2451
2452#[inline]
2453pub unsafe fn cgtcon(
2454    norm: u8,
2455    n: i32,
2456    dl: &[c32],
2457    d: &[c32],
2458    du: &[c32],
2459    du2: &[c32],
2460    ipiv: &[i32],
2461    anorm: f32,
2462    rcond: &mut f32,
2463    work: &mut [c32],
2464    info: &mut i32,
2465) {
2466    ffi::cgtcon_(
2467        &(norm as c_char),
2468        &n,
2469        dl.as_ptr() as *const _,
2470        d.as_ptr() as *const _,
2471        du.as_ptr() as *const _,
2472        du2.as_ptr() as *const _,
2473        ipiv.as_ptr(),
2474        &anorm,
2475        rcond,
2476        work.as_mut_ptr() as *mut _,
2477        info,
2478    )
2479}
2480
2481#[inline]
2482pub unsafe fn zgtcon(
2483    norm: u8,
2484    n: i32,
2485    dl: &[c64],
2486    d: &[c64],
2487    du: &[c64],
2488    du2: &[c64],
2489    ipiv: &[i32],
2490    anorm: f64,
2491    rcond: &mut f64,
2492    work: &mut [c64],
2493    info: &mut i32,
2494) {
2495    ffi::zgtcon_(
2496        &(norm as c_char),
2497        &n,
2498        dl.as_ptr() as *const _,
2499        d.as_ptr() as *const _,
2500        du.as_ptr() as *const _,
2501        du2.as_ptr() as *const _,
2502        ipiv.as_ptr(),
2503        &anorm,
2504        rcond,
2505        work.as_mut_ptr() as *mut _,
2506        info,
2507    )
2508}
2509
2510#[inline]
2511pub unsafe fn spocon(
2512    uplo: u8,
2513    n: i32,
2514    a: &[f32],
2515    lda: i32,
2516    anorm: f32,
2517    rcond: &mut f32,
2518    work: &mut [f32],
2519    iwork: &mut [i32],
2520    info: &mut i32,
2521) {
2522    ffi::spocon_(
2523        &(uplo as c_char),
2524        &n,
2525        a.as_ptr(),
2526        &lda,
2527        &anorm,
2528        rcond,
2529        work.as_mut_ptr(),
2530        iwork.as_mut_ptr(),
2531        info,
2532    )
2533}
2534
2535#[inline]
2536pub unsafe fn dpocon(
2537    uplo: u8,
2538    n: i32,
2539    a: &[f64],
2540    lda: i32,
2541    anorm: f64,
2542    rcond: &mut f64,
2543    work: &mut [f64],
2544    iwork: &mut [i32],
2545    info: &mut i32,
2546) {
2547    ffi::dpocon_(
2548        &(uplo as c_char),
2549        &n,
2550        a.as_ptr(),
2551        &lda,
2552        &anorm,
2553        rcond,
2554        work.as_mut_ptr(),
2555        iwork.as_mut_ptr(),
2556        info,
2557    )
2558}
2559
2560#[inline]
2561pub unsafe fn cpocon(
2562    uplo: u8,
2563    n: i32,
2564    a: &[c32],
2565    lda: i32,
2566    anorm: f32,
2567    rcond: &mut f32,
2568    work: &mut [c32],
2569    rwork: &mut [f32],
2570    info: &mut i32,
2571) {
2572    ffi::cpocon_(
2573        &(uplo as c_char),
2574        &n,
2575        a.as_ptr() as *const _,
2576        &lda,
2577        &anorm,
2578        rcond,
2579        work.as_mut_ptr() as *mut _,
2580        rwork.as_mut_ptr(),
2581        info,
2582    )
2583}
2584
2585#[inline]
2586pub unsafe fn zpocon(
2587    uplo: u8,
2588    n: i32,
2589    a: &[c64],
2590    lda: i32,
2591    anorm: f64,
2592    rcond: &mut f64,
2593    work: &mut [c64],
2594    rwork: &mut [f64],
2595    info: &mut i32,
2596) {
2597    ffi::zpocon_(
2598        &(uplo as c_char),
2599        &n,
2600        a.as_ptr() as *const _,
2601        &lda,
2602        &anorm,
2603        rcond,
2604        work.as_mut_ptr() as *mut _,
2605        rwork.as_mut_ptr(),
2606        info,
2607    )
2608}
2609
2610#[inline]
2611pub unsafe fn sppcon(
2612    uplo: u8,
2613    n: i32,
2614    ap: &[f32],
2615    anorm: f32,
2616    rcond: &mut f32,
2617    work: &mut [f32],
2618    iwork: &mut [i32],
2619    info: &mut i32,
2620) {
2621    ffi::sppcon_(
2622        &(uplo as c_char),
2623        &n,
2624        ap.as_ptr(),
2625        &anorm,
2626        rcond,
2627        work.as_mut_ptr(),
2628        iwork.as_mut_ptr(),
2629        info,
2630    )
2631}
2632
2633#[inline]
2634pub unsafe fn dppcon(
2635    uplo: u8,
2636    n: i32,
2637    ap: &[f64],
2638    anorm: f64,
2639    rcond: &mut f64,
2640    work: &mut [f64],
2641    iwork: &mut [i32],
2642    info: &mut i32,
2643) {
2644    ffi::dppcon_(
2645        &(uplo as c_char),
2646        &n,
2647        ap.as_ptr(),
2648        &anorm,
2649        rcond,
2650        work.as_mut_ptr(),
2651        iwork.as_mut_ptr(),
2652        info,
2653    )
2654}
2655
2656#[inline]
2657pub unsafe fn cppcon(
2658    uplo: u8,
2659    n: i32,
2660    ap: &[c32],
2661    anorm: f32,
2662    rcond: &mut f32,
2663    work: &mut [c32],
2664    rwork: &mut [f32],
2665    info: &mut i32,
2666) {
2667    ffi::cppcon_(
2668        &(uplo as c_char),
2669        &n,
2670        ap.as_ptr() as *const _,
2671        &anorm,
2672        rcond,
2673        work.as_mut_ptr() as *mut _,
2674        rwork.as_mut_ptr(),
2675        info,
2676    )
2677}
2678
2679#[inline]
2680pub unsafe fn zppcon(
2681    uplo: u8,
2682    n: i32,
2683    ap: &[c64],
2684    anorm: f64,
2685    rcond: &mut f64,
2686    work: &mut [c64],
2687    rwork: &mut [f64],
2688    info: &mut i32,
2689) {
2690    ffi::zppcon_(
2691        &(uplo as c_char),
2692        &n,
2693        ap.as_ptr() as *const _,
2694        &anorm,
2695        rcond,
2696        work.as_mut_ptr() as *mut _,
2697        rwork.as_mut_ptr(),
2698        info,
2699    )
2700}
2701
2702#[inline]
2703pub unsafe fn spbcon(
2704    uplo: u8,
2705    n: i32,
2706    kd: i32,
2707    ab: &[f32],
2708    ldab: i32,
2709    anorm: f32,
2710    rcond: &mut f32,
2711    work: &mut [f32],
2712    iwork: &mut [i32],
2713    info: &mut i32,
2714) {
2715    ffi::spbcon_(
2716        &(uplo as c_char),
2717        &n,
2718        &kd,
2719        ab.as_ptr(),
2720        &ldab,
2721        &anorm,
2722        rcond,
2723        work.as_mut_ptr(),
2724        iwork.as_mut_ptr(),
2725        info,
2726    )
2727}
2728
2729#[inline]
2730pub unsafe fn dpbcon(
2731    uplo: u8,
2732    n: i32,
2733    kd: i32,
2734    ab: &[f64],
2735    ldab: i32,
2736    anorm: f64,
2737    rcond: &mut f64,
2738    work: &mut [f64],
2739    iwork: &mut [i32],
2740    info: &mut i32,
2741) {
2742    ffi::dpbcon_(
2743        &(uplo as c_char),
2744        &n,
2745        &kd,
2746        ab.as_ptr(),
2747        &ldab,
2748        &anorm,
2749        rcond,
2750        work.as_mut_ptr(),
2751        iwork.as_mut_ptr(),
2752        info,
2753    )
2754}
2755
2756#[inline]
2757pub unsafe fn cpbcon(
2758    uplo: u8,
2759    n: i32,
2760    kd: i32,
2761    ab: &[c32],
2762    ldab: i32,
2763    anorm: f32,
2764    rcond: &mut f32,
2765    work: &mut [c32],
2766    rwork: &mut [f32],
2767    info: &mut i32,
2768) {
2769    ffi::cpbcon_(
2770        &(uplo as c_char),
2771        &n,
2772        &kd,
2773        ab.as_ptr() as *const _,
2774        &ldab,
2775        &anorm,
2776        rcond,
2777        work.as_mut_ptr() as *mut _,
2778        rwork.as_mut_ptr(),
2779        info,
2780    )
2781}
2782
2783#[inline]
2784pub unsafe fn zpbcon(
2785    uplo: u8,
2786    n: i32,
2787    kd: i32,
2788    ab: &[c64],
2789    ldab: i32,
2790    anorm: f64,
2791    rcond: &mut f64,
2792    work: &mut [c64],
2793    rwork: &mut [f64],
2794    info: &mut i32,
2795) {
2796    ffi::zpbcon_(
2797        &(uplo as c_char),
2798        &n,
2799        &kd,
2800        ab.as_ptr() as *const _,
2801        &ldab,
2802        &anorm,
2803        rcond,
2804        work.as_mut_ptr() as *mut _,
2805        rwork.as_mut_ptr(),
2806        info,
2807    )
2808}
2809
2810#[inline]
2811pub unsafe fn sptcon(
2812    n: i32,
2813    d: &[f32],
2814    e: &[f32],
2815    anorm: f32,
2816    rcond: &mut f32,
2817    work: &mut [f32],
2818    info: &mut i32,
2819) {
2820    ffi::sptcon_(
2821        &n,
2822        d.as_ptr(),
2823        e.as_ptr(),
2824        &anorm,
2825        rcond,
2826        work.as_mut_ptr(),
2827        info,
2828    )
2829}
2830
2831#[inline]
2832pub unsafe fn dptcon(
2833    n: i32,
2834    d: &[f64],
2835    e: &[f64],
2836    anorm: f64,
2837    rcond: &mut f64,
2838    work: &mut [f64],
2839    info: &mut i32,
2840) {
2841    ffi::dptcon_(
2842        &n,
2843        d.as_ptr(),
2844        e.as_ptr(),
2845        &anorm,
2846        rcond,
2847        work.as_mut_ptr(),
2848        info,
2849    )
2850}
2851
2852#[inline]
2853pub unsafe fn cptcon(
2854    n: i32,
2855    d: &[f32],
2856    e: &[c32],
2857    anorm: f32,
2858    rcond: &mut f32,
2859    work: &mut [f32],
2860    info: &mut i32,
2861) {
2862    ffi::cptcon_(
2863        &n,
2864        d.as_ptr(),
2865        e.as_ptr() as *const _,
2866        &anorm,
2867        rcond,
2868        work.as_mut_ptr(),
2869        info,
2870    )
2871}
2872
2873#[inline]
2874pub unsafe fn zptcon(
2875    n: i32,
2876    d: &[f64],
2877    e: &[c64],
2878    anorm: f64,
2879    rcond: &mut f64,
2880    work: &mut [f64],
2881    info: &mut i32,
2882) {
2883    ffi::zptcon_(
2884        &n,
2885        d.as_ptr(),
2886        e.as_ptr() as *const _,
2887        &anorm,
2888        rcond,
2889        work.as_mut_ptr(),
2890        info,
2891    )
2892}
2893
2894#[inline]
2895pub unsafe fn ssycon(
2896    uplo: u8,
2897    n: i32,
2898    a: &[f32],
2899    lda: i32,
2900    ipiv: &[i32],
2901    anorm: f32,
2902    rcond: &mut f32,
2903    work: &mut [f32],
2904    iwork: &mut [i32],
2905    info: &mut i32,
2906) {
2907    ffi::ssycon_(
2908        &(uplo as c_char),
2909        &n,
2910        a.as_ptr(),
2911        &lda,
2912        ipiv.as_ptr(),
2913        &anorm,
2914        rcond,
2915        work.as_mut_ptr(),
2916        iwork.as_mut_ptr(),
2917        info,
2918    )
2919}
2920
2921#[inline]
2922pub unsafe fn dsycon(
2923    uplo: u8,
2924    n: i32,
2925    a: &[f64],
2926    lda: i32,
2927    ipiv: &[i32],
2928    anorm: f64,
2929    rcond: &mut f64,
2930    work: &mut [f64],
2931    iwork: &mut [i32],
2932    info: &mut i32,
2933) {
2934    ffi::dsycon_(
2935        &(uplo as c_char),
2936        &n,
2937        a.as_ptr(),
2938        &lda,
2939        ipiv.as_ptr(),
2940        &anorm,
2941        rcond,
2942        work.as_mut_ptr(),
2943        iwork.as_mut_ptr(),
2944        info,
2945    )
2946}
2947
2948#[inline]
2949pub unsafe fn csycon(
2950    uplo: u8,
2951    n: i32,
2952    a: &[c32],
2953    lda: i32,
2954    ipiv: &[i32],
2955    anorm: f32,
2956    rcond: &mut f32,
2957    work: &mut [c32],
2958    info: &mut i32,
2959) {
2960    ffi::csycon_(
2961        &(uplo as c_char),
2962        &n,
2963        a.as_ptr() as *const _,
2964        &lda,
2965        ipiv.as_ptr(),
2966        &anorm,
2967        rcond,
2968        work.as_mut_ptr() as *mut _,
2969        info,
2970    )
2971}
2972
2973#[inline]
2974pub unsafe fn zsycon(
2975    uplo: u8,
2976    n: i32,
2977    a: &[c64],
2978    lda: i32,
2979    ipiv: &[i32],
2980    anorm: f64,
2981    rcond: &mut f64,
2982    work: &mut [c64],
2983    info: &mut i32,
2984) {
2985    ffi::zsycon_(
2986        &(uplo as c_char),
2987        &n,
2988        a.as_ptr() as *const _,
2989        &lda,
2990        ipiv.as_ptr(),
2991        &anorm,
2992        rcond,
2993        work.as_mut_ptr() as *mut _,
2994        info,
2995    )
2996}
2997
2998#[inline]
2999pub unsafe fn checon(
3000    uplo: u8,
3001    n: i32,
3002    a: &[c32],
3003    lda: i32,
3004    ipiv: &[i32],
3005    anorm: f32,
3006    rcond: &mut f32,
3007    work: &mut [c32],
3008    info: &mut i32,
3009) {
3010    ffi::checon_(
3011        &(uplo as c_char),
3012        &n,
3013        a.as_ptr() as *const _,
3014        &lda,
3015        ipiv.as_ptr(),
3016        &anorm,
3017        rcond,
3018        work.as_mut_ptr() as *mut _,
3019        info,
3020    )
3021}
3022
3023#[inline]
3024pub unsafe fn zhecon(
3025    uplo: u8,
3026    n: i32,
3027    a: &[c64],
3028    lda: i32,
3029    ipiv: &[i32],
3030    anorm: f64,
3031    rcond: &mut f64,
3032    work: &mut [c64],
3033    info: &mut i32,
3034) {
3035    ffi::zhecon_(
3036        &(uplo as c_char),
3037        &n,
3038        a.as_ptr() as *const _,
3039        &lda,
3040        ipiv.as_ptr(),
3041        &anorm,
3042        rcond,
3043        work.as_mut_ptr() as *mut _,
3044        info,
3045    )
3046}
3047
3048#[inline]
3049pub unsafe fn sspcon(
3050    uplo: u8,
3051    n: i32,
3052    ap: &[f32],
3053    ipiv: &[i32],
3054    anorm: f32,
3055    rcond: &mut f32,
3056    work: &mut [f32],
3057    iwork: &mut [i32],
3058    info: &mut i32,
3059) {
3060    ffi::sspcon_(
3061        &(uplo as c_char),
3062        &n,
3063        ap.as_ptr(),
3064        ipiv.as_ptr(),
3065        &anorm,
3066        rcond,
3067        work.as_mut_ptr(),
3068        iwork.as_mut_ptr(),
3069        info,
3070    )
3071}
3072
3073#[inline]
3074pub unsafe fn dspcon(
3075    uplo: u8,
3076    n: i32,
3077    ap: &[f64],
3078    ipiv: &[i32],
3079    anorm: f64,
3080    rcond: &mut f64,
3081    work: &mut [f64],
3082    iwork: &mut [i32],
3083    info: &mut i32,
3084) {
3085    ffi::dspcon_(
3086        &(uplo as c_char),
3087        &n,
3088        ap.as_ptr(),
3089        ipiv.as_ptr(),
3090        &anorm,
3091        rcond,
3092        work.as_mut_ptr(),
3093        iwork.as_mut_ptr(),
3094        info,
3095    )
3096}
3097
3098#[inline]
3099pub unsafe fn cspcon(
3100    uplo: u8,
3101    n: i32,
3102    ap: &[c32],
3103    ipiv: &[i32],
3104    anorm: f32,
3105    rcond: &mut f32,
3106    work: &mut [c32],
3107    info: &mut i32,
3108) {
3109    ffi::cspcon_(
3110        &(uplo as c_char),
3111        &n,
3112        ap.as_ptr() as *const _,
3113        ipiv.as_ptr(),
3114        &anorm,
3115        rcond,
3116        work.as_mut_ptr() as *mut _,
3117        info,
3118    )
3119}
3120
3121#[inline]
3122pub unsafe fn zspcon(
3123    uplo: u8,
3124    n: i32,
3125    ap: &[c64],
3126    ipiv: &[i32],
3127    anorm: f64,
3128    rcond: &mut f64,
3129    work: &mut [c64],
3130    info: &mut i32,
3131) {
3132    ffi::zspcon_(
3133        &(uplo as c_char),
3134        &n,
3135        ap.as_ptr() as *const _,
3136        ipiv.as_ptr(),
3137        &anorm,
3138        rcond,
3139        work.as_mut_ptr() as *mut _,
3140        info,
3141    )
3142}
3143
3144#[inline]
3145pub unsafe fn chpcon(
3146    uplo: u8,
3147    n: i32,
3148    ap: &[c32],
3149    ipiv: &[i32],
3150    anorm: f32,
3151    rcond: &mut f32,
3152    work: &mut [c32],
3153    info: &mut i32,
3154) {
3155    ffi::chpcon_(
3156        &(uplo as c_char),
3157        &n,
3158        ap.as_ptr() as *const _,
3159        ipiv.as_ptr(),
3160        &anorm,
3161        rcond,
3162        work.as_mut_ptr() as *mut _,
3163        info,
3164    )
3165}
3166
3167#[inline]
3168pub unsafe fn zhpcon(
3169    uplo: u8,
3170    n: i32,
3171    ap: &[c64],
3172    ipiv: &[i32],
3173    anorm: f64,
3174    rcond: &mut f64,
3175    work: &mut [c64],
3176    info: &mut i32,
3177) {
3178    ffi::zhpcon_(
3179        &(uplo as c_char),
3180        &n,
3181        ap.as_ptr() as *const _,
3182        ipiv.as_ptr(),
3183        &anorm,
3184        rcond,
3185        work.as_mut_ptr() as *mut _,
3186        info,
3187    )
3188}
3189
3190#[inline]
3191pub unsafe fn strcon(
3192    norm: u8,
3193    uplo: u8,
3194    diag: u8,
3195    n: i32,
3196    a: &[f32],
3197    lda: i32,
3198    rcond: &mut f32,
3199    work: &mut [f32],
3200    iwork: &mut [i32],
3201    info: &mut i32,
3202) {
3203    ffi::strcon_(
3204        &(norm as c_char),
3205        &(uplo as c_char),
3206        &(diag as c_char),
3207        &n,
3208        a.as_ptr(),
3209        &lda,
3210        rcond,
3211        work.as_mut_ptr(),
3212        iwork.as_mut_ptr(),
3213        info,
3214    )
3215}
3216
3217#[inline]
3218pub unsafe fn dtrcon(
3219    norm: u8,
3220    uplo: u8,
3221    diag: u8,
3222    n: i32,
3223    a: &[f64],
3224    lda: i32,
3225    rcond: &mut f64,
3226    work: &mut [f64],
3227    iwork: &mut [i32],
3228    info: &mut i32,
3229) {
3230    ffi::dtrcon_(
3231        &(norm as c_char),
3232        &(uplo as c_char),
3233        &(diag as c_char),
3234        &n,
3235        a.as_ptr(),
3236        &lda,
3237        rcond,
3238        work.as_mut_ptr(),
3239        iwork.as_mut_ptr(),
3240        info,
3241    )
3242}
3243
3244#[inline]
3245pub unsafe fn ctrcon(
3246    norm: u8,
3247    uplo: u8,
3248    diag: u8,
3249    n: i32,
3250    a: &[c32],
3251    lda: i32,
3252    rcond: &mut f32,
3253    work: &mut [c32],
3254    rwork: &mut [f32],
3255    info: &mut i32,
3256) {
3257    ffi::ctrcon_(
3258        &(norm as c_char),
3259        &(uplo as c_char),
3260        &(diag as c_char),
3261        &n,
3262        a.as_ptr() as *const _,
3263        &lda,
3264        rcond,
3265        work.as_mut_ptr() as *mut _,
3266        rwork.as_mut_ptr(),
3267        info,
3268    )
3269}
3270
3271#[inline]
3272pub unsafe fn ztrcon(
3273    norm: u8,
3274    uplo: u8,
3275    diag: u8,
3276    n: i32,
3277    a: &[c64],
3278    lda: i32,
3279    rcond: &mut f64,
3280    work: &mut [c64],
3281    rwork: &mut [f64],
3282    info: &mut i32,
3283) {
3284    ffi::ztrcon_(
3285        &(norm as c_char),
3286        &(uplo as c_char),
3287        &(diag as c_char),
3288        &n,
3289        a.as_ptr() as *const _,
3290        &lda,
3291        rcond,
3292        work.as_mut_ptr() as *mut _,
3293        rwork.as_mut_ptr(),
3294        info,
3295    )
3296}
3297
3298#[inline]
3299pub unsafe fn stpcon(
3300    norm: u8,
3301    uplo: u8,
3302    diag: u8,
3303    n: i32,
3304    ap: &[f32],
3305    rcond: &mut f32,
3306    work: &mut [f32],
3307    iwork: &mut [i32],
3308    info: &mut i32,
3309) {
3310    ffi::stpcon_(
3311        &(norm as c_char),
3312        &(uplo as c_char),
3313        &(diag as c_char),
3314        &n,
3315        ap.as_ptr(),
3316        rcond,
3317        work.as_mut_ptr(),
3318        iwork.as_mut_ptr(),
3319        info,
3320    )
3321}
3322
3323#[inline]
3324pub unsafe fn dtpcon(
3325    norm: u8,
3326    uplo: u8,
3327    diag: u8,
3328    n: i32,
3329    ap: &[f64],
3330    rcond: &mut f64,
3331    work: &mut [f64],
3332    iwork: &mut [i32],
3333    info: &mut i32,
3334) {
3335    ffi::dtpcon_(
3336        &(norm as c_char),
3337        &(uplo as c_char),
3338        &(diag as c_char),
3339        &n,
3340        ap.as_ptr(),
3341        rcond,
3342        work.as_mut_ptr(),
3343        iwork.as_mut_ptr(),
3344        info,
3345    )
3346}
3347
3348#[inline]
3349pub unsafe fn ctpcon(
3350    norm: u8,
3351    uplo: u8,
3352    diag: u8,
3353    n: i32,
3354    ap: &[c32],
3355    rcond: &mut f32,
3356    work: &mut [c32],
3357    rwork: &mut [f32],
3358    info: &mut i32,
3359) {
3360    ffi::ctpcon_(
3361        &(norm as c_char),
3362        &(uplo as c_char),
3363        &(diag as c_char),
3364        &n,
3365        ap.as_ptr() as *const _,
3366        rcond,
3367        work.as_mut_ptr() as *mut _,
3368        rwork.as_mut_ptr(),
3369        info,
3370    )
3371}
3372
3373#[inline]
3374pub unsafe fn ztpcon(
3375    norm: u8,
3376    uplo: u8,
3377    diag: u8,
3378    n: i32,
3379    ap: &[c64],
3380    rcond: &mut f64,
3381    work: &mut [c64],
3382    rwork: &mut [f64],
3383    info: &mut i32,
3384) {
3385    ffi::ztpcon_(
3386        &(norm as c_char),
3387        &(uplo as c_char),
3388        &(diag as c_char),
3389        &n,
3390        ap.as_ptr() as *const _,
3391        rcond,
3392        work.as_mut_ptr() as *mut _,
3393        rwork.as_mut_ptr(),
3394        info,
3395    )
3396}
3397
3398#[inline]
3399pub unsafe fn stbcon(
3400    norm: u8,
3401    uplo: u8,
3402    diag: u8,
3403    n: i32,
3404    kd: i32,
3405    ab: &[f32],
3406    ldab: i32,
3407    rcond: &mut f32,
3408    work: &mut [f32],
3409    iwork: &mut [i32],
3410    info: &mut i32,
3411) {
3412    ffi::stbcon_(
3413        &(norm as c_char),
3414        &(uplo as c_char),
3415        &(diag as c_char),
3416        &n,
3417        &kd,
3418        ab.as_ptr(),
3419        &ldab,
3420        rcond,
3421        work.as_mut_ptr(),
3422        iwork.as_mut_ptr(),
3423        info,
3424    )
3425}
3426
3427#[inline]
3428pub unsafe fn dtbcon(
3429    norm: u8,
3430    uplo: u8,
3431    diag: u8,
3432    n: i32,
3433    kd: i32,
3434    ab: &[f64],
3435    ldab: i32,
3436    rcond: &mut f64,
3437    work: &mut [f64],
3438    iwork: &mut [i32],
3439    info: &mut i32,
3440) {
3441    ffi::dtbcon_(
3442        &(norm as c_char),
3443        &(uplo as c_char),
3444        &(diag as c_char),
3445        &n,
3446        &kd,
3447        ab.as_ptr(),
3448        &ldab,
3449        rcond,
3450        work.as_mut_ptr(),
3451        iwork.as_mut_ptr(),
3452        info,
3453    )
3454}
3455
3456#[inline]
3457pub unsafe fn ctbcon(
3458    norm: u8,
3459    uplo: u8,
3460    diag: u8,
3461    n: i32,
3462    kd: i32,
3463    ab: &[c32],
3464    ldab: i32,
3465    rcond: &mut f32,
3466    work: &mut [c32],
3467    rwork: &mut [f32],
3468    info: &mut i32,
3469) {
3470    ffi::ctbcon_(
3471        &(norm as c_char),
3472        &(uplo as c_char),
3473        &(diag as c_char),
3474        &n,
3475        &kd,
3476        ab.as_ptr() as *const _,
3477        &ldab,
3478        rcond,
3479        work.as_mut_ptr() as *mut _,
3480        rwork.as_mut_ptr(),
3481        info,
3482    )
3483}
3484
3485#[inline]
3486pub unsafe fn ztbcon(
3487    norm: u8,
3488    uplo: u8,
3489    diag: u8,
3490    n: i32,
3491    kd: i32,
3492    ab: &[c64],
3493    ldab: i32,
3494    rcond: &mut f64,
3495    work: &mut [c64],
3496    rwork: &mut [f64],
3497    info: &mut i32,
3498) {
3499    ffi::ztbcon_(
3500        &(norm as c_char),
3501        &(uplo as c_char),
3502        &(diag as c_char),
3503        &n,
3504        &kd,
3505        ab.as_ptr() as *const _,
3506        &ldab,
3507        rcond,
3508        work.as_mut_ptr() as *mut _,
3509        rwork.as_mut_ptr(),
3510        info,
3511    )
3512}
3513
3514#[inline]
3515pub unsafe fn sgerfs(
3516    trans: u8,
3517    n: i32,
3518    nrhs: i32,
3519    a: &[f32],
3520    lda: i32,
3521    af: &[f32],
3522    ldaf: i32,
3523    ipiv: &[i32],
3524    b: &[f32],
3525    ldb: i32,
3526    x: &mut [f32],
3527    ldx: i32,
3528    ferr: &mut [f32],
3529    berr: &mut [f32],
3530    work: &mut [f32],
3531    iwork: &mut [i32],
3532    info: &mut i32,
3533) {
3534    ffi::sgerfs_(
3535        &(trans as c_char),
3536        &n,
3537        &nrhs,
3538        a.as_ptr(),
3539        &lda,
3540        af.as_ptr(),
3541        &ldaf,
3542        ipiv.as_ptr(),
3543        b.as_ptr(),
3544        &ldb,
3545        x.as_mut_ptr(),
3546        &ldx,
3547        ferr.as_mut_ptr(),
3548        berr.as_mut_ptr(),
3549        work.as_mut_ptr(),
3550        iwork.as_mut_ptr(),
3551        info,
3552    )
3553}
3554
3555#[inline]
3556pub unsafe fn dgerfs(
3557    trans: u8,
3558    n: i32,
3559    nrhs: i32,
3560    a: &[f64],
3561    lda: i32,
3562    af: &[f64],
3563    ldaf: i32,
3564    ipiv: &[i32],
3565    b: &[f64],
3566    ldb: i32,
3567    x: &mut [f64],
3568    ldx: i32,
3569    ferr: &mut [f64],
3570    berr: &mut [f64],
3571    work: &mut [f64],
3572    iwork: &mut [i32],
3573    info: &mut i32,
3574) {
3575    ffi::dgerfs_(
3576        &(trans as c_char),
3577        &n,
3578        &nrhs,
3579        a.as_ptr(),
3580        &lda,
3581        af.as_ptr(),
3582        &ldaf,
3583        ipiv.as_ptr(),
3584        b.as_ptr(),
3585        &ldb,
3586        x.as_mut_ptr(),
3587        &ldx,
3588        ferr.as_mut_ptr(),
3589        berr.as_mut_ptr(),
3590        work.as_mut_ptr(),
3591        iwork.as_mut_ptr(),
3592        info,
3593    )
3594}
3595
3596#[inline]
3597pub unsafe fn cgerfs(
3598    trans: u8,
3599    n: i32,
3600    nrhs: i32,
3601    a: &[c32],
3602    lda: i32,
3603    af: &[c32],
3604    ldaf: i32,
3605    ipiv: &[i32],
3606    b: &[c32],
3607    ldb: i32,
3608    x: &mut [c32],
3609    ldx: i32,
3610    ferr: &mut [f32],
3611    berr: &mut [f32],
3612    work: &mut [c32],
3613    rwork: &mut [f32],
3614    info: &mut i32,
3615) {
3616    ffi::cgerfs_(
3617        &(trans as c_char),
3618        &n,
3619        &nrhs,
3620        a.as_ptr() as *const _,
3621        &lda,
3622        af.as_ptr() as *const _,
3623        &ldaf,
3624        ipiv.as_ptr(),
3625        b.as_ptr() as *const _,
3626        &ldb,
3627        x.as_mut_ptr() as *mut _,
3628        &ldx,
3629        ferr.as_mut_ptr(),
3630        berr.as_mut_ptr(),
3631        work.as_mut_ptr() as *mut _,
3632        rwork.as_mut_ptr(),
3633        info,
3634    )
3635}
3636
3637#[inline]
3638pub unsafe fn zgerfs(
3639    trans: u8,
3640    n: i32,
3641    nrhs: i32,
3642    a: &[c64],
3643    lda: i32,
3644    af: &[c64],
3645    ldaf: i32,
3646    ipiv: &[i32],
3647    b: &[c64],
3648    ldb: i32,
3649    x: &mut [c64],
3650    ldx: i32,
3651    ferr: &mut [f64],
3652    berr: &mut [f64],
3653    work: &mut [c64],
3654    rwork: &mut [f64],
3655    info: &mut i32,
3656) {
3657    ffi::zgerfs_(
3658        &(trans as c_char),
3659        &n,
3660        &nrhs,
3661        a.as_ptr() as *const _,
3662        &lda,
3663        af.as_ptr() as *const _,
3664        &ldaf,
3665        ipiv.as_ptr(),
3666        b.as_ptr() as *const _,
3667        &ldb,
3668        x.as_mut_ptr() as *mut _,
3669        &ldx,
3670        ferr.as_mut_ptr(),
3671        berr.as_mut_ptr(),
3672        work.as_mut_ptr() as *mut _,
3673        rwork.as_mut_ptr(),
3674        info,
3675    )
3676}
3677
3678#[inline]
3679pub unsafe fn dgerfsx(
3680    trans: u8,
3681    equed: u8,
3682    n: i32,
3683    nrhs: i32,
3684    a: &[f64],
3685    lda: i32,
3686    af: &[f64],
3687    ldaf: i32,
3688    ipiv: &[i32],
3689    r: &[f64],
3690    c: &[f64],
3691    b: &[f64],
3692    ldb: i32,
3693    x: &mut [f64],
3694    ldx: i32,
3695    rcond: &mut f64,
3696    berr: &mut [f64],
3697    n_err_bnds: i32,
3698    err_bnds_norm: &mut [f64],
3699    err_bnds_comp: &mut [f64],
3700    nparams: &[i32],
3701    params: &mut [f64],
3702    work: &mut [f64],
3703    iwork: &mut [i32],
3704    info: &mut i32,
3705) {
3706    ffi::dgerfsx_(
3707        &(trans as c_char),
3708        &(equed as c_char),
3709        &n,
3710        &nrhs,
3711        a.as_ptr(),
3712        &lda,
3713        af.as_ptr(),
3714        &ldaf,
3715        ipiv.as_ptr(),
3716        r.as_ptr(),
3717        c.as_ptr(),
3718        b.as_ptr(),
3719        &ldb,
3720        x.as_mut_ptr(),
3721        &ldx,
3722        rcond,
3723        berr.as_mut_ptr(),
3724        &n_err_bnds,
3725        err_bnds_norm.as_mut_ptr(),
3726        err_bnds_comp.as_mut_ptr(),
3727        nparams.as_ptr(),
3728        params.as_mut_ptr(),
3729        work.as_mut_ptr(),
3730        iwork.as_mut_ptr(),
3731        info,
3732    )
3733}
3734
3735#[inline]
3736pub unsafe fn sgerfsx(
3737    trans: u8,
3738    equed: u8,
3739    n: i32,
3740    nrhs: i32,
3741    a: &[f32],
3742    lda: i32,
3743    af: &[f32],
3744    ldaf: i32,
3745    ipiv: &[i32],
3746    r: &[f32],
3747    c: &[f32],
3748    b: &[f32],
3749    ldb: i32,
3750    x: &mut [f32],
3751    ldx: i32,
3752    rcond: &mut f32,
3753    berr: &mut [f32],
3754    n_err_bnds: i32,
3755    err_bnds_norm: &mut [f32],
3756    err_bnds_comp: &mut [f32],
3757    nparams: &[i32],
3758    params: &mut [f32],
3759    work: &mut [f32],
3760    iwork: &mut [i32],
3761    info: &mut i32,
3762) {
3763    ffi::sgerfsx_(
3764        &(trans as c_char),
3765        &(equed as c_char),
3766        &n,
3767        &nrhs,
3768        a.as_ptr(),
3769        &lda,
3770        af.as_ptr(),
3771        &ldaf,
3772        ipiv.as_ptr(),
3773        r.as_ptr(),
3774        c.as_ptr(),
3775        b.as_ptr(),
3776        &ldb,
3777        x.as_mut_ptr(),
3778        &ldx,
3779        rcond,
3780        berr.as_mut_ptr(),
3781        &n_err_bnds,
3782        err_bnds_norm.as_mut_ptr(),
3783        err_bnds_comp.as_mut_ptr(),
3784        nparams.as_ptr(),
3785        params.as_mut_ptr(),
3786        work.as_mut_ptr(),
3787        iwork.as_mut_ptr(),
3788        info,
3789    )
3790}
3791
3792#[inline]
3793pub unsafe fn zgerfsx(
3794    trans: u8,
3795    equed: u8,
3796    n: i32,
3797    nrhs: i32,
3798    a: &[c64],
3799    lda: i32,
3800    af: &[c64],
3801    ldaf: i32,
3802    ipiv: &[i32],
3803    r: &[f64],
3804    c: &[f64],
3805    b: &[c64],
3806    ldb: i32,
3807    x: &mut [c64],
3808    ldx: i32,
3809    rcond: &mut f64,
3810    berr: &mut [f64],
3811    n_err_bnds: i32,
3812    err_bnds_norm: &mut [f64],
3813    err_bnds_comp: &mut [f64],
3814    nparams: &[i32],
3815    params: &mut [f64],
3816    work: &mut [c64],
3817    rwork: &mut [f64],
3818    info: &mut i32,
3819) {
3820    ffi::zgerfsx_(
3821        &(trans as c_char),
3822        &(equed as c_char),
3823        &n,
3824        &nrhs,
3825        a.as_ptr() as *const _,
3826        &lda,
3827        af.as_ptr() as *const _,
3828        &ldaf,
3829        ipiv.as_ptr(),
3830        r.as_ptr(),
3831        c.as_ptr(),
3832        b.as_ptr() as *const _,
3833        &ldb,
3834        x.as_mut_ptr() as *mut _,
3835        &ldx,
3836        rcond,
3837        berr.as_mut_ptr(),
3838        &n_err_bnds,
3839        err_bnds_norm.as_mut_ptr(),
3840        err_bnds_comp.as_mut_ptr(),
3841        nparams.as_ptr(),
3842        params.as_mut_ptr(),
3843        work.as_mut_ptr() as *mut _,
3844        rwork.as_mut_ptr(),
3845        info,
3846    )
3847}
3848
3849#[inline]
3850pub unsafe fn cgerfsx(
3851    trans: u8,
3852    equed: u8,
3853    n: i32,
3854    nrhs: i32,
3855    a: &[c32],
3856    lda: i32,
3857    af: &[c32],
3858    ldaf: i32,
3859    ipiv: &[i32],
3860    r: &[f32],
3861    c: &[f32],
3862    b: &[c32],
3863    ldb: i32,
3864    x: &mut [c32],
3865    ldx: i32,
3866    rcond: &mut f32,
3867    berr: &mut [f32],
3868    n_err_bnds: i32,
3869    err_bnds_norm: &mut [f32],
3870    err_bnds_comp: &mut [f32],
3871    nparams: &[i32],
3872    params: &mut [f32],
3873    work: &mut [c32],
3874    rwork: &mut [f32],
3875    info: &mut i32,
3876) {
3877    ffi::cgerfsx_(
3878        &(trans as c_char),
3879        &(equed as c_char),
3880        &n,
3881        &nrhs,
3882        a.as_ptr() as *const _,
3883        &lda,
3884        af.as_ptr() as *const _,
3885        &ldaf,
3886        ipiv.as_ptr(),
3887        r.as_ptr(),
3888        c.as_ptr(),
3889        b.as_ptr() as *const _,
3890        &ldb,
3891        x.as_mut_ptr() as *mut _,
3892        &ldx,
3893        rcond,
3894        berr.as_mut_ptr(),
3895        &n_err_bnds,
3896        err_bnds_norm.as_mut_ptr(),
3897        err_bnds_comp.as_mut_ptr(),
3898        nparams.as_ptr(),
3899        params.as_mut_ptr(),
3900        work.as_mut_ptr() as *mut _,
3901        rwork.as_mut_ptr(),
3902        info,
3903    )
3904}
3905
3906#[inline]
3907pub unsafe fn sgbrfs(
3908    trans: u8,
3909    n: i32,
3910    kl: i32,
3911    ku: i32,
3912    nrhs: i32,
3913    ab: &[f32],
3914    ldab: i32,
3915    afb: &[f32],
3916    ldafb: i32,
3917    ipiv: &[i32],
3918    b: &[f32],
3919    ldb: i32,
3920    x: &mut [f32],
3921    ldx: i32,
3922    ferr: &mut [f32],
3923    berr: &mut [f32],
3924    work: &mut [f32],
3925    iwork: &mut [i32],
3926    info: &mut i32,
3927) {
3928    ffi::sgbrfs_(
3929        &(trans as c_char),
3930        &n,
3931        &kl,
3932        &ku,
3933        &nrhs,
3934        ab.as_ptr(),
3935        &ldab,
3936        afb.as_ptr(),
3937        &ldafb,
3938        ipiv.as_ptr(),
3939        b.as_ptr(),
3940        &ldb,
3941        x.as_mut_ptr(),
3942        &ldx,
3943        ferr.as_mut_ptr(),
3944        berr.as_mut_ptr(),
3945        work.as_mut_ptr(),
3946        iwork.as_mut_ptr(),
3947        info,
3948    )
3949}
3950
3951#[inline]
3952pub unsafe fn dgbrfs(
3953    trans: u8,
3954    n: i32,
3955    kl: i32,
3956    ku: i32,
3957    nrhs: i32,
3958    ab: &[f64],
3959    ldab: i32,
3960    afb: &[f64],
3961    ldafb: i32,
3962    ipiv: &[i32],
3963    b: &[f64],
3964    ldb: i32,
3965    x: &mut [f64],
3966    ldx: i32,
3967    ferr: &mut [f64],
3968    berr: &mut [f64],
3969    work: &mut [f64],
3970    iwork: &mut [i32],
3971    info: &mut i32,
3972) {
3973    ffi::dgbrfs_(
3974        &(trans as c_char),
3975        &n,
3976        &kl,
3977        &ku,
3978        &nrhs,
3979        ab.as_ptr(),
3980        &ldab,
3981        afb.as_ptr(),
3982        &ldafb,
3983        ipiv.as_ptr(),
3984        b.as_ptr(),
3985        &ldb,
3986        x.as_mut_ptr(),
3987        &ldx,
3988        ferr.as_mut_ptr(),
3989        berr.as_mut_ptr(),
3990        work.as_mut_ptr(),
3991        iwork.as_mut_ptr(),
3992        info,
3993    )
3994}
3995
3996#[inline]
3997pub unsafe fn cgbrfs(
3998    trans: u8,
3999    n: i32,
4000    kl: i32,
4001    ku: i32,
4002    nrhs: i32,
4003    ab: &[c32],
4004    ldab: i32,
4005    afb: &[c32],
4006    ldafb: i32,
4007    ipiv: &[i32],
4008    b: &[c32],
4009    ldb: i32,
4010    x: &mut [c32],
4011    ldx: i32,
4012    ferr: &mut [f32],
4013    berr: &mut [f32],
4014    work: &mut [c32],
4015    rwork: &mut [f32],
4016    info: &mut i32,
4017) {
4018    ffi::cgbrfs_(
4019        &(trans as c_char),
4020        &n,
4021        &kl,
4022        &ku,
4023        &nrhs,
4024        ab.as_ptr() as *const _,
4025        &ldab,
4026        afb.as_ptr() as *const _,
4027        &ldafb,
4028        ipiv.as_ptr(),
4029        b.as_ptr() as *const _,
4030        &ldb,
4031        x.as_mut_ptr() as *mut _,
4032        &ldx,
4033        ferr.as_mut_ptr(),
4034        berr.as_mut_ptr(),
4035        work.as_mut_ptr() as *mut _,
4036        rwork.as_mut_ptr(),
4037        info,
4038    )
4039}
4040
4041#[inline]
4042pub unsafe fn zgbrfs(
4043    trans: u8,
4044    n: i32,
4045    kl: i32,
4046    ku: i32,
4047    nrhs: i32,
4048    ab: &[c64],
4049    ldab: i32,
4050    afb: &[c64],
4051    ldafb: i32,
4052    ipiv: &[i32],
4053    b: &[c64],
4054    ldb: i32,
4055    x: &mut [c64],
4056    ldx: i32,
4057    ferr: &mut [f64],
4058    berr: &mut [f64],
4059    work: &mut [c64],
4060    rwork: &mut [f64],
4061    info: &mut i32,
4062) {
4063    ffi::zgbrfs_(
4064        &(trans as c_char),
4065        &n,
4066        &kl,
4067        &ku,
4068        &nrhs,
4069        ab.as_ptr() as *const _,
4070        &ldab,
4071        afb.as_ptr() as *const _,
4072        &ldafb,
4073        ipiv.as_ptr(),
4074        b.as_ptr() as *const _,
4075        &ldb,
4076        x.as_mut_ptr() as *mut _,
4077        &ldx,
4078        ferr.as_mut_ptr(),
4079        berr.as_mut_ptr(),
4080        work.as_mut_ptr() as *mut _,
4081        rwork.as_mut_ptr(),
4082        info,
4083    )
4084}
4085
4086#[inline]
4087pub unsafe fn dgbrfsx(
4088    trans: u8,
4089    equed: u8,
4090    n: i32,
4091    kl: i32,
4092    ku: i32,
4093    nrhs: i32,
4094    ab: &[f64],
4095    ldab: i32,
4096    afb: &[f64],
4097    ldafb: i32,
4098    ipiv: &[i32],
4099    r: &[f64],
4100    c: &[f64],
4101    b: &[f64],
4102    ldb: i32,
4103    x: &mut [f64],
4104    ldx: i32,
4105    rcond: &mut f64,
4106    berr: &mut [f64],
4107    n_err_bnds: i32,
4108    err_bnds_norm: &mut [f64],
4109    err_bnds_comp: &mut [f64],
4110    nparams: &[i32],
4111    params: &mut [f64],
4112    work: &mut [f64],
4113    iwork: &mut [i32],
4114    info: &mut i32,
4115) {
4116    ffi::dgbrfsx_(
4117        &(trans as c_char),
4118        &(equed as c_char),
4119        &n,
4120        &kl,
4121        &ku,
4122        &nrhs,
4123        ab.as_ptr(),
4124        &ldab,
4125        afb.as_ptr(),
4126        &ldafb,
4127        ipiv.as_ptr(),
4128        r.as_ptr(),
4129        c.as_ptr(),
4130        b.as_ptr(),
4131        &ldb,
4132        x.as_mut_ptr(),
4133        &ldx,
4134        rcond,
4135        berr.as_mut_ptr(),
4136        &n_err_bnds,
4137        err_bnds_norm.as_mut_ptr(),
4138        err_bnds_comp.as_mut_ptr(),
4139        nparams.as_ptr(),
4140        params.as_mut_ptr(),
4141        work.as_mut_ptr(),
4142        iwork.as_mut_ptr(),
4143        info,
4144    )
4145}
4146
4147#[inline]
4148pub unsafe fn sgbrfsx(
4149    trans: u8,
4150    equed: u8,
4151    n: i32,
4152    kl: i32,
4153    ku: i32,
4154    nrhs: i32,
4155    ab: &[f32],
4156    ldab: i32,
4157    afb: &[f32],
4158    ldafb: i32,
4159    ipiv: &[i32],
4160    r: &[f32],
4161    c: &[f32],
4162    b: &[f32],
4163    ldb: i32,
4164    x: &mut [f32],
4165    ldx: i32,
4166    rcond: &mut f32,
4167    berr: &mut [f32],
4168    n_err_bnds: i32,
4169    err_bnds_norm: &mut [f32],
4170    err_bnds_comp: &mut [f32],
4171    nparams: &[i32],
4172    params: &mut [f32],
4173    work: &mut [f32],
4174    iwork: &mut [i32],
4175    info: &mut i32,
4176) {
4177    ffi::sgbrfsx_(
4178        &(trans as c_char),
4179        &(equed as c_char),
4180        &n,
4181        &kl,
4182        &ku,
4183        &nrhs,
4184        ab.as_ptr(),
4185        &ldab,
4186        afb.as_ptr(),
4187        &ldafb,
4188        ipiv.as_ptr(),
4189        r.as_ptr(),
4190        c.as_ptr(),
4191        b.as_ptr(),
4192        &ldb,
4193        x.as_mut_ptr(),
4194        &ldx,
4195        rcond,
4196        berr.as_mut_ptr(),
4197        &n_err_bnds,
4198        err_bnds_norm.as_mut_ptr(),
4199        err_bnds_comp.as_mut_ptr(),
4200        nparams.as_ptr(),
4201        params.as_mut_ptr(),
4202        work.as_mut_ptr(),
4203        iwork.as_mut_ptr(),
4204        info,
4205    )
4206}
4207
4208#[inline]
4209pub unsafe fn zgbrfsx(
4210    trans: u8,
4211    equed: u8,
4212    n: i32,
4213    kl: i32,
4214    ku: i32,
4215    nrhs: i32,
4216    ab: &[c64],
4217    ldab: i32,
4218    afb: &[c64],
4219    ldafb: i32,
4220    ipiv: &[i32],
4221    r: &[f64],
4222    c: &[f64],
4223    b: &[c64],
4224    ldb: i32,
4225    x: &mut [c64],
4226    ldx: i32,
4227    rcond: &mut f64,
4228    berr: &mut [f64],
4229    n_err_bnds: i32,
4230    err_bnds_norm: &mut [f64],
4231    err_bnds_comp: &mut [f64],
4232    nparams: &[i32],
4233    params: &mut [f64],
4234    work: &mut [c64],
4235    rwork: &mut [f64],
4236    info: &mut i32,
4237) {
4238    ffi::zgbrfsx_(
4239        &(trans as c_char),
4240        &(equed as c_char),
4241        &n,
4242        &kl,
4243        &ku,
4244        &nrhs,
4245        ab.as_ptr() as *const _,
4246        &ldab,
4247        afb.as_ptr() as *const _,
4248        &ldafb,
4249        ipiv.as_ptr(),
4250        r.as_ptr(),
4251        c.as_ptr(),
4252        b.as_ptr() as *const _,
4253        &ldb,
4254        x.as_mut_ptr() as *mut _,
4255        &ldx,
4256        rcond,
4257        berr.as_mut_ptr(),
4258        &n_err_bnds,
4259        err_bnds_norm.as_mut_ptr(),
4260        err_bnds_comp.as_mut_ptr(),
4261        nparams.as_ptr(),
4262        params.as_mut_ptr(),
4263        work.as_mut_ptr() as *mut _,
4264        rwork.as_mut_ptr(),
4265        info,
4266    )
4267}
4268
4269#[inline]
4270pub unsafe fn cgbrfsx(
4271    trans: u8,
4272    equed: u8,
4273    n: i32,
4274    kl: i32,
4275    ku: i32,
4276    nrhs: i32,
4277    ab: &[c32],
4278    ldab: i32,
4279    afb: &[c32],
4280    ldafb: i32,
4281    ipiv: &[i32],
4282    r: &[f32],
4283    c: &[f32],
4284    b: &[c32],
4285    ldb: i32,
4286    x: &mut [c32],
4287    ldx: i32,
4288    rcond: &mut f32,
4289    berr: &mut [f32],
4290    n_err_bnds: i32,
4291    err_bnds_norm: &mut [f32],
4292    err_bnds_comp: &mut [f32],
4293    nparams: &[i32],
4294    params: &mut [f32],
4295    work: &mut [c32],
4296    rwork: &mut [f32],
4297    info: &mut i32,
4298) {
4299    ffi::cgbrfsx_(
4300        &(trans as c_char),
4301        &(equed as c_char),
4302        &n,
4303        &kl,
4304        &ku,
4305        &nrhs,
4306        ab.as_ptr() as *const _,
4307        &ldab,
4308        afb.as_ptr() as *const _,
4309        &ldafb,
4310        ipiv.as_ptr(),
4311        r.as_ptr(),
4312        c.as_ptr(),
4313        b.as_ptr() as *const _,
4314        &ldb,
4315        x.as_mut_ptr() as *mut _,
4316        &ldx,
4317        rcond,
4318        berr.as_mut_ptr(),
4319        &n_err_bnds,
4320        err_bnds_norm.as_mut_ptr(),
4321        err_bnds_comp.as_mut_ptr(),
4322        nparams.as_ptr(),
4323        params.as_mut_ptr(),
4324        work.as_mut_ptr() as *mut _,
4325        rwork.as_mut_ptr(),
4326        info,
4327    )
4328}
4329
4330#[inline]
4331pub unsafe fn sgtrfs(
4332    trans: u8,
4333    n: i32,
4334    nrhs: i32,
4335    dl: &[f32],
4336    d: &[f32],
4337    du: &[f32],
4338    dlf: &[f32],
4339    df: &[f32],
4340    duf: &[f32],
4341    du2: &[f32],
4342    ipiv: &[i32],
4343    b: &[f32],
4344    ldb: i32,
4345    x: &mut [f32],
4346    ldx: i32,
4347    ferr: &mut [f32],
4348    berr: &mut [f32],
4349    work: &mut [f32],
4350    iwork: &mut [i32],
4351    info: &mut i32,
4352) {
4353    ffi::sgtrfs_(
4354        &(trans as c_char),
4355        &n,
4356        &nrhs,
4357        dl.as_ptr(),
4358        d.as_ptr(),
4359        du.as_ptr(),
4360        dlf.as_ptr(),
4361        df.as_ptr(),
4362        duf.as_ptr(),
4363        du2.as_ptr(),
4364        ipiv.as_ptr(),
4365        b.as_ptr(),
4366        &ldb,
4367        x.as_mut_ptr(),
4368        &ldx,
4369        ferr.as_mut_ptr(),
4370        berr.as_mut_ptr(),
4371        work.as_mut_ptr(),
4372        iwork.as_mut_ptr(),
4373        info,
4374    )
4375}
4376
4377#[inline]
4378pub unsafe fn dgtrfs(
4379    trans: u8,
4380    n: i32,
4381    nrhs: i32,
4382    dl: &[f64],
4383    d: &[f64],
4384    du: &[f64],
4385    dlf: &[f64],
4386    df: &[f64],
4387    duf: &[f64],
4388    du2: &[f64],
4389    ipiv: &[i32],
4390    b: &[f64],
4391    ldb: i32,
4392    x: &mut [f64],
4393    ldx: i32,
4394    ferr: &mut [f64],
4395    berr: &mut [f64],
4396    work: &mut [f64],
4397    iwork: &mut [i32],
4398    info: &mut i32,
4399) {
4400    ffi::dgtrfs_(
4401        &(trans as c_char),
4402        &n,
4403        &nrhs,
4404        dl.as_ptr(),
4405        d.as_ptr(),
4406        du.as_ptr(),
4407        dlf.as_ptr(),
4408        df.as_ptr(),
4409        duf.as_ptr(),
4410        du2.as_ptr(),
4411        ipiv.as_ptr(),
4412        b.as_ptr(),
4413        &ldb,
4414        x.as_mut_ptr(),
4415        &ldx,
4416        ferr.as_mut_ptr(),
4417        berr.as_mut_ptr(),
4418        work.as_mut_ptr(),
4419        iwork.as_mut_ptr(),
4420        info,
4421    )
4422}
4423
4424#[inline]
4425pub unsafe fn cgtrfs(
4426    trans: u8,
4427    n: i32,
4428    nrhs: i32,
4429    dl: &[c32],
4430    d: &[c32],
4431    du: &[c32],
4432    dlf: &[c32],
4433    df: &[c32],
4434    duf: &[c32],
4435    du2: &[c32],
4436    ipiv: &[i32],
4437    b: &[c32],
4438    ldb: i32,
4439    x: &mut [c32],
4440    ldx: i32,
4441    ferr: &mut [f32],
4442    berr: &mut [f32],
4443    work: &mut [c32],
4444    rwork: &mut [f32],
4445    info: &mut i32,
4446) {
4447    ffi::cgtrfs_(
4448        &(trans as c_char),
4449        &n,
4450        &nrhs,
4451        dl.as_ptr() as *const _,
4452        d.as_ptr() as *const _,
4453        du.as_ptr() as *const _,
4454        dlf.as_ptr() as *const _,
4455        df.as_ptr() as *const _,
4456        duf.as_ptr() as *const _,
4457        du2.as_ptr() as *const _,
4458        ipiv.as_ptr(),
4459        b.as_ptr() as *const _,
4460        &ldb,
4461        x.as_mut_ptr() as *mut _,
4462        &ldx,
4463        ferr.as_mut_ptr(),
4464        berr.as_mut_ptr(),
4465        work.as_mut_ptr() as *mut _,
4466        rwork.as_mut_ptr(),
4467        info,
4468    )
4469}
4470
4471#[inline]
4472pub unsafe fn zgtrfs(
4473    trans: u8,
4474    n: i32,
4475    nrhs: i32,
4476    dl: &[c64],
4477    d: &[c64],
4478    du: &[c64],
4479    dlf: &[c64],
4480    df: &[c64],
4481    duf: &[c64],
4482    du2: &[c64],
4483    ipiv: &[i32],
4484    b: &[c64],
4485    ldb: i32,
4486    x: &mut [c64],
4487    ldx: i32,
4488    ferr: &mut [f64],
4489    berr: &mut [f64],
4490    work: &mut [c64],
4491    rwork: &mut [f64],
4492    info: &mut i32,
4493) {
4494    ffi::zgtrfs_(
4495        &(trans as c_char),
4496        &n,
4497        &nrhs,
4498        dl.as_ptr() as *const _,
4499        d.as_ptr() as *const _,
4500        du.as_ptr() as *const _,
4501        dlf.as_ptr() as *const _,
4502        df.as_ptr() as *const _,
4503        duf.as_ptr() as *const _,
4504        du2.as_ptr() as *const _,
4505        ipiv.as_ptr(),
4506        b.as_ptr() as *const _,
4507        &ldb,
4508        x.as_mut_ptr() as *mut _,
4509        &ldx,
4510        ferr.as_mut_ptr(),
4511        berr.as_mut_ptr(),
4512        work.as_mut_ptr() as *mut _,
4513        rwork.as_mut_ptr(),
4514        info,
4515    )
4516}
4517
4518#[inline]
4519pub unsafe fn sporfs(
4520    uplo: u8,
4521    n: i32,
4522    nrhs: i32,
4523    a: &[f32],
4524    lda: i32,
4525    af: &[f32],
4526    ldaf: i32,
4527    b: &[f32],
4528    ldb: i32,
4529    x: &mut [f32],
4530    ldx: i32,
4531    ferr: &mut [f32],
4532    berr: &mut [f32],
4533    work: &mut [f32],
4534    iwork: &mut [i32],
4535    info: &mut i32,
4536) {
4537    ffi::sporfs_(
4538        &(uplo as c_char),
4539        &n,
4540        &nrhs,
4541        a.as_ptr(),
4542        &lda,
4543        af.as_ptr(),
4544        &ldaf,
4545        b.as_ptr(),
4546        &ldb,
4547        x.as_mut_ptr(),
4548        &ldx,
4549        ferr.as_mut_ptr(),
4550        berr.as_mut_ptr(),
4551        work.as_mut_ptr(),
4552        iwork.as_mut_ptr(),
4553        info,
4554    )
4555}
4556
4557#[inline]
4558pub unsafe fn dporfs(
4559    uplo: u8,
4560    n: i32,
4561    nrhs: i32,
4562    a: &[f64],
4563    lda: i32,
4564    af: &[f64],
4565    ldaf: i32,
4566    b: &[f64],
4567    ldb: i32,
4568    x: &mut [f64],
4569    ldx: i32,
4570    ferr: &mut [f64],
4571    berr: &mut [f64],
4572    work: &mut [f64],
4573    iwork: &mut [i32],
4574    info: &mut i32,
4575) {
4576    ffi::dporfs_(
4577        &(uplo as c_char),
4578        &n,
4579        &nrhs,
4580        a.as_ptr(),
4581        &lda,
4582        af.as_ptr(),
4583        &ldaf,
4584        b.as_ptr(),
4585        &ldb,
4586        x.as_mut_ptr(),
4587        &ldx,
4588        ferr.as_mut_ptr(),
4589        berr.as_mut_ptr(),
4590        work.as_mut_ptr(),
4591        iwork.as_mut_ptr(),
4592        info,
4593    )
4594}
4595
4596#[inline]
4597pub unsafe fn cporfs(
4598    uplo: u8,
4599    n: i32,
4600    nrhs: i32,
4601    a: &[c32],
4602    lda: i32,
4603    af: &[c32],
4604    ldaf: i32,
4605    b: &[c32],
4606    ldb: i32,
4607    x: &mut [c32],
4608    ldx: i32,
4609    ferr: &mut [f32],
4610    berr: &mut [f32],
4611    work: &mut [c32],
4612    rwork: &mut [f32],
4613    info: &mut i32,
4614) {
4615    ffi::cporfs_(
4616        &(uplo as c_char),
4617        &n,
4618        &nrhs,
4619        a.as_ptr() as *const _,
4620        &lda,
4621        af.as_ptr() as *const _,
4622        &ldaf,
4623        b.as_ptr() as *const _,
4624        &ldb,
4625        x.as_mut_ptr() as *mut _,
4626        &ldx,
4627        ferr.as_mut_ptr(),
4628        berr.as_mut_ptr(),
4629        work.as_mut_ptr() as *mut _,
4630        rwork.as_mut_ptr(),
4631        info,
4632    )
4633}
4634
4635#[inline]
4636pub unsafe fn zporfs(
4637    uplo: u8,
4638    n: i32,
4639    nrhs: i32,
4640    a: &[c64],
4641    lda: i32,
4642    af: &[c64],
4643    ldaf: i32,
4644    b: &[c64],
4645    ldb: i32,
4646    x: &mut [c64],
4647    ldx: i32,
4648    ferr: &mut [f64],
4649    berr: &mut [f64],
4650    work: &mut [c64],
4651    rwork: &mut [f64],
4652    info: &mut i32,
4653) {
4654    ffi::zporfs_(
4655        &(uplo as c_char),
4656        &n,
4657        &nrhs,
4658        a.as_ptr() as *const _,
4659        &lda,
4660        af.as_ptr() as *const _,
4661        &ldaf,
4662        b.as_ptr() as *const _,
4663        &ldb,
4664        x.as_mut_ptr() as *mut _,
4665        &ldx,
4666        ferr.as_mut_ptr(),
4667        berr.as_mut_ptr(),
4668        work.as_mut_ptr() as *mut _,
4669        rwork.as_mut_ptr(),
4670        info,
4671    )
4672}
4673
4674#[inline]
4675pub unsafe fn dporfsx(
4676    uplo: u8,
4677    equed: u8,
4678    n: i32,
4679    nrhs: i32,
4680    a: &[f64],
4681    lda: i32,
4682    af: &[f64],
4683    ldaf: i32,
4684    s: &[f64],
4685    b: &[f64],
4686    ldb: i32,
4687    x: &mut [f64],
4688    ldx: i32,
4689    rcond: &mut f64,
4690    berr: &mut [f64],
4691    n_err_bnds: i32,
4692    err_bnds_norm: &mut [f64],
4693    err_bnds_comp: &mut [f64],
4694    nparams: &[i32],
4695    params: &mut [f64],
4696    work: &mut [f64],
4697    iwork: &mut [i32],
4698    info: &mut i32,
4699) {
4700    ffi::dporfsx_(
4701        &(uplo as c_char),
4702        &(equed as c_char),
4703        &n,
4704        &nrhs,
4705        a.as_ptr(),
4706        &lda,
4707        af.as_ptr(),
4708        &ldaf,
4709        s.as_ptr(),
4710        b.as_ptr(),
4711        &ldb,
4712        x.as_mut_ptr(),
4713        &ldx,
4714        rcond,
4715        berr.as_mut_ptr(),
4716        &n_err_bnds,
4717        err_bnds_norm.as_mut_ptr(),
4718        err_bnds_comp.as_mut_ptr(),
4719        nparams.as_ptr(),
4720        params.as_mut_ptr(),
4721        work.as_mut_ptr(),
4722        iwork.as_mut_ptr(),
4723        info,
4724    )
4725}
4726
4727#[inline]
4728pub unsafe fn sporfsx(
4729    uplo: u8,
4730    equed: u8,
4731    n: i32,
4732    nrhs: i32,
4733    a: &[f32],
4734    lda: i32,
4735    af: &[f32],
4736    ldaf: i32,
4737    s: &[f32],
4738    b: &[f32],
4739    ldb: i32,
4740    x: &mut [f32],
4741    ldx: i32,
4742    rcond: &mut f32,
4743    berr: &mut [f32],
4744    n_err_bnds: i32,
4745    err_bnds_norm: &mut [f32],
4746    err_bnds_comp: &mut [f32],
4747    nparams: &[i32],
4748    params: &mut [f32],
4749    work: &mut [f32],
4750    iwork: &mut [i32],
4751    info: &mut i32,
4752) {
4753    ffi::sporfsx_(
4754        &(uplo as c_char),
4755        &(equed as c_char),
4756        &n,
4757        &nrhs,
4758        a.as_ptr(),
4759        &lda,
4760        af.as_ptr(),
4761        &ldaf,
4762        s.as_ptr(),
4763        b.as_ptr(),
4764        &ldb,
4765        x.as_mut_ptr(),
4766        &ldx,
4767        rcond,
4768        berr.as_mut_ptr(),
4769        &n_err_bnds,
4770        err_bnds_norm.as_mut_ptr(),
4771        err_bnds_comp.as_mut_ptr(),
4772        nparams.as_ptr(),
4773        params.as_mut_ptr(),
4774        work.as_mut_ptr(),
4775        iwork.as_mut_ptr(),
4776        info,
4777    )
4778}
4779
4780#[inline]
4781pub unsafe fn zporfsx(
4782    uplo: u8,
4783    equed: u8,
4784    n: i32,
4785    nrhs: i32,
4786    a: &[c64],
4787    lda: i32,
4788    af: &[c64],
4789    ldaf: i32,
4790    s: &[f64],
4791    b: &[c64],
4792    ldb: i32,
4793    x: &mut [c64],
4794    ldx: i32,
4795    rcond: &mut f64,
4796    berr: &mut [f64],
4797    n_err_bnds: i32,
4798    err_bnds_norm: &mut [f64],
4799    err_bnds_comp: &mut [f64],
4800    nparams: &[i32],
4801    params: &mut [f64],
4802    work: &mut [c64],
4803    rwork: &mut [f64],
4804    info: &mut i32,
4805) {
4806    ffi::zporfsx_(
4807        &(uplo as c_char),
4808        &(equed as c_char),
4809        &n,
4810        &nrhs,
4811        a.as_ptr() as *const _,
4812        &lda,
4813        af.as_ptr() as *const _,
4814        &ldaf,
4815        s.as_ptr(),
4816        b.as_ptr() as *const _,
4817        &ldb,
4818        x.as_mut_ptr() as *mut _,
4819        &ldx,
4820        rcond,
4821        berr.as_mut_ptr(),
4822        &n_err_bnds,
4823        err_bnds_norm.as_mut_ptr(),
4824        err_bnds_comp.as_mut_ptr(),
4825        nparams.as_ptr(),
4826        params.as_mut_ptr(),
4827        work.as_mut_ptr() as *mut _,
4828        rwork.as_mut_ptr(),
4829        info,
4830    )
4831}
4832
4833#[inline]
4834pub unsafe fn cporfsx(
4835    uplo: u8,
4836    equed: u8,
4837    n: i32,
4838    nrhs: i32,
4839    a: &[c32],
4840    lda: i32,
4841    af: &[c32],
4842    ldaf: i32,
4843    s: &[f32],
4844    b: &[c32],
4845    ldb: i32,
4846    x: &mut [c32],
4847    ldx: i32,
4848    rcond: &mut f32,
4849    berr: &mut [f32],
4850    n_err_bnds: i32,
4851    err_bnds_norm: &mut [f32],
4852    err_bnds_comp: &mut [f32],
4853    nparams: &[i32],
4854    params: &mut [f32],
4855    work: &mut [c32],
4856    rwork: &mut [f32],
4857    info: &mut i32,
4858) {
4859    ffi::cporfsx_(
4860        &(uplo as c_char),
4861        &(equed as c_char),
4862        &n,
4863        &nrhs,
4864        a.as_ptr() as *const _,
4865        &lda,
4866        af.as_ptr() as *const _,
4867        &ldaf,
4868        s.as_ptr(),
4869        b.as_ptr() as *const _,
4870        &ldb,
4871        x.as_mut_ptr() as *mut _,
4872        &ldx,
4873        rcond,
4874        berr.as_mut_ptr(),
4875        &n_err_bnds,
4876        err_bnds_norm.as_mut_ptr(),
4877        err_bnds_comp.as_mut_ptr(),
4878        nparams.as_ptr(),
4879        params.as_mut_ptr(),
4880        work.as_mut_ptr() as *mut _,
4881        rwork.as_mut_ptr(),
4882        info,
4883    )
4884}
4885
4886#[inline]
4887pub unsafe fn spprfs(
4888    uplo: u8,
4889    n: i32,
4890    nrhs: i32,
4891    ap: &[f32],
4892    afp: &[f32],
4893    b: &[f32],
4894    ldb: i32,
4895    x: &mut [f32],
4896    ldx: i32,
4897    ferr: &mut [f32],
4898    berr: &mut [f32],
4899    work: &mut [f32],
4900    iwork: &mut [i32],
4901    info: &mut i32,
4902) {
4903    ffi::spprfs_(
4904        &(uplo as c_char),
4905        &n,
4906        &nrhs,
4907        ap.as_ptr(),
4908        afp.as_ptr(),
4909        b.as_ptr(),
4910        &ldb,
4911        x.as_mut_ptr(),
4912        &ldx,
4913        ferr.as_mut_ptr(),
4914        berr.as_mut_ptr(),
4915        work.as_mut_ptr(),
4916        iwork.as_mut_ptr(),
4917        info,
4918    )
4919}
4920
4921#[inline]
4922pub unsafe fn dpprfs(
4923    uplo: u8,
4924    n: i32,
4925    nrhs: i32,
4926    ap: &[f64],
4927    afp: &[f64],
4928    b: &[f64],
4929    ldb: i32,
4930    x: &mut [f64],
4931    ldx: i32,
4932    ferr: &mut [f64],
4933    berr: &mut [f64],
4934    work: &mut [f64],
4935    iwork: &mut [i32],
4936    info: &mut i32,
4937) {
4938    ffi::dpprfs_(
4939        &(uplo as c_char),
4940        &n,
4941        &nrhs,
4942        ap.as_ptr(),
4943        afp.as_ptr(),
4944        b.as_ptr(),
4945        &ldb,
4946        x.as_mut_ptr(),
4947        &ldx,
4948        ferr.as_mut_ptr(),
4949        berr.as_mut_ptr(),
4950        work.as_mut_ptr(),
4951        iwork.as_mut_ptr(),
4952        info,
4953    )
4954}
4955
4956#[inline]
4957pub unsafe fn cpprfs(
4958    uplo: u8,
4959    n: i32,
4960    nrhs: i32,
4961    ap: &[c32],
4962    afp: &[c32],
4963    b: &[c32],
4964    ldb: i32,
4965    x: &mut [c32],
4966    ldx: i32,
4967    ferr: &mut [f32],
4968    berr: &mut [f32],
4969    work: &mut [c32],
4970    rwork: &mut [f32],
4971    info: &mut i32,
4972) {
4973    ffi::cpprfs_(
4974        &(uplo as c_char),
4975        &n,
4976        &nrhs,
4977        ap.as_ptr() as *const _,
4978        afp.as_ptr() as *const _,
4979        b.as_ptr() as *const _,
4980        &ldb,
4981        x.as_mut_ptr() as *mut _,
4982        &ldx,
4983        ferr.as_mut_ptr(),
4984        berr.as_mut_ptr(),
4985        work.as_mut_ptr() as *mut _,
4986        rwork.as_mut_ptr(),
4987        info,
4988    )
4989}
4990
4991#[inline]
4992pub unsafe fn zpprfs(
4993    uplo: u8,
4994    n: i32,
4995    nrhs: i32,
4996    ap: &[c64],
4997    afp: &[c64],
4998    b: &[c64],
4999    ldb: i32,
5000    x: &mut [c64],
5001    ldx: i32,
5002    ferr: &mut [f64],
5003    berr: &mut [f64],
5004    work: &mut [c64],
5005    rwork: &mut [f64],
5006    info: &mut i32,
5007) {
5008    ffi::zpprfs_(
5009        &(uplo as c_char),
5010        &n,
5011        &nrhs,
5012        ap.as_ptr() as *const _,
5013        afp.as_ptr() as *const _,
5014        b.as_ptr() as *const _,
5015        &ldb,
5016        x.as_mut_ptr() as *mut _,
5017        &ldx,
5018        ferr.as_mut_ptr(),
5019        berr.as_mut_ptr(),
5020        work.as_mut_ptr() as *mut _,
5021        rwork.as_mut_ptr(),
5022        info,
5023    )
5024}
5025
5026#[inline]
5027pub unsafe fn spbrfs(
5028    uplo: u8,
5029    n: i32,
5030    kd: i32,
5031    nrhs: i32,
5032    ab: &[f32],
5033    ldab: i32,
5034    afb: &[f32],
5035    ldafb: i32,
5036    b: &[f32],
5037    ldb: i32,
5038    x: &mut [f32],
5039    ldx: i32,
5040    ferr: &mut [f32],
5041    berr: &mut [f32],
5042    work: &mut [f32],
5043    iwork: &mut [i32],
5044    info: &mut i32,
5045) {
5046    ffi::spbrfs_(
5047        &(uplo as c_char),
5048        &n,
5049        &kd,
5050        &nrhs,
5051        ab.as_ptr(),
5052        &ldab,
5053        afb.as_ptr(),
5054        &ldafb,
5055        b.as_ptr(),
5056        &ldb,
5057        x.as_mut_ptr(),
5058        &ldx,
5059        ferr.as_mut_ptr(),
5060        berr.as_mut_ptr(),
5061        work.as_mut_ptr(),
5062        iwork.as_mut_ptr(),
5063        info,
5064    )
5065}
5066
5067#[inline]
5068pub unsafe fn dpbrfs(
5069    uplo: u8,
5070    n: i32,
5071    kd: i32,
5072    nrhs: i32,
5073    ab: &[f64],
5074    ldab: i32,
5075    afb: &[f64],
5076    ldafb: i32,
5077    b: &[f64],
5078    ldb: i32,
5079    x: &mut [f64],
5080    ldx: i32,
5081    ferr: &mut [f64],
5082    berr: &mut [f64],
5083    work: &mut [f64],
5084    iwork: &mut [i32],
5085    info: &mut i32,
5086) {
5087    ffi::dpbrfs_(
5088        &(uplo as c_char),
5089        &n,
5090        &kd,
5091        &nrhs,
5092        ab.as_ptr(),
5093        &ldab,
5094        afb.as_ptr(),
5095        &ldafb,
5096        b.as_ptr(),
5097        &ldb,
5098        x.as_mut_ptr(),
5099        &ldx,
5100        ferr.as_mut_ptr(),
5101        berr.as_mut_ptr(),
5102        work.as_mut_ptr(),
5103        iwork.as_mut_ptr(),
5104        info,
5105    )
5106}
5107
5108#[inline]
5109pub unsafe fn cpbrfs(
5110    uplo: u8,
5111    n: i32,
5112    kd: i32,
5113    nrhs: i32,
5114    ab: &[c32],
5115    ldab: i32,
5116    afb: &[c32],
5117    ldafb: i32,
5118    b: &[c32],
5119    ldb: i32,
5120    x: &mut [c32],
5121    ldx: i32,
5122    ferr: &mut [f32],
5123    berr: &mut [f32],
5124    work: &mut [c32],
5125    rwork: &mut [f32],
5126    info: &mut i32,
5127) {
5128    ffi::cpbrfs_(
5129        &(uplo as c_char),
5130        &n,
5131        &kd,
5132        &nrhs,
5133        ab.as_ptr() as *const _,
5134        &ldab,
5135        afb.as_ptr() as *const _,
5136        &ldafb,
5137        b.as_ptr() as *const _,
5138        &ldb,
5139        x.as_mut_ptr() as *mut _,
5140        &ldx,
5141        ferr.as_mut_ptr(),
5142        berr.as_mut_ptr(),
5143        work.as_mut_ptr() as *mut _,
5144        rwork.as_mut_ptr(),
5145        info,
5146    )
5147}
5148
5149#[inline]
5150pub unsafe fn zpbrfs(
5151    uplo: u8,
5152    n: i32,
5153    kd: i32,
5154    nrhs: i32,
5155    ab: &[c64],
5156    ldab: i32,
5157    afb: &[c64],
5158    ldafb: i32,
5159    b: &[c64],
5160    ldb: i32,
5161    x: &mut [c64],
5162    ldx: i32,
5163    ferr: &mut [f64],
5164    berr: &mut [f64],
5165    work: &mut [c64],
5166    rwork: &mut [f64],
5167    info: &mut i32,
5168) {
5169    ffi::zpbrfs_(
5170        &(uplo as c_char),
5171        &n,
5172        &kd,
5173        &nrhs,
5174        ab.as_ptr() as *const _,
5175        &ldab,
5176        afb.as_ptr() as *const _,
5177        &ldafb,
5178        b.as_ptr() as *const _,
5179        &ldb,
5180        x.as_mut_ptr() as *mut _,
5181        &ldx,
5182        ferr.as_mut_ptr(),
5183        berr.as_mut_ptr(),
5184        work.as_mut_ptr() as *mut _,
5185        rwork.as_mut_ptr(),
5186        info,
5187    )
5188}
5189
5190#[inline]
5191pub unsafe fn sptrfs(
5192    n: i32,
5193    nrhs: i32,
5194    d: &[f32],
5195    e: &[f32],
5196    df: &[f32],
5197    ef: &[f32],
5198    b: &[f32],
5199    ldb: i32,
5200    x: &mut [f32],
5201    ldx: i32,
5202    ferr: &mut [f32],
5203    berr: &mut [f32],
5204    work: &mut [f32],
5205    info: &mut i32,
5206) {
5207    ffi::sptrfs_(
5208        &n,
5209        &nrhs,
5210        d.as_ptr(),
5211        e.as_ptr(),
5212        df.as_ptr(),
5213        ef.as_ptr(),
5214        b.as_ptr(),
5215        &ldb,
5216        x.as_mut_ptr(),
5217        &ldx,
5218        ferr.as_mut_ptr(),
5219        berr.as_mut_ptr(),
5220        work.as_mut_ptr(),
5221        info,
5222    )
5223}
5224
5225#[inline]
5226pub unsafe fn dptrfs(
5227    n: i32,
5228    nrhs: i32,
5229    d: &[f64],
5230    e: &[f64],
5231    df: &[f64],
5232    ef: &[f64],
5233    b: &[f64],
5234    ldb: i32,
5235    x: &mut [f64],
5236    ldx: i32,
5237    ferr: &mut [f64],
5238    berr: &mut [f64],
5239    work: &mut [f64],
5240    info: &mut i32,
5241) {
5242    ffi::dptrfs_(
5243        &n,
5244        &nrhs,
5245        d.as_ptr(),
5246        e.as_ptr(),
5247        df.as_ptr(),
5248        ef.as_ptr(),
5249        b.as_ptr(),
5250        &ldb,
5251        x.as_mut_ptr(),
5252        &ldx,
5253        ferr.as_mut_ptr(),
5254        berr.as_mut_ptr(),
5255        work.as_mut_ptr(),
5256        info,
5257    )
5258}
5259
5260#[inline]
5261pub unsafe fn cptrfs(
5262    uplo: u8,
5263    n: i32,
5264    nrhs: i32,
5265    d: &[f32],
5266    e: &[c32],
5267    df: &[f32],
5268    ef: &[c32],
5269    b: &[c32],
5270    ldb: i32,
5271    x: &mut [c32],
5272    ldx: i32,
5273    ferr: &mut [f32],
5274    berr: &mut [f32],
5275    work: &mut [c32],
5276    rwork: &mut [f32],
5277    info: &mut i32,
5278) {
5279    ffi::cptrfs_(
5280        &(uplo as c_char),
5281        &n,
5282        &nrhs,
5283        d.as_ptr(),
5284        e.as_ptr() as *const _,
5285        df.as_ptr(),
5286        ef.as_ptr() as *const _,
5287        b.as_ptr() as *const _,
5288        &ldb,
5289        x.as_mut_ptr() as *mut _,
5290        &ldx,
5291        ferr.as_mut_ptr(),
5292        berr.as_mut_ptr(),
5293        work.as_mut_ptr() as *mut _,
5294        rwork.as_mut_ptr(),
5295        info,
5296    )
5297}
5298
5299#[inline]
5300pub unsafe fn zptrfs(
5301    uplo: u8,
5302    n: i32,
5303    nrhs: i32,
5304    d: &[f64],
5305    e: &[c64],
5306    df: &[f64],
5307    ef: &[c64],
5308    b: &[c64],
5309    ldb: i32,
5310    x: &mut [c64],
5311    ldx: i32,
5312    ferr: &mut [f64],
5313    berr: &mut [f64],
5314    work: &mut [c64],
5315    rwork: &mut [f64],
5316    info: &mut i32,
5317) {
5318    ffi::zptrfs_(
5319        &(uplo as c_char),
5320        &n,
5321        &nrhs,
5322        d.as_ptr(),
5323        e.as_ptr() as *const _,
5324        df.as_ptr(),
5325        ef.as_ptr() as *const _,
5326        b.as_ptr() as *const _,
5327        &ldb,
5328        x.as_mut_ptr() as *mut _,
5329        &ldx,
5330        ferr.as_mut_ptr(),
5331        berr.as_mut_ptr(),
5332        work.as_mut_ptr() as *mut _,
5333        rwork.as_mut_ptr(),
5334        info,
5335    )
5336}
5337
5338#[inline]
5339pub unsafe fn ssyrfs(
5340    uplo: u8,
5341    n: i32,
5342    nrhs: i32,
5343    a: &[f32],
5344    lda: i32,
5345    af: &[f32],
5346    ldaf: i32,
5347    ipiv: &[i32],
5348    b: &[f32],
5349    ldb: i32,
5350    x: &mut [f32],
5351    ldx: i32,
5352    ferr: &mut [f32],
5353    berr: &mut [f32],
5354    work: &mut [f32],
5355    iwork: &mut [i32],
5356    info: &mut i32,
5357) {
5358    ffi::ssyrfs_(
5359        &(uplo as c_char),
5360        &n,
5361        &nrhs,
5362        a.as_ptr(),
5363        &lda,
5364        af.as_ptr(),
5365        &ldaf,
5366        ipiv.as_ptr(),
5367        b.as_ptr(),
5368        &ldb,
5369        x.as_mut_ptr(),
5370        &ldx,
5371        ferr.as_mut_ptr(),
5372        berr.as_mut_ptr(),
5373        work.as_mut_ptr(),
5374        iwork.as_mut_ptr(),
5375        info,
5376    )
5377}
5378
5379#[inline]
5380pub unsafe fn dsyrfs(
5381    uplo: u8,
5382    n: i32,
5383    nrhs: i32,
5384    a: &[f64],
5385    lda: i32,
5386    af: &[f64],
5387    ldaf: i32,
5388    ipiv: &[i32],
5389    b: &[f64],
5390    ldb: i32,
5391    x: &mut [f64],
5392    ldx: i32,
5393    ferr: &mut [f64],
5394    berr: &mut [f64],
5395    work: &mut [f64],
5396    iwork: &mut [i32],
5397    info: &mut i32,
5398) {
5399    ffi::dsyrfs_(
5400        &(uplo as c_char),
5401        &n,
5402        &nrhs,
5403        a.as_ptr(),
5404        &lda,
5405        af.as_ptr(),
5406        &ldaf,
5407        ipiv.as_ptr(),
5408        b.as_ptr(),
5409        &ldb,
5410        x.as_mut_ptr(),
5411        &ldx,
5412        ferr.as_mut_ptr(),
5413        berr.as_mut_ptr(),
5414        work.as_mut_ptr(),
5415        iwork.as_mut_ptr(),
5416        info,
5417    )
5418}
5419
5420#[inline]
5421pub unsafe fn csyrfs(
5422    uplo: u8,
5423    n: i32,
5424    nrhs: i32,
5425    a: &[c32],
5426    lda: i32,
5427    af: &[c32],
5428    ldaf: i32,
5429    ipiv: &[i32],
5430    b: &[c32],
5431    ldb: i32,
5432    x: &mut [c32],
5433    ldx: i32,
5434    ferr: &mut [f32],
5435    berr: &mut [f32],
5436    work: &mut [c32],
5437    rwork: &mut [f32],
5438    info: &mut i32,
5439) {
5440    ffi::csyrfs_(
5441        &(uplo as c_char),
5442        &n,
5443        &nrhs,
5444        a.as_ptr() as *const _,
5445        &lda,
5446        af.as_ptr() as *const _,
5447        &ldaf,
5448        ipiv.as_ptr(),
5449        b.as_ptr() as *const _,
5450        &ldb,
5451        x.as_mut_ptr() as *mut _,
5452        &ldx,
5453        ferr.as_mut_ptr(),
5454        berr.as_mut_ptr(),
5455        work.as_mut_ptr() as *mut _,
5456        rwork.as_mut_ptr(),
5457        info,
5458    )
5459}
5460
5461#[inline]
5462pub unsafe fn zsyrfs(
5463    uplo: u8,
5464    n: i32,
5465    nrhs: i32,
5466    a: &[c64],
5467    lda: i32,
5468    af: &[c64],
5469    ldaf: i32,
5470    ipiv: &[i32],
5471    b: &[c64],
5472    ldb: i32,
5473    x: &mut [c64],
5474    ldx: i32,
5475    ferr: &mut [f64],
5476    berr: &mut [f64],
5477    work: &mut [c64],
5478    rwork: &mut [f64],
5479    info: &mut i32,
5480) {
5481    ffi::zsyrfs_(
5482        &(uplo as c_char),
5483        &n,
5484        &nrhs,
5485        a.as_ptr() as *const _,
5486        &lda,
5487        af.as_ptr() as *const _,
5488        &ldaf,
5489        ipiv.as_ptr(),
5490        b.as_ptr() as *const _,
5491        &ldb,
5492        x.as_mut_ptr() as *mut _,
5493        &ldx,
5494        ferr.as_mut_ptr(),
5495        berr.as_mut_ptr(),
5496        work.as_mut_ptr() as *mut _,
5497        rwork.as_mut_ptr(),
5498        info,
5499    )
5500}
5501
5502#[inline]
5503pub unsafe fn dsyrfsx(
5504    uplo: u8,
5505    equed: u8,
5506    n: i32,
5507    nrhs: i32,
5508    a: &[f64],
5509    lda: i32,
5510    af: &[f64],
5511    ldaf: i32,
5512    ipiv: &[i32],
5513    s: &[f64],
5514    b: &[f64],
5515    ldb: i32,
5516    x: &mut [f64],
5517    ldx: i32,
5518    rcond: &mut f64,
5519    berr: &mut [f64],
5520    n_err_bnds: i32,
5521    err_bnds_norm: &mut [f64],
5522    err_bnds_comp: &mut [f64],
5523    nparams: &[i32],
5524    params: &mut [f64],
5525    work: &mut [f64],
5526    iwork: &mut [i32],
5527    info: &mut i32,
5528) {
5529    ffi::dsyrfsx_(
5530        &(uplo as c_char),
5531        &(equed as c_char),
5532        &n,
5533        &nrhs,
5534        a.as_ptr(),
5535        &lda,
5536        af.as_ptr(),
5537        &ldaf,
5538        ipiv.as_ptr(),
5539        s.as_ptr(),
5540        b.as_ptr(),
5541        &ldb,
5542        x.as_mut_ptr(),
5543        &ldx,
5544        rcond,
5545        berr.as_mut_ptr(),
5546        &n_err_bnds,
5547        err_bnds_norm.as_mut_ptr(),
5548        err_bnds_comp.as_mut_ptr(),
5549        nparams.as_ptr(),
5550        params.as_mut_ptr(),
5551        work.as_mut_ptr(),
5552        iwork.as_mut_ptr(),
5553        info,
5554    )
5555}
5556
5557#[inline]
5558pub unsafe fn ssyrfsx(
5559    uplo: u8,
5560    equed: u8,
5561    n: i32,
5562    nrhs: i32,
5563    a: &[f32],
5564    lda: i32,
5565    af: &[f32],
5566    ldaf: i32,
5567    ipiv: &[i32],
5568    s: &[f32],
5569    b: &[f32],
5570    ldb: i32,
5571    x: &mut [f32],
5572    ldx: i32,
5573    rcond: &mut f32,
5574    berr: &mut [f32],
5575    n_err_bnds: i32,
5576    err_bnds_norm: &mut [f32],
5577    err_bnds_comp: &mut [f32],
5578    nparams: &[i32],
5579    params: &mut [f32],
5580    work: &mut [f32],
5581    iwork: &mut [i32],
5582    info: &mut i32,
5583) {
5584    ffi::ssyrfsx_(
5585        &(uplo as c_char),
5586        &(equed as c_char),
5587        &n,
5588        &nrhs,
5589        a.as_ptr(),
5590        &lda,
5591        af.as_ptr(),
5592        &ldaf,
5593        ipiv.as_ptr(),
5594        s.as_ptr(),
5595        b.as_ptr(),
5596        &ldb,
5597        x.as_mut_ptr(),
5598        &ldx,
5599        rcond,
5600        berr.as_mut_ptr(),
5601        &n_err_bnds,
5602        err_bnds_norm.as_mut_ptr(),
5603        err_bnds_comp.as_mut_ptr(),
5604        nparams.as_ptr(),
5605        params.as_mut_ptr(),
5606        work.as_mut_ptr(),
5607        iwork.as_mut_ptr(),
5608        info,
5609    )
5610}
5611
5612#[inline]
5613pub unsafe fn zsyrfsx(
5614    uplo: u8,
5615    equed: u8,
5616    n: i32,
5617    nrhs: i32,
5618    a: &[c64],
5619    lda: i32,
5620    af: &[c64],
5621    ldaf: i32,
5622    ipiv: &[i32],
5623    s: &[f64],
5624    b: &[c64],
5625    ldb: i32,
5626    x: &mut [c64],
5627    ldx: i32,
5628    rcond: &mut f64,
5629    berr: &mut [f64],
5630    n_err_bnds: i32,
5631    err_bnds_norm: &mut [f64],
5632    err_bnds_comp: &mut [f64],
5633    nparams: &[i32],
5634    params: &mut [f64],
5635    work: &mut [c64],
5636    rwork: &mut [f64],
5637    info: &mut i32,
5638) {
5639    ffi::zsyrfsx_(
5640        &(uplo as c_char),
5641        &(equed as c_char),
5642        &n,
5643        &nrhs,
5644        a.as_ptr() as *const _,
5645        &lda,
5646        af.as_ptr() as *const _,
5647        &ldaf,
5648        ipiv.as_ptr(),
5649        s.as_ptr(),
5650        b.as_ptr() as *const _,
5651        &ldb,
5652        x.as_mut_ptr() as *mut _,
5653        &ldx,
5654        rcond,
5655        berr.as_mut_ptr(),
5656        &n_err_bnds,
5657        err_bnds_norm.as_mut_ptr(),
5658        err_bnds_comp.as_mut_ptr(),
5659        nparams.as_ptr(),
5660        params.as_mut_ptr(),
5661        work.as_mut_ptr() as *mut _,
5662        rwork.as_mut_ptr(),
5663        info,
5664    )
5665}
5666
5667#[inline]
5668pub unsafe fn csyrfsx(
5669    uplo: u8,
5670    equed: u8,
5671    n: i32,
5672    nrhs: i32,
5673    a: &[c32],
5674    lda: i32,
5675    af: &[c32],
5676    ldaf: i32,
5677    ipiv: &[i32],
5678    s: &[f32],
5679    b: &[c32],
5680    ldb: i32,
5681    x: &mut [c32],
5682    ldx: i32,
5683    rcond: &mut f32,
5684    berr: &mut [f32],
5685    n_err_bnds: i32,
5686    err_bnds_norm: &mut [f32],
5687    err_bnds_comp: &mut [f32],
5688    nparams: &[i32],
5689    params: &mut [f32],
5690    work: &mut [c32],
5691    rwork: &mut [f32],
5692    info: &mut i32,
5693) {
5694    ffi::csyrfsx_(
5695        &(uplo as c_char),
5696        &(equed as c_char),
5697        &n,
5698        &nrhs,
5699        a.as_ptr() as *const _,
5700        &lda,
5701        af.as_ptr() as *const _,
5702        &ldaf,
5703        ipiv.as_ptr(),
5704        s.as_ptr(),
5705        b.as_ptr() as *const _,
5706        &ldb,
5707        x.as_mut_ptr() as *mut _,
5708        &ldx,
5709        rcond,
5710        berr.as_mut_ptr(),
5711        &n_err_bnds,
5712        err_bnds_norm.as_mut_ptr(),
5713        err_bnds_comp.as_mut_ptr(),
5714        nparams.as_ptr(),
5715        params.as_mut_ptr(),
5716        work.as_mut_ptr() as *mut _,
5717        rwork.as_mut_ptr(),
5718        info,
5719    )
5720}
5721
5722#[inline]
5723pub unsafe fn cherfs(
5724    uplo: u8,
5725    n: i32,
5726    nrhs: i32,
5727    a: &[c32],
5728    lda: i32,
5729    af: &[c32],
5730    ldaf: i32,
5731    ipiv: &[i32],
5732    b: &[c32],
5733    ldb: i32,
5734    x: &mut [c32],
5735    ldx: i32,
5736    ferr: &mut [f32],
5737    berr: &mut [f32],
5738    work: &mut [c32],
5739    rwork: &mut [f32],
5740    info: &mut i32,
5741) {
5742    ffi::cherfs_(
5743        &(uplo as c_char),
5744        &n,
5745        &nrhs,
5746        a.as_ptr() as *const _,
5747        &lda,
5748        af.as_ptr() as *const _,
5749        &ldaf,
5750        ipiv.as_ptr(),
5751        b.as_ptr() as *const _,
5752        &ldb,
5753        x.as_mut_ptr() as *mut _,
5754        &ldx,
5755        ferr.as_mut_ptr(),
5756        berr.as_mut_ptr(),
5757        work.as_mut_ptr() as *mut _,
5758        rwork.as_mut_ptr(),
5759        info,
5760    )
5761}
5762
5763#[inline]
5764pub unsafe fn zherfs(
5765    uplo: u8,
5766    n: i32,
5767    nrhs: i32,
5768    a: &[c64],
5769    lda: i32,
5770    af: &[c64],
5771    ldaf: i32,
5772    ipiv: &[i32],
5773    b: &[c64],
5774    ldb: i32,
5775    x: &mut [c64],
5776    ldx: i32,
5777    ferr: &mut [f64],
5778    berr: &mut [f64],
5779    work: &mut [c64],
5780    rwork: &mut [f64],
5781    info: &mut i32,
5782) {
5783    ffi::zherfs_(
5784        &(uplo as c_char),
5785        &n,
5786        &nrhs,
5787        a.as_ptr() as *const _,
5788        &lda,
5789        af.as_ptr() as *const _,
5790        &ldaf,
5791        ipiv.as_ptr(),
5792        b.as_ptr() as *const _,
5793        &ldb,
5794        x.as_mut_ptr() as *mut _,
5795        &ldx,
5796        ferr.as_mut_ptr(),
5797        berr.as_mut_ptr(),
5798        work.as_mut_ptr() as *mut _,
5799        rwork.as_mut_ptr(),
5800        info,
5801    )
5802}
5803
5804#[inline]
5805pub unsafe fn zherfsx(
5806    uplo: u8,
5807    equed: u8,
5808    n: i32,
5809    nrhs: i32,
5810    a: &[c64],
5811    lda: i32,
5812    af: &[c64],
5813    ldaf: i32,
5814    ipiv: &[i32],
5815    s: &[f64],
5816    b: &[c64],
5817    ldb: i32,
5818    x: &mut [c64],
5819    ldx: i32,
5820    rcond: &mut f64,
5821    berr: &mut [f64],
5822    n_err_bnds: i32,
5823    err_bnds_norm: &mut [f64],
5824    err_bnds_comp: &mut [f64],
5825    nparams: &[i32],
5826    params: &mut [f64],
5827    work: &mut [c64],
5828    rwork: &mut [f64],
5829    info: &mut i32,
5830) {
5831    ffi::zherfsx_(
5832        &(uplo as c_char),
5833        &(equed as c_char),
5834        &n,
5835        &nrhs,
5836        a.as_ptr() as *const _,
5837        &lda,
5838        af.as_ptr() as *const _,
5839        &ldaf,
5840        ipiv.as_ptr(),
5841        s.as_ptr(),
5842        b.as_ptr() as *const _,
5843        &ldb,
5844        x.as_mut_ptr() as *mut _,
5845        &ldx,
5846        rcond,
5847        berr.as_mut_ptr(),
5848        &n_err_bnds,
5849        err_bnds_norm.as_mut_ptr(),
5850        err_bnds_comp.as_mut_ptr(),
5851        nparams.as_ptr(),
5852        params.as_mut_ptr(),
5853        work.as_mut_ptr() as *mut _,
5854        rwork.as_mut_ptr(),
5855        info,
5856    )
5857}
5858
5859#[inline]
5860pub unsafe fn cherfsx(
5861    uplo: u8,
5862    equed: u8,
5863    n: i32,
5864    nrhs: i32,
5865    a: &[c32],
5866    lda: i32,
5867    af: &[c32],
5868    ldaf: i32,
5869    ipiv: &[i32],
5870    s: &[f32],
5871    b: &[c32],
5872    ldb: i32,
5873    x: &mut [c32],
5874    ldx: i32,
5875    rcond: &mut f32,
5876    berr: &mut [f32],
5877    n_err_bnds: i32,
5878    err_bnds_norm: &mut [f32],
5879    err_bnds_comp: &mut [f32],
5880    nparams: &[i32],
5881    params: &mut [f32],
5882    work: &mut [c32],
5883    rwork: &mut [f32],
5884    info: &mut i32,
5885) {
5886    ffi::cherfsx_(
5887        &(uplo as c_char),
5888        &(equed as c_char),
5889        &n,
5890        &nrhs,
5891        a.as_ptr() as *const _,
5892        &lda,
5893        af.as_ptr() as *const _,
5894        &ldaf,
5895        ipiv.as_ptr(),
5896        s.as_ptr(),
5897        b.as_ptr() as *const _,
5898        &ldb,
5899        x.as_mut_ptr() as *mut _,
5900        &ldx,
5901        rcond,
5902        berr.as_mut_ptr(),
5903        &n_err_bnds,
5904        err_bnds_norm.as_mut_ptr(),
5905        err_bnds_comp.as_mut_ptr(),
5906        nparams.as_ptr(),
5907        params.as_mut_ptr(),
5908        work.as_mut_ptr() as *mut _,
5909        rwork.as_mut_ptr(),
5910        info,
5911    )
5912}
5913
5914#[inline]
5915pub unsafe fn ssprfs(
5916    uplo: u8,
5917    n: i32,
5918    nrhs: i32,
5919    ap: &[f32],
5920    afp: &[f32],
5921    ipiv: &[i32],
5922    b: &[f32],
5923    ldb: i32,
5924    x: &mut [f32],
5925    ldx: i32,
5926    ferr: &mut [f32],
5927    berr: &mut [f32],
5928    work: &mut [f32],
5929    iwork: &mut [i32],
5930    info: &mut i32,
5931) {
5932    ffi::ssprfs_(
5933        &(uplo as c_char),
5934        &n,
5935        &nrhs,
5936        ap.as_ptr(),
5937        afp.as_ptr(),
5938        ipiv.as_ptr(),
5939        b.as_ptr(),
5940        &ldb,
5941        x.as_mut_ptr(),
5942        &ldx,
5943        ferr.as_mut_ptr(),
5944        berr.as_mut_ptr(),
5945        work.as_mut_ptr(),
5946        iwork.as_mut_ptr(),
5947        info,
5948    )
5949}
5950
5951#[inline]
5952pub unsafe fn dsprfs(
5953    uplo: u8,
5954    n: i32,
5955    nrhs: i32,
5956    ap: &[f64],
5957    afp: &[f64],
5958    ipiv: &[i32],
5959    b: &[f64],
5960    ldb: i32,
5961    x: &mut [f64],
5962    ldx: i32,
5963    ferr: &mut [f64],
5964    berr: &mut [f64],
5965    work: &mut [f64],
5966    iwork: &mut [i32],
5967    info: &mut i32,
5968) {
5969    ffi::dsprfs_(
5970        &(uplo as c_char),
5971        &n,
5972        &nrhs,
5973        ap.as_ptr(),
5974        afp.as_ptr(),
5975        ipiv.as_ptr(),
5976        b.as_ptr(),
5977        &ldb,
5978        x.as_mut_ptr(),
5979        &ldx,
5980        ferr.as_mut_ptr(),
5981        berr.as_mut_ptr(),
5982        work.as_mut_ptr(),
5983        iwork.as_mut_ptr(),
5984        info,
5985    )
5986}
5987
5988#[inline]
5989pub unsafe fn csprfs(
5990    uplo: u8,
5991    n: i32,
5992    nrhs: i32,
5993    ap: &[c32],
5994    afp: &[c32],
5995    ipiv: &[i32],
5996    b: &[c32],
5997    ldb: i32,
5998    x: &mut [c32],
5999    ldx: i32,
6000    ferr: &mut [f32],
6001    berr: &mut [f32],
6002    work: &mut [c32],
6003    rwork: &mut [f32],
6004    info: &mut i32,
6005) {
6006    ffi::csprfs_(
6007        &(uplo as c_char),
6008        &n,
6009        &nrhs,
6010        ap.as_ptr() as *const _,
6011        afp.as_ptr() as *const _,
6012        ipiv.as_ptr(),
6013        b.as_ptr() as *const _,
6014        &ldb,
6015        x.as_mut_ptr() as *mut _,
6016        &ldx,
6017        ferr.as_mut_ptr(),
6018        berr.as_mut_ptr(),
6019        work.as_mut_ptr() as *mut _,
6020        rwork.as_mut_ptr(),
6021        info,
6022    )
6023}
6024
6025#[inline]
6026pub unsafe fn zsprfs(
6027    uplo: u8,
6028    n: i32,
6029    nrhs: i32,
6030    ap: &[c64],
6031    afp: &[c64],
6032    ipiv: &[i32],
6033    b: &[c64],
6034    ldb: i32,
6035    x: &mut [c64],
6036    ldx: i32,
6037    ferr: &mut [f64],
6038    berr: &mut [f64],
6039    work: &mut [c64],
6040    rwork: &mut [f64],
6041    info: &mut i32,
6042) {
6043    ffi::zsprfs_(
6044        &(uplo as c_char),
6045        &n,
6046        &nrhs,
6047        ap.as_ptr() as *const _,
6048        afp.as_ptr() as *const _,
6049        ipiv.as_ptr(),
6050        b.as_ptr() as *const _,
6051        &ldb,
6052        x.as_mut_ptr() as *mut _,
6053        &ldx,
6054        ferr.as_mut_ptr(),
6055        berr.as_mut_ptr(),
6056        work.as_mut_ptr() as *mut _,
6057        rwork.as_mut_ptr(),
6058        info,
6059    )
6060}
6061
6062#[inline]
6063pub unsafe fn chprfs(
6064    uplo: u8,
6065    n: i32,
6066    nrhs: i32,
6067    ap: &[c32],
6068    afp: &[c32],
6069    ipiv: &[i32],
6070    b: &[c32],
6071    ldb: i32,
6072    x: &mut [c32],
6073    ldx: i32,
6074    ferr: &mut [f32],
6075    berr: &mut [f32],
6076    work: &mut [c32],
6077    rwork: &mut [f32],
6078    info: &mut i32,
6079) {
6080    ffi::chprfs_(
6081        &(uplo as c_char),
6082        &n,
6083        &nrhs,
6084        ap.as_ptr() as *const _,
6085        afp.as_ptr() as *const _,
6086        ipiv.as_ptr(),
6087        b.as_ptr() as *const _,
6088        &ldb,
6089        x.as_mut_ptr() as *mut _,
6090        &ldx,
6091        ferr.as_mut_ptr(),
6092        berr.as_mut_ptr(),
6093        work.as_mut_ptr() as *mut _,
6094        rwork.as_mut_ptr(),
6095        info,
6096    )
6097}
6098
6099#[inline]
6100pub unsafe fn zhprfs(
6101    uplo: u8,
6102    n: i32,
6103    nrhs: i32,
6104    ap: &[c64],
6105    afp: &[c64],
6106    ipiv: &[i32],
6107    b: &[c64],
6108    ldb: i32,
6109    x: &mut [c64],
6110    ldx: i32,
6111    ferr: &mut [f64],
6112    berr: &mut [f64],
6113    work: &mut [c64],
6114    rwork: &mut [f64],
6115    info: &mut i32,
6116) {
6117    ffi::zhprfs_(
6118        &(uplo as c_char),
6119        &n,
6120        &nrhs,
6121        ap.as_ptr() as *const _,
6122        afp.as_ptr() as *const _,
6123        ipiv.as_ptr(),
6124        b.as_ptr() as *const _,
6125        &ldb,
6126        x.as_mut_ptr() as *mut _,
6127        &ldx,
6128        ferr.as_mut_ptr(),
6129        berr.as_mut_ptr(),
6130        work.as_mut_ptr() as *mut _,
6131        rwork.as_mut_ptr(),
6132        info,
6133    )
6134}
6135
6136#[inline]
6137pub unsafe fn strrfs(
6138    uplo: u8,
6139    trans: u8,
6140    diag: u8,
6141    n: i32,
6142    nrhs: i32,
6143    a: &[f32],
6144    lda: i32,
6145    b: &[f32],
6146    ldb: i32,
6147    x: &[f32],
6148    ldx: i32,
6149    ferr: &mut [f32],
6150    berr: &mut [f32],
6151    work: &mut [f32],
6152    iwork: &mut [i32],
6153    info: &mut i32,
6154) {
6155    ffi::strrfs_(
6156        &(uplo as c_char),
6157        &(trans as c_char),
6158        &(diag as c_char),
6159        &n,
6160        &nrhs,
6161        a.as_ptr(),
6162        &lda,
6163        b.as_ptr(),
6164        &ldb,
6165        x.as_ptr(),
6166        &ldx,
6167        ferr.as_mut_ptr(),
6168        berr.as_mut_ptr(),
6169        work.as_mut_ptr(),
6170        iwork.as_mut_ptr(),
6171        info,
6172    )
6173}
6174
6175#[inline]
6176pub unsafe fn dtrrfs(
6177    uplo: u8,
6178    trans: u8,
6179    diag: u8,
6180    n: i32,
6181    nrhs: i32,
6182    a: &[f64],
6183    lda: i32,
6184    b: &[f64],
6185    ldb: i32,
6186    x: &[f64],
6187    ldx: i32,
6188    ferr: &mut [f64],
6189    berr: &mut [f64],
6190    work: &mut [f64],
6191    iwork: &mut [i32],
6192    info: &mut i32,
6193) {
6194    ffi::dtrrfs_(
6195        &(uplo as c_char),
6196        &(trans as c_char),
6197        &(diag as c_char),
6198        &n,
6199        &nrhs,
6200        a.as_ptr(),
6201        &lda,
6202        b.as_ptr(),
6203        &ldb,
6204        x.as_ptr(),
6205        &ldx,
6206        ferr.as_mut_ptr(),
6207        berr.as_mut_ptr(),
6208        work.as_mut_ptr(),
6209        iwork.as_mut_ptr(),
6210        info,
6211    )
6212}
6213
6214#[inline]
6215pub unsafe fn ctrrfs(
6216    uplo: u8,
6217    trans: u8,
6218    diag: u8,
6219    n: i32,
6220    nrhs: i32,
6221    a: &[c32],
6222    lda: i32,
6223    b: &[c32],
6224    ldb: i32,
6225    x: &[c32],
6226    ldx: i32,
6227    ferr: &mut [f32],
6228    berr: &mut [f32],
6229    work: &mut [c32],
6230    rwork: &mut [f32],
6231    info: &mut i32,
6232) {
6233    ffi::ctrrfs_(
6234        &(uplo as c_char),
6235        &(trans as c_char),
6236        &(diag as c_char),
6237        &n,
6238        &nrhs,
6239        a.as_ptr() as *const _,
6240        &lda,
6241        b.as_ptr() as *const _,
6242        &ldb,
6243        x.as_ptr() as *const _,
6244        &ldx,
6245        ferr.as_mut_ptr(),
6246        berr.as_mut_ptr(),
6247        work.as_mut_ptr() as *mut _,
6248        rwork.as_mut_ptr(),
6249        info,
6250    )
6251}
6252
6253#[inline]
6254pub unsafe fn ztrrfs(
6255    uplo: u8,
6256    trans: u8,
6257    diag: u8,
6258    n: i32,
6259    nrhs: i32,
6260    a: &[c64],
6261    lda: i32,
6262    b: &[c64],
6263    ldb: i32,
6264    x: &[c64],
6265    ldx: i32,
6266    ferr: &mut [f64],
6267    berr: &mut [f64],
6268    work: &mut [c64],
6269    rwork: &mut [f64],
6270    info: &mut i32,
6271) {
6272    ffi::ztrrfs_(
6273        &(uplo as c_char),
6274        &(trans as c_char),
6275        &(diag as c_char),
6276        &n,
6277        &nrhs,
6278        a.as_ptr() as *const _,
6279        &lda,
6280        b.as_ptr() as *const _,
6281        &ldb,
6282        x.as_ptr() as *const _,
6283        &ldx,
6284        ferr.as_mut_ptr(),
6285        berr.as_mut_ptr(),
6286        work.as_mut_ptr() as *mut _,
6287        rwork.as_mut_ptr(),
6288        info,
6289    )
6290}
6291
6292#[inline]
6293pub unsafe fn stprfs(
6294    uplo: u8,
6295    trans: u8,
6296    diag: u8,
6297    n: i32,
6298    nrhs: i32,
6299    ap: &[f32],
6300    b: &[f32],
6301    ldb: i32,
6302    x: &[f32],
6303    ldx: i32,
6304    ferr: &mut [f32],
6305    berr: &mut [f32],
6306    work: &mut [f32],
6307    iwork: &mut [i32],
6308    info: &mut i32,
6309) {
6310    ffi::stprfs_(
6311        &(uplo as c_char),
6312        &(trans as c_char),
6313        &(diag as c_char),
6314        &n,
6315        &nrhs,
6316        ap.as_ptr(),
6317        b.as_ptr(),
6318        &ldb,
6319        x.as_ptr(),
6320        &ldx,
6321        ferr.as_mut_ptr(),
6322        berr.as_mut_ptr(),
6323        work.as_mut_ptr(),
6324        iwork.as_mut_ptr(),
6325        info,
6326    )
6327}
6328
6329#[inline]
6330pub unsafe fn dtprfs(
6331    uplo: u8,
6332    trans: u8,
6333    diag: u8,
6334    n: i32,
6335    nrhs: i32,
6336    ap: &[f64],
6337    b: &[f64],
6338    ldb: i32,
6339    x: &[f64],
6340    ldx: i32,
6341    ferr: &mut [f64],
6342    berr: &mut [f64],
6343    work: &mut [f64],
6344    iwork: &mut [i32],
6345    info: &mut i32,
6346) {
6347    ffi::dtprfs_(
6348        &(uplo as c_char),
6349        &(trans as c_char),
6350        &(diag as c_char),
6351        &n,
6352        &nrhs,
6353        ap.as_ptr(),
6354        b.as_ptr(),
6355        &ldb,
6356        x.as_ptr(),
6357        &ldx,
6358        ferr.as_mut_ptr(),
6359        berr.as_mut_ptr(),
6360        work.as_mut_ptr(),
6361        iwork.as_mut_ptr(),
6362        info,
6363    )
6364}
6365
6366#[inline]
6367pub unsafe fn ctprfs(
6368    uplo: u8,
6369    trans: u8,
6370    diag: u8,
6371    n: i32,
6372    nrhs: i32,
6373    ap: &[c32],
6374    b: &[c32],
6375    ldb: i32,
6376    x: &[c32],
6377    ldx: i32,
6378    ferr: &mut [f32],
6379    berr: &mut [f32],
6380    work: &mut [c32],
6381    rwork: &mut [f32],
6382    info: &mut i32,
6383) {
6384    ffi::ctprfs_(
6385        &(uplo as c_char),
6386        &(trans as c_char),
6387        &(diag as c_char),
6388        &n,
6389        &nrhs,
6390        ap.as_ptr() as *const _,
6391        b.as_ptr() as *const _,
6392        &ldb,
6393        x.as_ptr() as *const _,
6394        &ldx,
6395        ferr.as_mut_ptr(),
6396        berr.as_mut_ptr(),
6397        work.as_mut_ptr() as *mut _,
6398        rwork.as_mut_ptr(),
6399        info,
6400    )
6401}
6402
6403#[inline]
6404pub unsafe fn ztprfs(
6405    uplo: u8,
6406    trans: u8,
6407    diag: u8,
6408    n: i32,
6409    nrhs: i32,
6410    ap: &[c64],
6411    b: &[c64],
6412    ldb: i32,
6413    x: &[c64],
6414    ldx: i32,
6415    ferr: &mut [f64],
6416    berr: &mut [f64],
6417    work: &mut [c64],
6418    rwork: &mut [f64],
6419    info: &mut i32,
6420) {
6421    ffi::ztprfs_(
6422        &(uplo as c_char),
6423        &(trans as c_char),
6424        &(diag as c_char),
6425        &n,
6426        &nrhs,
6427        ap.as_ptr() as *const _,
6428        b.as_ptr() as *const _,
6429        &ldb,
6430        x.as_ptr() as *const _,
6431        &ldx,
6432        ferr.as_mut_ptr(),
6433        berr.as_mut_ptr(),
6434        work.as_mut_ptr() as *mut _,
6435        rwork.as_mut_ptr(),
6436        info,
6437    )
6438}
6439
6440#[inline]
6441pub unsafe fn stbrfs(
6442    uplo: u8,
6443    trans: u8,
6444    diag: u8,
6445    n: i32,
6446    kd: i32,
6447    nrhs: i32,
6448    ab: &[f32],
6449    ldab: i32,
6450    b: &[f32],
6451    ldb: i32,
6452    x: &[f32],
6453    ldx: i32,
6454    ferr: &mut [f32],
6455    berr: &mut [f32],
6456    work: &mut [f32],
6457    iwork: &mut [i32],
6458    info: &mut i32,
6459) {
6460    ffi::stbrfs_(
6461        &(uplo as c_char),
6462        &(trans as c_char),
6463        &(diag as c_char),
6464        &n,
6465        &kd,
6466        &nrhs,
6467        ab.as_ptr(),
6468        &ldab,
6469        b.as_ptr(),
6470        &ldb,
6471        x.as_ptr(),
6472        &ldx,
6473        ferr.as_mut_ptr(),
6474        berr.as_mut_ptr(),
6475        work.as_mut_ptr(),
6476        iwork.as_mut_ptr(),
6477        info,
6478    )
6479}
6480
6481#[inline]
6482pub unsafe fn dtbrfs(
6483    uplo: u8,
6484    trans: u8,
6485    diag: u8,
6486    n: i32,
6487    kd: i32,
6488    nrhs: i32,
6489    ab: &[f64],
6490    ldab: i32,
6491    b: &[f64],
6492    ldb: i32,
6493    x: &[f64],
6494    ldx: i32,
6495    ferr: &mut [f64],
6496    berr: &mut [f64],
6497    work: &mut [f64],
6498    iwork: &mut [i32],
6499    info: &mut i32,
6500) {
6501    ffi::dtbrfs_(
6502        &(uplo as c_char),
6503        &(trans as c_char),
6504        &(diag as c_char),
6505        &n,
6506        &kd,
6507        &nrhs,
6508        ab.as_ptr(),
6509        &ldab,
6510        b.as_ptr(),
6511        &ldb,
6512        x.as_ptr(),
6513        &ldx,
6514        ferr.as_mut_ptr(),
6515        berr.as_mut_ptr(),
6516        work.as_mut_ptr(),
6517        iwork.as_mut_ptr(),
6518        info,
6519    )
6520}
6521
6522#[inline]
6523pub unsafe fn ctbrfs(
6524    uplo: u8,
6525    trans: u8,
6526    diag: u8,
6527    n: i32,
6528    kd: i32,
6529    nrhs: i32,
6530    ab: &[c32],
6531    ldab: i32,
6532    b: &[c32],
6533    ldb: i32,
6534    x: &[c32],
6535    ldx: i32,
6536    ferr: &mut [f32],
6537    berr: &mut [f32],
6538    work: &mut [c32],
6539    rwork: &mut [f32],
6540    info: &mut i32,
6541) {
6542    ffi::ctbrfs_(
6543        &(uplo as c_char),
6544        &(trans as c_char),
6545        &(diag as c_char),
6546        &n,
6547        &kd,
6548        &nrhs,
6549        ab.as_ptr() as *const _,
6550        &ldab,
6551        b.as_ptr() as *const _,
6552        &ldb,
6553        x.as_ptr() as *const _,
6554        &ldx,
6555        ferr.as_mut_ptr(),
6556        berr.as_mut_ptr(),
6557        work.as_mut_ptr() as *mut _,
6558        rwork.as_mut_ptr(),
6559        info,
6560    )
6561}
6562
6563#[inline]
6564pub unsafe fn ztbrfs(
6565    uplo: u8,
6566    trans: u8,
6567    diag: u8,
6568    n: i32,
6569    kd: i32,
6570    nrhs: i32,
6571    ab: &[c64],
6572    ldab: i32,
6573    b: &[c64],
6574    ldb: i32,
6575    x: &[c64],
6576    ldx: i32,
6577    ferr: &mut [f64],
6578    berr: &mut [f64],
6579    work: &mut [c64],
6580    rwork: &mut [f64],
6581    info: &mut i32,
6582) {
6583    ffi::ztbrfs_(
6584        &(uplo as c_char),
6585        &(trans as c_char),
6586        &(diag as c_char),
6587        &n,
6588        &kd,
6589        &nrhs,
6590        ab.as_ptr() as *const _,
6591        &ldab,
6592        b.as_ptr() as *const _,
6593        &ldb,
6594        x.as_ptr() as *const _,
6595        &ldx,
6596        ferr.as_mut_ptr(),
6597        berr.as_mut_ptr(),
6598        work.as_mut_ptr() as *mut _,
6599        rwork.as_mut_ptr(),
6600        info,
6601    )
6602}
6603
6604#[inline]
6605pub unsafe fn sgetri(
6606    n: i32,
6607    a: &mut [f32],
6608    lda: i32,
6609    ipiv: &[i32],
6610    work: &mut [f32],
6611    lwork: i32,
6612    info: &mut i32,
6613) {
6614    ffi::sgetri_(
6615        &n,
6616        a.as_mut_ptr(),
6617        &lda,
6618        ipiv.as_ptr(),
6619        work.as_mut_ptr(),
6620        &lwork,
6621        info,
6622    )
6623}
6624
6625#[inline]
6626pub unsafe fn dgetri(
6627    n: i32,
6628    a: &mut [f64],
6629    lda: i32,
6630    ipiv: &[i32],
6631    work: &mut [f64],
6632    lwork: i32,
6633    info: &mut i32,
6634) {
6635    ffi::dgetri_(
6636        &n,
6637        a.as_mut_ptr(),
6638        &lda,
6639        ipiv.as_ptr(),
6640        work.as_mut_ptr(),
6641        &lwork,
6642        info,
6643    )
6644}
6645
6646#[inline]
6647pub unsafe fn cgetri(
6648    n: i32,
6649    a: &mut [c32],
6650    lda: i32,
6651    ipiv: &[i32],
6652    work: &mut [c32],
6653    lwork: i32,
6654    info: &mut i32,
6655) {
6656    ffi::cgetri_(
6657        &n,
6658        a.as_mut_ptr() as *mut _,
6659        &lda,
6660        ipiv.as_ptr(),
6661        work.as_mut_ptr() as *mut _,
6662        &lwork,
6663        info,
6664    )
6665}
6666
6667#[inline]
6668pub unsafe fn zgetri(
6669    n: i32,
6670    a: &mut [c64],
6671    lda: i32,
6672    ipiv: &[i32],
6673    work: &mut [c64],
6674    lwork: i32,
6675    info: &mut i32,
6676) {
6677    ffi::zgetri_(
6678        &n,
6679        a.as_mut_ptr() as *mut _,
6680        &lda,
6681        ipiv.as_ptr(),
6682        work.as_mut_ptr() as *mut _,
6683        &lwork,
6684        info,
6685    )
6686}
6687
6688#[inline]
6689pub unsafe fn spotri(uplo: u8, n: i32, a: &mut [f32], lda: i32, info: &mut i32) {
6690    ffi::spotri_(&(uplo as c_char), &n, a.as_mut_ptr(), &lda, info)
6691}
6692
6693#[inline]
6694pub unsafe fn dpotri(uplo: u8, n: i32, a: &mut [f64], lda: i32, info: &mut i32) {
6695    ffi::dpotri_(&(uplo as c_char), &n, a.as_mut_ptr(), &lda, info)
6696}
6697
6698#[inline]
6699pub unsafe fn cpotri(uplo: u8, n: i32, a: &mut [c32], lda: i32, info: &mut i32) {
6700    ffi::cpotri_(&(uplo as c_char), &n, a.as_mut_ptr() as *mut _, &lda, info)
6701}
6702
6703#[inline]
6704pub unsafe fn zpotri(uplo: u8, n: i32, a: &mut [c64], lda: i32, info: &mut i32) {
6705    ffi::zpotri_(&(uplo as c_char), &n, a.as_mut_ptr() as *mut _, &lda, info)
6706}
6707
6708#[inline]
6709pub unsafe fn dpftri(transr: u8, uplo: u8, n: i32, a: &mut [f64], info: &mut i32) {
6710    ffi::dpftri_(
6711        &(transr as c_char),
6712        &(uplo as c_char),
6713        &n,
6714        a.as_mut_ptr(),
6715        info,
6716    )
6717}
6718
6719#[inline]
6720pub unsafe fn spftri(transr: u8, uplo: u8, n: i32, a: &mut [f32], info: &mut i32) {
6721    ffi::spftri_(
6722        &(transr as c_char),
6723        &(uplo as c_char),
6724        &n,
6725        a.as_mut_ptr(),
6726        info,
6727    )
6728}
6729
6730#[inline]
6731pub unsafe fn zpftri(transr: u8, uplo: u8, n: i32, a: &mut [c64], info: &mut i32) {
6732    ffi::zpftri_(
6733        &(transr as c_char),
6734        &(uplo as c_char),
6735        &n,
6736        a.as_mut_ptr() as *mut _,
6737        info,
6738    )
6739}
6740
6741#[inline]
6742pub unsafe fn cpftri(transr: u8, uplo: u8, n: i32, a: &mut [c32], info: &mut i32) {
6743    ffi::cpftri_(
6744        &(transr as c_char),
6745        &(uplo as c_char),
6746        &n,
6747        a.as_mut_ptr() as *mut _,
6748        info,
6749    )
6750}
6751
6752#[inline]
6753pub unsafe fn spptri(uplo: u8, n: i32, ap: &mut [f32], info: &mut i32) {
6754    ffi::spptri_(&(uplo as c_char), &n, ap.as_mut_ptr(), info)
6755}
6756
6757#[inline]
6758pub unsafe fn dpptri(uplo: u8, n: i32, ap: &mut [f64], info: &mut i32) {
6759    ffi::dpptri_(&(uplo as c_char), &n, ap.as_mut_ptr(), info)
6760}
6761
6762#[inline]
6763pub unsafe fn cpptri(uplo: u8, n: i32, ap: &mut [c32], info: &mut i32) {
6764    ffi::cpptri_(&(uplo as c_char), &n, ap.as_mut_ptr() as *mut _, info)
6765}
6766
6767#[inline]
6768pub unsafe fn zpptri(uplo: u8, n: i32, ap: &mut [c64], info: &mut i32) {
6769    ffi::zpptri_(&(uplo as c_char), &n, ap.as_mut_ptr() as *mut _, info)
6770}
6771
6772#[inline]
6773pub unsafe fn ssytri(
6774    uplo: u8,
6775    n: i32,
6776    a: &mut [f32],
6777    lda: i32,
6778    ipiv: &[i32],
6779    work: &mut [f32],
6780    info: &mut i32,
6781) {
6782    ffi::ssytri_(
6783        &(uplo as c_char),
6784        &n,
6785        a.as_mut_ptr(),
6786        &lda,
6787        ipiv.as_ptr(),
6788        work.as_mut_ptr(),
6789        info,
6790    )
6791}
6792
6793#[inline]
6794pub unsafe fn dsytri(
6795    uplo: u8,
6796    n: i32,
6797    a: &mut [f64],
6798    lda: i32,
6799    ipiv: &[i32],
6800    work: &mut [f64],
6801    info: &mut i32,
6802) {
6803    ffi::dsytri_(
6804        &(uplo as c_char),
6805        &n,
6806        a.as_mut_ptr(),
6807        &lda,
6808        ipiv.as_ptr(),
6809        work.as_mut_ptr(),
6810        info,
6811    )
6812}
6813
6814#[inline]
6815pub unsafe fn csytri(
6816    uplo: u8,
6817    n: i32,
6818    a: &mut [c32],
6819    lda: i32,
6820    ipiv: &[i32],
6821    work: &mut [c32],
6822    info: &mut i32,
6823) {
6824    ffi::csytri_(
6825        &(uplo as c_char),
6826        &n,
6827        a.as_mut_ptr() as *mut _,
6828        &lda,
6829        ipiv.as_ptr(),
6830        work.as_mut_ptr() as *mut _,
6831        info,
6832    )
6833}
6834
6835#[inline]
6836pub unsafe fn zsytri(
6837    uplo: u8,
6838    n: i32,
6839    a: &mut [c64],
6840    lda: i32,
6841    ipiv: &[i32],
6842    work: &mut [c64],
6843    info: &mut i32,
6844) {
6845    ffi::zsytri_(
6846        &(uplo as c_char),
6847        &n,
6848        a.as_mut_ptr() as *mut _,
6849        &lda,
6850        ipiv.as_ptr(),
6851        work.as_mut_ptr() as *mut _,
6852        info,
6853    )
6854}
6855
6856#[inline]
6857pub unsafe fn chetri(
6858    uplo: u8,
6859    n: i32,
6860    a: &mut [c32],
6861    lda: i32,
6862    ipiv: &[i32],
6863    work: &mut [c32],
6864    info: &mut i32,
6865) {
6866    ffi::chetri_(
6867        &(uplo as c_char),
6868        &n,
6869        a.as_mut_ptr() as *mut _,
6870        &lda,
6871        ipiv.as_ptr(),
6872        work.as_mut_ptr() as *mut _,
6873        info,
6874    )
6875}
6876
6877#[inline]
6878pub unsafe fn zhetri(
6879    uplo: u8,
6880    n: i32,
6881    a: &mut [c64],
6882    lda: i32,
6883    ipiv: &[i32],
6884    work: &mut [c64],
6885    info: &mut i32,
6886) {
6887    ffi::zhetri_(
6888        &(uplo as c_char),
6889        &n,
6890        a.as_mut_ptr() as *mut _,
6891        &lda,
6892        ipiv.as_ptr(),
6893        work.as_mut_ptr() as *mut _,
6894        info,
6895    )
6896}
6897
6898#[inline]
6899pub unsafe fn ssptri(
6900    uplo: u8,
6901    n: i32,
6902    ap: &mut [f32],
6903    ipiv: &[i32],
6904    work: &mut [f32],
6905    info: &mut i32,
6906) {
6907    ffi::ssptri_(
6908        &(uplo as c_char),
6909        &n,
6910        ap.as_mut_ptr(),
6911        ipiv.as_ptr(),
6912        work.as_mut_ptr(),
6913        info,
6914    )
6915}
6916
6917#[inline]
6918pub unsafe fn dsptri(
6919    uplo: u8,
6920    n: i32,
6921    ap: &mut [f64],
6922    ipiv: &[i32],
6923    work: &mut [f64],
6924    info: &mut i32,
6925) {
6926    ffi::dsptri_(
6927        &(uplo as c_char),
6928        &n,
6929        ap.as_mut_ptr(),
6930        ipiv.as_ptr(),
6931        work.as_mut_ptr(),
6932        info,
6933    )
6934}
6935
6936#[inline]
6937pub unsafe fn csptri(
6938    uplo: u8,
6939    n: i32,
6940    ap: &mut [c32],
6941    ipiv: &[i32],
6942    work: &mut [c32],
6943    info: &mut i32,
6944) {
6945    ffi::csptri_(
6946        &(uplo as c_char),
6947        &n,
6948        ap.as_mut_ptr() as *mut _,
6949        ipiv.as_ptr(),
6950        work.as_mut_ptr() as *mut _,
6951        info,
6952    )
6953}
6954
6955#[inline]
6956pub unsafe fn zsptri(
6957    uplo: u8,
6958    n: i32,
6959    ap: &mut [c64],
6960    ipiv: &[i32],
6961    work: &mut [c64],
6962    info: &mut i32,
6963) {
6964    ffi::zsptri_(
6965        &(uplo as c_char),
6966        &n,
6967        ap.as_mut_ptr() as *mut _,
6968        ipiv.as_ptr(),
6969        work.as_mut_ptr() as *mut _,
6970        info,
6971    )
6972}
6973
6974#[inline]
6975pub unsafe fn chptri(
6976    uplo: u8,
6977    n: i32,
6978    ap: &mut [c32],
6979    ipiv: &[i32],
6980    work: &mut [c32],
6981    info: &mut i32,
6982) {
6983    ffi::chptri_(
6984        &(uplo as c_char),
6985        &n,
6986        ap.as_mut_ptr() as *mut _,
6987        ipiv.as_ptr(),
6988        work.as_mut_ptr() as *mut _,
6989        info,
6990    )
6991}
6992
6993#[inline]
6994pub unsafe fn zhptri(
6995    uplo: u8,
6996    n: i32,
6997    ap: &mut [c64],
6998    ipiv: &[i32],
6999    work: &mut [c64],
7000    info: &mut i32,
7001) {
7002    ffi::zhptri_(
7003        &(uplo as c_char),
7004        &n,
7005        ap.as_mut_ptr() as *mut _,
7006        ipiv.as_ptr(),
7007        work.as_mut_ptr() as *mut _,
7008        info,
7009    )
7010}
7011
7012#[inline]
7013pub unsafe fn strtri(uplo: u8, diag: u8, n: i32, a: &mut [f32], lda: i32, info: &mut i32) {
7014    ffi::strtri_(
7015        &(uplo as c_char),
7016        &(diag as c_char),
7017        &n,
7018        a.as_mut_ptr(),
7019        &lda,
7020        info,
7021    )
7022}
7023
7024#[inline]
7025pub unsafe fn dtrtri(uplo: u8, diag: u8, n: i32, a: &mut [f64], lda: i32, info: &mut i32) {
7026    ffi::dtrtri_(
7027        &(uplo as c_char),
7028        &(diag as c_char),
7029        &n,
7030        a.as_mut_ptr(),
7031        &lda,
7032        info,
7033    )
7034}
7035
7036#[inline]
7037pub unsafe fn ctrtri(uplo: u8, diag: u8, n: i32, a: &mut [c32], lda: i32, info: &mut i32) {
7038    ffi::ctrtri_(
7039        &(uplo as c_char),
7040        &(diag as c_char),
7041        &n,
7042        a.as_mut_ptr() as *mut _,
7043        &lda,
7044        info,
7045    )
7046}
7047
7048#[inline]
7049pub unsafe fn ztrtri(uplo: u8, diag: u8, n: i32, a: &mut [c64], lda: i32, info: &mut i32) {
7050    ffi::ztrtri_(
7051        &(uplo as c_char),
7052        &(diag as c_char),
7053        &n,
7054        a.as_mut_ptr() as *mut _,
7055        &lda,
7056        info,
7057    )
7058}
7059
7060#[inline]
7061pub unsafe fn dtftri(transr: u8, uplo: u8, diag: u8, n: i32, a: &mut [f64], info: &mut i32) {
7062    ffi::dtftri_(
7063        &(transr as c_char),
7064        &(uplo as c_char),
7065        &(diag as c_char),
7066        &n,
7067        a.as_mut_ptr(),
7068        info,
7069    )
7070}
7071
7072#[inline]
7073pub unsafe fn stftri(transr: u8, uplo: u8, diag: u8, n: i32, a: &mut [f32], info: &mut i32) {
7074    ffi::stftri_(
7075        &(transr as c_char),
7076        &(uplo as c_char),
7077        &(diag as c_char),
7078        &n,
7079        a.as_mut_ptr(),
7080        info,
7081    )
7082}
7083
7084#[inline]
7085pub unsafe fn ztftri(transr: u8, uplo: u8, diag: u8, n: i32, a: &mut [c64], info: &mut i32) {
7086    ffi::ztftri_(
7087        &(transr as c_char),
7088        &(uplo as c_char),
7089        &(diag as c_char),
7090        &n,
7091        a.as_mut_ptr() as *mut _,
7092        info,
7093    )
7094}
7095
7096#[inline]
7097pub unsafe fn ctftri(transr: u8, uplo: u8, diag: u8, n: i32, a: &mut [c32], info: &mut i32) {
7098    ffi::ctftri_(
7099        &(transr as c_char),
7100        &(uplo as c_char),
7101        &(diag as c_char),
7102        &n,
7103        a.as_mut_ptr() as *mut _,
7104        info,
7105    )
7106}
7107
7108#[inline]
7109pub unsafe fn stptri(uplo: u8, diag: u8, n: i32, ap: &mut [f32], info: &mut i32) {
7110    ffi::stptri_(
7111        &(uplo as c_char),
7112        &(diag as c_char),
7113        &n,
7114        ap.as_mut_ptr(),
7115        info,
7116    )
7117}
7118
7119#[inline]
7120pub unsafe fn dtptri(uplo: u8, diag: u8, n: i32, ap: &mut [f64], info: &mut i32) {
7121    ffi::dtptri_(
7122        &(uplo as c_char),
7123        &(diag as c_char),
7124        &n,
7125        ap.as_mut_ptr(),
7126        info,
7127    )
7128}
7129
7130#[inline]
7131pub unsafe fn ctptri(uplo: u8, diag: u8, n: i32, ap: &mut [c32], info: &mut i32) {
7132    ffi::ctptri_(
7133        &(uplo as c_char),
7134        &(diag as c_char),
7135        &n,
7136        ap.as_mut_ptr() as *mut _,
7137        info,
7138    )
7139}
7140
7141#[inline]
7142pub unsafe fn ztptri(uplo: u8, diag: u8, n: i32, ap: &mut [c64], info: &mut i32) {
7143    ffi::ztptri_(
7144        &(uplo as c_char),
7145        &(diag as c_char),
7146        &n,
7147        ap.as_mut_ptr() as *mut _,
7148        info,
7149    )
7150}
7151
7152#[inline]
7153pub unsafe fn sgeequ(
7154    m: i32,
7155    n: i32,
7156    a: &[f32],
7157    lda: i32,
7158    r: &mut [f32],
7159    c: &mut [f32],
7160    rowcnd: &mut f32,
7161    colcnd: &mut f32,
7162    amax: &mut f32,
7163    info: &mut i32,
7164) {
7165    ffi::sgeequ_(
7166        &m,
7167        &n,
7168        a.as_ptr(),
7169        &lda,
7170        r.as_mut_ptr(),
7171        c.as_mut_ptr(),
7172        rowcnd,
7173        colcnd,
7174        amax,
7175        info,
7176    )
7177}
7178
7179#[inline]
7180pub unsafe fn dgeequ(
7181    m: i32,
7182    n: i32,
7183    a: &[f64],
7184    lda: i32,
7185    r: &mut [f64],
7186    c: &mut [f64],
7187    rowcnd: &mut f64,
7188    colcnd: &mut f64,
7189    amax: &mut f64,
7190    info: &mut i32,
7191) {
7192    ffi::dgeequ_(
7193        &m,
7194        &n,
7195        a.as_ptr(),
7196        &lda,
7197        r.as_mut_ptr(),
7198        c.as_mut_ptr(),
7199        rowcnd,
7200        colcnd,
7201        amax,
7202        info,
7203    )
7204}
7205
7206#[inline]
7207pub unsafe fn cgeequ(
7208    m: i32,
7209    n: i32,
7210    a: &[c32],
7211    lda: i32,
7212    r: &mut [f32],
7213    c: &mut [f32],
7214    rowcnd: &mut f32,
7215    colcnd: &mut f32,
7216    amax: &mut f32,
7217    info: &mut i32,
7218) {
7219    ffi::cgeequ_(
7220        &m,
7221        &n,
7222        a.as_ptr() as *const _,
7223        &lda,
7224        r.as_mut_ptr(),
7225        c.as_mut_ptr(),
7226        rowcnd,
7227        colcnd,
7228        amax,
7229        info,
7230    )
7231}
7232
7233#[inline]
7234pub unsafe fn zgeequ(
7235    m: i32,
7236    n: i32,
7237    a: &[c64],
7238    lda: i32,
7239    r: &mut [f64],
7240    c: &mut [f64],
7241    rowcnd: &mut f64,
7242    colcnd: &mut f64,
7243    amax: &mut f64,
7244    info: &mut i32,
7245) {
7246    ffi::zgeequ_(
7247        &m,
7248        &n,
7249        a.as_ptr() as *const _,
7250        &lda,
7251        r.as_mut_ptr(),
7252        c.as_mut_ptr(),
7253        rowcnd,
7254        colcnd,
7255        amax,
7256        info,
7257    )
7258}
7259
7260#[inline]
7261pub unsafe fn dgeequb(
7262    m: i32,
7263    n: i32,
7264    a: &[f64],
7265    lda: i32,
7266    r: &mut [f64],
7267    c: &mut [f64],
7268    rowcnd: &mut f64,
7269    colcnd: &mut f64,
7270    amax: &mut f64,
7271    info: &mut i32,
7272) {
7273    ffi::dgeequb_(
7274        &m,
7275        &n,
7276        a.as_ptr(),
7277        &lda,
7278        r.as_mut_ptr(),
7279        c.as_mut_ptr(),
7280        rowcnd,
7281        colcnd,
7282        amax,
7283        info,
7284    )
7285}
7286
7287#[inline]
7288pub unsafe fn sgeequb(
7289    m: i32,
7290    n: i32,
7291    a: &[f32],
7292    lda: i32,
7293    r: &mut [f32],
7294    c: &mut [f32],
7295    rowcnd: &mut f32,
7296    colcnd: &mut f32,
7297    amax: &mut f32,
7298    info: &mut i32,
7299) {
7300    ffi::sgeequb_(
7301        &m,
7302        &n,
7303        a.as_ptr(),
7304        &lda,
7305        r.as_mut_ptr(),
7306        c.as_mut_ptr(),
7307        rowcnd,
7308        colcnd,
7309        amax,
7310        info,
7311    )
7312}
7313
7314#[inline]
7315pub unsafe fn zgeequb(
7316    m: i32,
7317    n: i32,
7318    a: &[c64],
7319    lda: i32,
7320    r: &mut [f64],
7321    c: &mut [f64],
7322    rowcnd: &mut f64,
7323    colcnd: &mut f64,
7324    amax: &mut f64,
7325    info: &mut i32,
7326) {
7327    ffi::zgeequb_(
7328        &m,
7329        &n,
7330        a.as_ptr() as *const _,
7331        &lda,
7332        r.as_mut_ptr(),
7333        c.as_mut_ptr(),
7334        rowcnd,
7335        colcnd,
7336        amax,
7337        info,
7338    )
7339}
7340
7341#[inline]
7342pub unsafe fn cgeequb(
7343    m: i32,
7344    n: i32,
7345    a: &[c32],
7346    lda: i32,
7347    r: &mut [f32],
7348    c: &mut [f32],
7349    rowcnd: &mut f32,
7350    colcnd: &mut f32,
7351    amax: &mut f32,
7352    info: &mut i32,
7353) {
7354    ffi::cgeequb_(
7355        &m,
7356        &n,
7357        a.as_ptr() as *const _,
7358        &lda,
7359        r.as_mut_ptr(),
7360        c.as_mut_ptr(),
7361        rowcnd,
7362        colcnd,
7363        amax,
7364        info,
7365    )
7366}
7367
7368#[inline]
7369pub unsafe fn sgbequ(
7370    m: i32,
7371    n: i32,
7372    kl: i32,
7373    ku: i32,
7374    ab: &[f32],
7375    ldab: i32,
7376    r: &mut [f32],
7377    c: &mut [f32],
7378    rowcnd: &mut f32,
7379    colcnd: &mut f32,
7380    amax: &mut f32,
7381    info: &mut i32,
7382) {
7383    ffi::sgbequ_(
7384        &m,
7385        &n,
7386        &kl,
7387        &ku,
7388        ab.as_ptr(),
7389        &ldab,
7390        r.as_mut_ptr(),
7391        c.as_mut_ptr(),
7392        rowcnd,
7393        colcnd,
7394        amax,
7395        info,
7396    )
7397}
7398
7399#[inline]
7400pub unsafe fn dgbequ(
7401    m: i32,
7402    n: i32,
7403    kl: i32,
7404    ku: i32,
7405    ab: &[f64],
7406    ldab: i32,
7407    r: &mut [f64],
7408    c: &mut [f64],
7409    rowcnd: &mut f64,
7410    colcnd: &mut f64,
7411    amax: &mut f64,
7412    info: &mut i32,
7413) {
7414    ffi::dgbequ_(
7415        &m,
7416        &n,
7417        &kl,
7418        &ku,
7419        ab.as_ptr(),
7420        &ldab,
7421        r.as_mut_ptr(),
7422        c.as_mut_ptr(),
7423        rowcnd,
7424        colcnd,
7425        amax,
7426        info,
7427    )
7428}
7429
7430#[inline]
7431pub unsafe fn cgbequ(
7432    m: i32,
7433    n: i32,
7434    kl: i32,
7435    ku: i32,
7436    ab: &[c32],
7437    ldab: i32,
7438    r: &mut [f32],
7439    c: &mut [f32],
7440    rowcnd: &mut f32,
7441    colcnd: &mut f32,
7442    amax: &mut f32,
7443    info: &mut i32,
7444) {
7445    ffi::cgbequ_(
7446        &m,
7447        &n,
7448        &kl,
7449        &ku,
7450        ab.as_ptr() as *const _,
7451        &ldab,
7452        r.as_mut_ptr(),
7453        c.as_mut_ptr(),
7454        rowcnd,
7455        colcnd,
7456        amax,
7457        info,
7458    )
7459}
7460
7461#[inline]
7462pub unsafe fn zgbequ(
7463    m: i32,
7464    n: i32,
7465    kl: i32,
7466    ku: i32,
7467    ab: &[c64],
7468    ldab: i32,
7469    r: &mut [f64],
7470    c: &mut [f64],
7471    rowcnd: &mut f64,
7472    colcnd: &mut f64,
7473    amax: &mut f64,
7474    info: &mut i32,
7475) {
7476    ffi::zgbequ_(
7477        &m,
7478        &n,
7479        &kl,
7480        &ku,
7481        ab.as_ptr() as *const _,
7482        &ldab,
7483        r.as_mut_ptr(),
7484        c.as_mut_ptr(),
7485        rowcnd,
7486        colcnd,
7487        amax,
7488        info,
7489    )
7490}
7491
7492#[inline]
7493pub unsafe fn dgbequb(
7494    m: i32,
7495    n: i32,
7496    kl: i32,
7497    ku: i32,
7498    ab: &[f64],
7499    ldab: i32,
7500    r: &mut [f64],
7501    c: &mut [f64],
7502    rowcnd: &mut f64,
7503    colcnd: &mut f64,
7504    amax: &mut f64,
7505    info: &mut i32,
7506) {
7507    ffi::dgbequb_(
7508        &m,
7509        &n,
7510        &kl,
7511        &ku,
7512        ab.as_ptr(),
7513        &ldab,
7514        r.as_mut_ptr(),
7515        c.as_mut_ptr(),
7516        rowcnd,
7517        colcnd,
7518        amax,
7519        info,
7520    )
7521}
7522
7523#[inline]
7524pub unsafe fn sgbequb(
7525    m: i32,
7526    n: i32,
7527    kl: i32,
7528    ku: i32,
7529    ab: &[f32],
7530    ldab: i32,
7531    r: &mut [f32],
7532    c: &mut [f32],
7533    rowcnd: &mut f32,
7534    colcnd: &mut f32,
7535    amax: &mut f32,
7536    info: &mut i32,
7537) {
7538    ffi::sgbequb_(
7539        &m,
7540        &n,
7541        &kl,
7542        &ku,
7543        ab.as_ptr(),
7544        &ldab,
7545        r.as_mut_ptr(),
7546        c.as_mut_ptr(),
7547        rowcnd,
7548        colcnd,
7549        amax,
7550        info,
7551    )
7552}
7553
7554#[inline]
7555pub unsafe fn zgbequb(
7556    m: i32,
7557    n: i32,
7558    kl: i32,
7559    ku: i32,
7560    ab: &[c64],
7561    ldab: i32,
7562    r: &mut [f64],
7563    c: &mut [f64],
7564    rowcnd: &mut f64,
7565    colcnd: &mut f64,
7566    amax: &mut f64,
7567    info: &mut i32,
7568) {
7569    ffi::zgbequb_(
7570        &m,
7571        &n,
7572        &kl,
7573        &ku,
7574        ab.as_ptr() as *const _,
7575        &ldab,
7576        r.as_mut_ptr(),
7577        c.as_mut_ptr(),
7578        rowcnd,
7579        colcnd,
7580        amax,
7581        info,
7582    )
7583}
7584
7585#[inline]
7586pub unsafe fn cgbequb(
7587    m: i32,
7588    n: i32,
7589    kl: i32,
7590    ku: i32,
7591    ab: &[c32],
7592    ldab: i32,
7593    r: &mut [f32],
7594    c: &mut [f32],
7595    rowcnd: &mut f32,
7596    colcnd: &mut f32,
7597    amax: &mut f32,
7598    info: &mut i32,
7599) {
7600    ffi::cgbequb_(
7601        &m,
7602        &n,
7603        &kl,
7604        &ku,
7605        ab.as_ptr() as *const _,
7606        &ldab,
7607        r.as_mut_ptr(),
7608        c.as_mut_ptr(),
7609        rowcnd,
7610        colcnd,
7611        amax,
7612        info,
7613    )
7614}
7615
7616#[inline]
7617pub unsafe fn spoequ(
7618    n: i32,
7619    a: &[f32],
7620    lda: i32,
7621    s: &mut [f32],
7622    scond: &mut [f32],
7623    amax: &mut f32,
7624    info: &mut i32,
7625) {
7626    ffi::spoequ_(
7627        &n,
7628        a.as_ptr(),
7629        &lda,
7630        s.as_mut_ptr(),
7631        scond.as_mut_ptr(),
7632        amax,
7633        info,
7634    )
7635}
7636
7637#[inline]
7638pub unsafe fn dpoequ(
7639    n: i32,
7640    a: &[f64],
7641    lda: i32,
7642    s: &mut [f64],
7643    scond: &mut [f64],
7644    amax: &mut f64,
7645    info: &mut i32,
7646) {
7647    ffi::dpoequ_(
7648        &n,
7649        a.as_ptr(),
7650        &lda,
7651        s.as_mut_ptr(),
7652        scond.as_mut_ptr(),
7653        amax,
7654        info,
7655    )
7656}
7657
7658#[inline]
7659pub unsafe fn cpoequ(
7660    n: i32,
7661    a: &[c32],
7662    lda: i32,
7663    s: &mut [f32],
7664    scond: &mut [f32],
7665    amax: &mut f32,
7666    info: &mut i32,
7667) {
7668    ffi::cpoequ_(
7669        &n,
7670        a.as_ptr() as *const _,
7671        &lda,
7672        s.as_mut_ptr(),
7673        scond.as_mut_ptr(),
7674        amax,
7675        info,
7676    )
7677}
7678
7679#[inline]
7680pub unsafe fn zpoequ(
7681    n: i32,
7682    a: &[c64],
7683    lda: i32,
7684    s: &mut [f64],
7685    scond: &mut [f64],
7686    amax: &mut f64,
7687    info: &mut i32,
7688) {
7689    ffi::zpoequ_(
7690        &n,
7691        a.as_ptr() as *const _,
7692        &lda,
7693        s.as_mut_ptr(),
7694        scond.as_mut_ptr(),
7695        amax,
7696        info,
7697    )
7698}
7699
7700#[inline]
7701pub unsafe fn dpoequb(
7702    n: i32,
7703    a: &[f64],
7704    lda: i32,
7705    s: &mut [f64],
7706    scond: &mut [f64],
7707    amax: &mut f64,
7708    info: &mut i32,
7709) {
7710    ffi::dpoequb_(
7711        &n,
7712        a.as_ptr(),
7713        &lda,
7714        s.as_mut_ptr(),
7715        scond.as_mut_ptr(),
7716        amax,
7717        info,
7718    )
7719}
7720
7721#[inline]
7722pub unsafe fn spoequb(
7723    n: i32,
7724    a: &[f32],
7725    lda: i32,
7726    s: &mut [f32],
7727    scond: &mut [f32],
7728    amax: &mut f32,
7729    info: &mut i32,
7730) {
7731    ffi::spoequb_(
7732        &n,
7733        a.as_ptr(),
7734        &lda,
7735        s.as_mut_ptr(),
7736        scond.as_mut_ptr(),
7737        amax,
7738        info,
7739    )
7740}
7741
7742#[inline]
7743pub unsafe fn zpoequb(
7744    n: i32,
7745    a: &[c64],
7746    lda: i32,
7747    s: &mut [f64],
7748    scond: &mut [f64],
7749    amax: &mut f64,
7750    info: &mut i32,
7751) {
7752    ffi::zpoequb_(
7753        &n,
7754        a.as_ptr() as *const _,
7755        &lda,
7756        s.as_mut_ptr(),
7757        scond.as_mut_ptr(),
7758        amax,
7759        info,
7760    )
7761}
7762
7763#[inline]
7764pub unsafe fn cpoequb(
7765    n: i32,
7766    a: &[c32],
7767    lda: i32,
7768    s: &mut [f32],
7769    scond: &mut [f32],
7770    amax: &mut f32,
7771    info: &mut i32,
7772) {
7773    ffi::cpoequb_(
7774        &n,
7775        a.as_ptr() as *const _,
7776        &lda,
7777        s.as_mut_ptr(),
7778        scond.as_mut_ptr(),
7779        amax,
7780        info,
7781    )
7782}
7783
7784#[inline]
7785pub unsafe fn sppequ(
7786    uplo: u8,
7787    n: i32,
7788    ap: &[f32],
7789    s: &mut [f32],
7790    scond: &mut [f32],
7791    amax: &mut f32,
7792    info: &mut i32,
7793) {
7794    ffi::sppequ_(
7795        &(uplo as c_char),
7796        &n,
7797        ap.as_ptr(),
7798        s.as_mut_ptr(),
7799        scond.as_mut_ptr(),
7800        amax,
7801        info,
7802    )
7803}
7804
7805#[inline]
7806pub unsafe fn dppequ(
7807    uplo: u8,
7808    n: i32,
7809    ap: &[f64],
7810    s: &mut [f64],
7811    scond: &mut [f64],
7812    amax: &mut f64,
7813    info: &mut i32,
7814) {
7815    ffi::dppequ_(
7816        &(uplo as c_char),
7817        &n,
7818        ap.as_ptr(),
7819        s.as_mut_ptr(),
7820        scond.as_mut_ptr(),
7821        amax,
7822        info,
7823    )
7824}
7825
7826#[inline]
7827pub unsafe fn cppequ(
7828    uplo: u8,
7829    n: i32,
7830    ap: &[c32],
7831    s: &mut [f32],
7832    scond: &mut [f32],
7833    amax: &mut f32,
7834    info: &mut i32,
7835) {
7836    ffi::cppequ_(
7837        &(uplo as c_char),
7838        &n,
7839        ap.as_ptr() as *const _,
7840        s.as_mut_ptr(),
7841        scond.as_mut_ptr(),
7842        amax,
7843        info,
7844    )
7845}
7846
7847#[inline]
7848pub unsafe fn zppequ(
7849    uplo: u8,
7850    n: i32,
7851    ap: &[c64],
7852    s: &mut [f64],
7853    scond: &mut [f64],
7854    amax: &mut f64,
7855    info: &mut i32,
7856) {
7857    ffi::zppequ_(
7858        &(uplo as c_char),
7859        &n,
7860        ap.as_ptr() as *const _,
7861        s.as_mut_ptr(),
7862        scond.as_mut_ptr(),
7863        amax,
7864        info,
7865    )
7866}
7867
7868#[inline]
7869pub unsafe fn spbequ(
7870    uplo: u8,
7871    n: i32,
7872    kd: i32,
7873    ab: &[f32],
7874    ldab: i32,
7875    s: &mut [f32],
7876    scond: &mut [f32],
7877    amax: &mut f32,
7878    info: &mut i32,
7879) {
7880    ffi::spbequ_(
7881        &(uplo as c_char),
7882        &n,
7883        &kd,
7884        ab.as_ptr(),
7885        &ldab,
7886        s.as_mut_ptr(),
7887        scond.as_mut_ptr(),
7888        amax,
7889        info,
7890    )
7891}
7892
7893#[inline]
7894pub unsafe fn dpbequ(
7895    uplo: u8,
7896    n: i32,
7897    kd: i32,
7898    ab: &[f64],
7899    ldab: i32,
7900    s: &mut [f64],
7901    scond: &mut [f64],
7902    amax: &mut f64,
7903    info: &mut i32,
7904) {
7905    ffi::dpbequ_(
7906        &(uplo as c_char),
7907        &n,
7908        &kd,
7909        ab.as_ptr(),
7910        &ldab,
7911        s.as_mut_ptr(),
7912        scond.as_mut_ptr(),
7913        amax,
7914        info,
7915    )
7916}
7917
7918#[inline]
7919pub unsafe fn cpbequ(
7920    uplo: u8,
7921    n: i32,
7922    kd: i32,
7923    ab: &[c32],
7924    ldab: i32,
7925    s: &mut [f32],
7926    scond: &mut [f32],
7927    amax: &mut f32,
7928    info: &mut i32,
7929) {
7930    ffi::cpbequ_(
7931        &(uplo as c_char),
7932        &n,
7933        &kd,
7934        ab.as_ptr() as *const _,
7935        &ldab,
7936        s.as_mut_ptr(),
7937        scond.as_mut_ptr(),
7938        amax,
7939        info,
7940    )
7941}
7942
7943#[inline]
7944pub unsafe fn zpbequ(
7945    uplo: u8,
7946    n: i32,
7947    kd: i32,
7948    ab: &[c64],
7949    ldab: i32,
7950    s: &mut [f64],
7951    scond: &mut [f64],
7952    amax: &mut f64,
7953    info: &mut i32,
7954) {
7955    ffi::zpbequ_(
7956        &(uplo as c_char),
7957        &n,
7958        &kd,
7959        ab.as_ptr() as *const _,
7960        &ldab,
7961        s.as_mut_ptr(),
7962        scond.as_mut_ptr(),
7963        amax,
7964        info,
7965    )
7966}
7967
7968#[inline]
7969pub unsafe fn dsyequb(
7970    uplo: u8,
7971    n: i32,
7972    a: &[f64],
7973    lda: i32,
7974    s: &mut [f64],
7975    scond: &mut [f64],
7976    amax: &mut f64,
7977    work: &mut [f64],
7978    info: &mut i32,
7979) {
7980    ffi::dsyequb_(
7981        &(uplo as c_char),
7982        &n,
7983        a.as_ptr(),
7984        &lda,
7985        s.as_mut_ptr(),
7986        scond.as_mut_ptr(),
7987        amax,
7988        work.as_mut_ptr(),
7989        info,
7990    )
7991}
7992
7993#[inline]
7994pub unsafe fn ssyequb(
7995    uplo: u8,
7996    n: i32,
7997    a: &[f32],
7998    lda: i32,
7999    s: &mut [f32],
8000    scond: &mut [f32],
8001    amax: &mut f32,
8002    work: &mut [f32],
8003    info: &mut i32,
8004) {
8005    ffi::ssyequb_(
8006        &(uplo as c_char),
8007        &n,
8008        a.as_ptr(),
8009        &lda,
8010        s.as_mut_ptr(),
8011        scond.as_mut_ptr(),
8012        amax,
8013        work.as_mut_ptr(),
8014        info,
8015    )
8016}
8017
8018#[inline]
8019pub unsafe fn zsyequb(
8020    uplo: u8,
8021    n: i32,
8022    a: &[c64],
8023    lda: i32,
8024    s: &mut [f64],
8025    scond: &mut [f64],
8026    amax: &mut f64,
8027    work: &mut [c64],
8028    info: &mut i32,
8029) {
8030    ffi::zsyequb_(
8031        &(uplo as c_char),
8032        &n,
8033        a.as_ptr() as *const _,
8034        &lda,
8035        s.as_mut_ptr(),
8036        scond.as_mut_ptr(),
8037        amax,
8038        work.as_mut_ptr() as *mut _,
8039        info,
8040    )
8041}
8042
8043#[inline]
8044pub unsafe fn csyequb(
8045    uplo: u8,
8046    n: i32,
8047    a: &[c32],
8048    lda: i32,
8049    s: &mut [f32],
8050    scond: &mut [f32],
8051    amax: &mut f32,
8052    work: &mut [c32],
8053    info: &mut i32,
8054) {
8055    ffi::csyequb_(
8056        &(uplo as c_char),
8057        &n,
8058        a.as_ptr() as *const _,
8059        &lda,
8060        s.as_mut_ptr(),
8061        scond.as_mut_ptr(),
8062        amax,
8063        work.as_mut_ptr() as *mut _,
8064        info,
8065    )
8066}
8067
8068#[inline]
8069pub unsafe fn zheequb(
8070    uplo: u8,
8071    n: i32,
8072    a: &[c64],
8073    lda: i32,
8074    s: &mut [f64],
8075    scond: &mut [f64],
8076    amax: &mut f64,
8077    work: &mut [c64],
8078    info: &mut i32,
8079) {
8080    ffi::zheequb_(
8081        &(uplo as c_char),
8082        &n,
8083        a.as_ptr() as *const _,
8084        &lda,
8085        s.as_mut_ptr(),
8086        scond.as_mut_ptr(),
8087        amax,
8088        work.as_mut_ptr() as *mut _,
8089        info,
8090    )
8091}
8092
8093#[inline]
8094pub unsafe fn cheequb(
8095    uplo: u8,
8096    n: i32,
8097    a: &[c32],
8098    lda: i32,
8099    s: &mut [f32],
8100    scond: &mut [f32],
8101    amax: &mut f32,
8102    work: &mut [c32],
8103    info: &mut i32,
8104) {
8105    ffi::cheequb_(
8106        &(uplo as c_char),
8107        &n,
8108        a.as_ptr() as *const _,
8109        &lda,
8110        s.as_mut_ptr(),
8111        scond.as_mut_ptr(),
8112        amax,
8113        work.as_mut_ptr() as *mut _,
8114        info,
8115    )
8116}
8117
8118#[inline]
8119pub unsafe fn sgesv(
8120    n: i32,
8121    nrhs: i32,
8122    a: &mut [f32],
8123    lda: i32,
8124    ipiv: &mut [i32],
8125    b: &mut [f32],
8126    ldb: i32,
8127    info: &mut i32,
8128) {
8129    ffi::sgesv_(
8130        &n,
8131        &nrhs,
8132        a.as_mut_ptr(),
8133        &lda,
8134        ipiv.as_mut_ptr(),
8135        b.as_mut_ptr(),
8136        &ldb,
8137        info,
8138    )
8139}
8140
8141#[inline]
8142pub unsafe fn dgesv(
8143    n: i32,
8144    nrhs: i32,
8145    a: &mut [f64],
8146    lda: i32,
8147    ipiv: &mut [i32],
8148    b: &mut [f64],
8149    ldb: i32,
8150    info: &mut i32,
8151) {
8152    ffi::dgesv_(
8153        &n,
8154        &nrhs,
8155        a.as_mut_ptr(),
8156        &lda,
8157        ipiv.as_mut_ptr(),
8158        b.as_mut_ptr(),
8159        &ldb,
8160        info,
8161    )
8162}
8163
8164#[inline]
8165pub unsafe fn cgesv(
8166    n: i32,
8167    nrhs: i32,
8168    a: &mut [c32],
8169    lda: i32,
8170    ipiv: &mut [i32],
8171    b: &mut [c32],
8172    ldb: i32,
8173    info: &mut i32,
8174) {
8175    ffi::cgesv_(
8176        &n,
8177        &nrhs,
8178        a.as_mut_ptr() as *mut _,
8179        &lda,
8180        ipiv.as_mut_ptr(),
8181        b.as_mut_ptr() as *mut _,
8182        &ldb,
8183        info,
8184    )
8185}
8186
8187#[inline]
8188pub unsafe fn zgesv(
8189    n: i32,
8190    nrhs: i32,
8191    a: &mut [c64],
8192    lda: i32,
8193    ipiv: &mut [i32],
8194    b: &mut [c64],
8195    ldb: i32,
8196    info: &mut i32,
8197) {
8198    ffi::zgesv_(
8199        &n,
8200        &nrhs,
8201        a.as_mut_ptr() as *mut _,
8202        &lda,
8203        ipiv.as_mut_ptr(),
8204        b.as_mut_ptr() as *mut _,
8205        &ldb,
8206        info,
8207    )
8208}
8209
8210#[inline]
8211pub unsafe fn dsgesv(
8212    n: i32,
8213    nrhs: i32,
8214    a: &mut [f64],
8215    lda: i32,
8216    ipiv: &mut [i32],
8217    b: &[f64],
8218    ldb: i32,
8219    x: &mut [f64],
8220    ldx: i32,
8221    work: &mut [f64],
8222    swork: &mut [f32],
8223    iter: &mut i32,
8224    info: &mut i32,
8225) {
8226    ffi::dsgesv_(
8227        &n,
8228        &nrhs,
8229        a.as_mut_ptr(),
8230        &lda,
8231        ipiv.as_mut_ptr(),
8232        b.as_ptr(),
8233        &ldb,
8234        x.as_mut_ptr(),
8235        &ldx,
8236        work.as_mut_ptr(),
8237        swork.as_mut_ptr(),
8238        iter,
8239        info,
8240    )
8241}
8242
8243#[inline]
8244pub unsafe fn zcgesv(
8245    n: i32,
8246    nrhs: i32,
8247    a: &mut [c64],
8248    lda: i32,
8249    ipiv: &mut [i32],
8250    b: &[c64],
8251    ldb: i32,
8252    x: &mut [c64],
8253    ldx: i32,
8254    work: &mut [c64],
8255    swork: &mut [c32],
8256    rwork: &mut [f64],
8257    iter: &mut i32,
8258    info: &mut i32,
8259) {
8260    ffi::zcgesv_(
8261        &n,
8262        &nrhs,
8263        a.as_mut_ptr() as *mut _,
8264        &lda,
8265        ipiv.as_mut_ptr(),
8266        b.as_ptr() as *const _,
8267        &ldb,
8268        x.as_mut_ptr() as *mut _,
8269        &ldx,
8270        work.as_mut_ptr() as *mut _,
8271        swork.as_mut_ptr() as *mut _,
8272        rwork.as_mut_ptr(),
8273        iter,
8274        info,
8275    )
8276}
8277
8278#[inline]
8279pub unsafe fn sgesvx(
8280    fact: u8,
8281    trans: u8,
8282    n: i32,
8283    nrhs: i32,
8284    a: &mut [f32],
8285    lda: i32,
8286    af: &mut [f32],
8287    ldaf: i32,
8288    ipiv: &mut [i32],
8289    equed: &mut u8,
8290    r: &mut [f32],
8291    c: &mut [f32],
8292    b: &mut [f32],
8293    ldb: i32,
8294    x: &mut [f32],
8295    ldx: i32,
8296    rcond: &mut f32,
8297    ferr: &mut [f32],
8298    berr: &mut [f32],
8299    work: &mut [f32],
8300    iwork: &mut [i32],
8301    info: &mut i32,
8302) {
8303    ffi::sgesvx_(
8304        &(fact as c_char),
8305        &(trans as c_char),
8306        &n,
8307        &nrhs,
8308        a.as_mut_ptr(),
8309        &lda,
8310        af.as_mut_ptr(),
8311        &ldaf,
8312        ipiv.as_mut_ptr(),
8313        equed as *mut _ as *mut _,
8314        r.as_mut_ptr(),
8315        c.as_mut_ptr(),
8316        b.as_mut_ptr(),
8317        &ldb,
8318        x.as_mut_ptr(),
8319        &ldx,
8320        rcond,
8321        ferr.as_mut_ptr(),
8322        berr.as_mut_ptr(),
8323        work.as_mut_ptr(),
8324        iwork.as_mut_ptr(),
8325        info,
8326    )
8327}
8328
8329#[inline]
8330pub unsafe fn dgesvx(
8331    fact: u8,
8332    trans: u8,
8333    n: i32,
8334    nrhs: i32,
8335    a: &mut [f64],
8336    lda: i32,
8337    af: &mut [f64],
8338    ldaf: i32,
8339    ipiv: &mut [i32],
8340    equed: &mut u8,
8341    r: &mut [f64],
8342    c: &mut [f64],
8343    b: &mut [f64],
8344    ldb: i32,
8345    x: &mut [f64],
8346    ldx: i32,
8347    rcond: &mut f64,
8348    ferr: &mut [f64],
8349    berr: &mut [f64],
8350    work: &mut [f64],
8351    iwork: &mut [i32],
8352    info: &mut i32,
8353) {
8354    ffi::dgesvx_(
8355        &(fact as c_char),
8356        &(trans as c_char),
8357        &n,
8358        &nrhs,
8359        a.as_mut_ptr(),
8360        &lda,
8361        af.as_mut_ptr(),
8362        &ldaf,
8363        ipiv.as_mut_ptr(),
8364        equed as *mut _ as *mut _,
8365        r.as_mut_ptr(),
8366        c.as_mut_ptr(),
8367        b.as_mut_ptr(),
8368        &ldb,
8369        x.as_mut_ptr(),
8370        &ldx,
8371        rcond,
8372        ferr.as_mut_ptr(),
8373        berr.as_mut_ptr(),
8374        work.as_mut_ptr(),
8375        iwork.as_mut_ptr(),
8376        info,
8377    )
8378}
8379
8380#[inline]
8381pub unsafe fn cgesvx(
8382    fact: u8,
8383    trans: u8,
8384    n: i32,
8385    nrhs: i32,
8386    a: &mut [c32],
8387    lda: i32,
8388    af: &mut [c32],
8389    ldaf: i32,
8390    ipiv: &mut [i32],
8391    equed: &mut u8,
8392    r: &mut [f32],
8393    c: &mut [f32],
8394    b: &mut [c32],
8395    ldb: i32,
8396    x: &mut [c32],
8397    ldx: i32,
8398    rcond: &mut f32,
8399    ferr: &mut [f32],
8400    berr: &mut [f32],
8401    work: &mut [c32],
8402    rwork: &mut [f32],
8403    info: &mut i32,
8404) {
8405    ffi::cgesvx_(
8406        &(fact as c_char),
8407        &(trans as c_char),
8408        &n,
8409        &nrhs,
8410        a.as_mut_ptr() as *mut _,
8411        &lda,
8412        af.as_mut_ptr() as *mut _,
8413        &ldaf,
8414        ipiv.as_mut_ptr(),
8415        equed as *mut _ as *mut _,
8416        r.as_mut_ptr(),
8417        c.as_mut_ptr(),
8418        b.as_mut_ptr() as *mut _,
8419        &ldb,
8420        x.as_mut_ptr() as *mut _,
8421        &ldx,
8422        rcond,
8423        ferr.as_mut_ptr(),
8424        berr.as_mut_ptr(),
8425        work.as_mut_ptr() as *mut _,
8426        rwork.as_mut_ptr(),
8427        info,
8428    )
8429}
8430
8431#[inline]
8432pub unsafe fn zgesvx(
8433    fact: u8,
8434    trans: u8,
8435    n: i32,
8436    nrhs: i32,
8437    a: &mut [c64],
8438    lda: i32,
8439    af: &mut [c64],
8440    ldaf: i32,
8441    ipiv: &mut [i32],
8442    equed: &mut u8,
8443    r: &mut [f64],
8444    c: &mut [f64],
8445    b: &mut [c64],
8446    ldb: i32,
8447    x: &mut [c64],
8448    ldx: i32,
8449    rcond: &mut f64,
8450    ferr: &mut [f64],
8451    berr: &mut [f64],
8452    work: &mut [c64],
8453    rwork: &mut [f64],
8454    info: &mut i32,
8455) {
8456    ffi::zgesvx_(
8457        &(fact as c_char),
8458        &(trans as c_char),
8459        &n,
8460        &nrhs,
8461        a.as_mut_ptr() as *mut _,
8462        &lda,
8463        af.as_mut_ptr() as *mut _,
8464        &ldaf,
8465        ipiv.as_mut_ptr(),
8466        equed as *mut _ as *mut _,
8467        r.as_mut_ptr(),
8468        c.as_mut_ptr(),
8469        b.as_mut_ptr() as *mut _,
8470        &ldb,
8471        x.as_mut_ptr() as *mut _,
8472        &ldx,
8473        rcond,
8474        ferr.as_mut_ptr(),
8475        berr.as_mut_ptr(),
8476        work.as_mut_ptr() as *mut _,
8477        rwork.as_mut_ptr(),
8478        info,
8479    )
8480}
8481
8482#[inline]
8483pub unsafe fn dgesvxx(
8484    fact: u8,
8485    trans: u8,
8486    n: i32,
8487    nrhs: i32,
8488    a: &mut [f64],
8489    lda: i32,
8490    af: &mut [f64],
8491    ldaf: i32,
8492    ipiv: &mut [i32],
8493    equed: &mut u8,
8494    r: &mut [f64],
8495    c: &mut [f64],
8496    b: &mut [f64],
8497    ldb: i32,
8498    x: &mut [f64],
8499    ldx: i32,
8500    rcond: &mut f64,
8501    rpvgrw: &mut f64,
8502    berr: &mut [f64],
8503    n_err_bnds: i32,
8504    err_bnds_norm: &mut [f64],
8505    err_bnds_comp: &mut [f64],
8506    nparams: &[i32],
8507    params: &mut [f64],
8508    work: &mut [f64],
8509    iwork: &mut [i32],
8510    info: &mut i32,
8511) {
8512    ffi::dgesvxx_(
8513        &(fact as c_char),
8514        &(trans as c_char),
8515        &n,
8516        &nrhs,
8517        a.as_mut_ptr(),
8518        &lda,
8519        af.as_mut_ptr(),
8520        &ldaf,
8521        ipiv.as_mut_ptr(),
8522        equed as *mut _ as *mut _,
8523        r.as_mut_ptr(),
8524        c.as_mut_ptr(),
8525        b.as_mut_ptr(),
8526        &ldb,
8527        x.as_mut_ptr(),
8528        &ldx,
8529        rcond,
8530        rpvgrw,
8531        berr.as_mut_ptr(),
8532        &n_err_bnds,
8533        err_bnds_norm.as_mut_ptr(),
8534        err_bnds_comp.as_mut_ptr(),
8535        nparams.as_ptr(),
8536        params.as_mut_ptr(),
8537        work.as_mut_ptr(),
8538        iwork.as_mut_ptr(),
8539        info,
8540    )
8541}
8542
8543#[inline]
8544pub unsafe fn sgesvxx(
8545    fact: u8,
8546    trans: u8,
8547    n: i32,
8548    nrhs: i32,
8549    a: &mut [f32],
8550    lda: i32,
8551    af: &mut [f32],
8552    ldaf: i32,
8553    ipiv: &mut [i32],
8554    equed: &mut u8,
8555    r: &mut [f32],
8556    c: &mut [f32],
8557    b: &mut [f32],
8558    ldb: i32,
8559    x: &mut [f32],
8560    ldx: i32,
8561    rcond: &mut f32,
8562    rpvgrw: &mut f32,
8563    berr: &mut [f32],
8564    n_err_bnds: i32,
8565    err_bnds_norm: &mut [f32],
8566    err_bnds_comp: &mut [f32],
8567    nparams: &[i32],
8568    params: &mut [f32],
8569    work: &mut [f32],
8570    iwork: &mut [i32],
8571    info: &mut i32,
8572) {
8573    ffi::sgesvxx_(
8574        &(fact as c_char),
8575        &(trans as c_char),
8576        &n,
8577        &nrhs,
8578        a.as_mut_ptr(),
8579        &lda,
8580        af.as_mut_ptr(),
8581        &ldaf,
8582        ipiv.as_mut_ptr(),
8583        equed as *mut _ as *mut _,
8584        r.as_mut_ptr(),
8585        c.as_mut_ptr(),
8586        b.as_mut_ptr(),
8587        &ldb,
8588        x.as_mut_ptr(),
8589        &ldx,
8590        rcond,
8591        rpvgrw,
8592        berr.as_mut_ptr(),
8593        &n_err_bnds,
8594        err_bnds_norm.as_mut_ptr(),
8595        err_bnds_comp.as_mut_ptr(),
8596        nparams.as_ptr(),
8597        params.as_mut_ptr(),
8598        work.as_mut_ptr(),
8599        iwork.as_mut_ptr(),
8600        info,
8601    )
8602}
8603
8604#[inline]
8605pub unsafe fn zgesvxx(
8606    fact: u8,
8607    trans: u8,
8608    n: i32,
8609    nrhs: i32,
8610    a: &mut [c64],
8611    lda: i32,
8612    af: &mut [c64],
8613    ldaf: i32,
8614    ipiv: &mut [i32],
8615    equed: &mut u8,
8616    r: &mut [f64],
8617    c: &mut [f64],
8618    b: &mut [c64],
8619    ldb: i32,
8620    x: &mut [c64],
8621    ldx: i32,
8622    rcond: &mut f64,
8623    rpvgrw: &mut f64,
8624    berr: &mut [f64],
8625    n_err_bnds: i32,
8626    err_bnds_norm: &mut [f64],
8627    err_bnds_comp: &mut [f64],
8628    nparams: &[i32],
8629    params: &mut [f64],
8630    work: &mut [c64],
8631    rwork: &mut [f64],
8632    info: &mut i32,
8633) {
8634    ffi::zgesvxx_(
8635        &(fact as c_char),
8636        &(trans as c_char),
8637        &n,
8638        &nrhs,
8639        a.as_mut_ptr() as *mut _,
8640        &lda,
8641        af.as_mut_ptr() as *mut _,
8642        &ldaf,
8643        ipiv.as_mut_ptr(),
8644        equed as *mut _ as *mut _,
8645        r.as_mut_ptr(),
8646        c.as_mut_ptr(),
8647        b.as_mut_ptr() as *mut _,
8648        &ldb,
8649        x.as_mut_ptr() as *mut _,
8650        &ldx,
8651        rcond,
8652        rpvgrw,
8653        berr.as_mut_ptr(),
8654        &n_err_bnds,
8655        err_bnds_norm.as_mut_ptr(),
8656        err_bnds_comp.as_mut_ptr(),
8657        nparams.as_ptr(),
8658        params.as_mut_ptr(),
8659        work.as_mut_ptr() as *mut _,
8660        rwork.as_mut_ptr(),
8661        info,
8662    )
8663}
8664
8665#[inline]
8666pub unsafe fn cgesvxx(
8667    fact: u8,
8668    trans: u8,
8669    n: i32,
8670    nrhs: i32,
8671    a: &mut [c32],
8672    lda: i32,
8673    af: &mut [c32],
8674    ldaf: i32,
8675    ipiv: &mut [i32],
8676    equed: &mut u8,
8677    r: &mut [f32],
8678    c: &mut [f32],
8679    b: &mut [c32],
8680    ldb: i32,
8681    x: &mut [c32],
8682    ldx: i32,
8683    rcond: &mut f32,
8684    rpvgrw: &mut f32,
8685    berr: &mut [f32],
8686    n_err_bnds: i32,
8687    err_bnds_norm: &mut [f32],
8688    err_bnds_comp: &mut [f32],
8689    nparams: &[i32],
8690    params: &mut [f32],
8691    work: &mut [c32],
8692    rwork: &mut [f32],
8693    info: &mut i32,
8694) {
8695    ffi::cgesvxx_(
8696        &(fact as c_char),
8697        &(trans as c_char),
8698        &n,
8699        &nrhs,
8700        a.as_mut_ptr() as *mut _,
8701        &lda,
8702        af.as_mut_ptr() as *mut _,
8703        &ldaf,
8704        ipiv.as_mut_ptr(),
8705        equed as *mut _ as *mut _,
8706        r.as_mut_ptr(),
8707        c.as_mut_ptr(),
8708        b.as_mut_ptr() as *mut _,
8709        &ldb,
8710        x.as_mut_ptr() as *mut _,
8711        &ldx,
8712        rcond,
8713        rpvgrw,
8714        berr.as_mut_ptr(),
8715        &n_err_bnds,
8716        err_bnds_norm.as_mut_ptr(),
8717        err_bnds_comp.as_mut_ptr(),
8718        nparams.as_ptr(),
8719        params.as_mut_ptr(),
8720        work.as_mut_ptr() as *mut _,
8721        rwork.as_mut_ptr(),
8722        info,
8723    )
8724}
8725
8726#[inline]
8727pub unsafe fn sgbsv(
8728    n: i32,
8729    kl: i32,
8730    ku: i32,
8731    nrhs: i32,
8732    ab: &mut [f32],
8733    ldab: i32,
8734    ipiv: &mut [i32],
8735    b: &mut [f32],
8736    ldb: i32,
8737    info: &mut i32,
8738) {
8739    ffi::sgbsv_(
8740        &n,
8741        &kl,
8742        &ku,
8743        &nrhs,
8744        ab.as_mut_ptr(),
8745        &ldab,
8746        ipiv.as_mut_ptr(),
8747        b.as_mut_ptr(),
8748        &ldb,
8749        info,
8750    )
8751}
8752
8753#[inline]
8754pub unsafe fn dgbsv(
8755    n: i32,
8756    kl: i32,
8757    ku: i32,
8758    nrhs: i32,
8759    ab: &mut [f64],
8760    ldab: i32,
8761    ipiv: &mut [i32],
8762    b: &mut [f64],
8763    ldb: i32,
8764    info: &mut i32,
8765) {
8766    ffi::dgbsv_(
8767        &n,
8768        &kl,
8769        &ku,
8770        &nrhs,
8771        ab.as_mut_ptr(),
8772        &ldab,
8773        ipiv.as_mut_ptr(),
8774        b.as_mut_ptr(),
8775        &ldb,
8776        info,
8777    )
8778}
8779
8780#[inline]
8781pub unsafe fn cgbsv(
8782    n: i32,
8783    kl: i32,
8784    ku: i32,
8785    nrhs: i32,
8786    ab: &mut [c32],
8787    ldab: i32,
8788    ipiv: &mut [i32],
8789    b: &mut [c32],
8790    ldb: i32,
8791    info: &mut i32,
8792) {
8793    ffi::cgbsv_(
8794        &n,
8795        &kl,
8796        &ku,
8797        &nrhs,
8798        ab.as_mut_ptr() as *mut _,
8799        &ldab,
8800        ipiv.as_mut_ptr(),
8801        b.as_mut_ptr() as *mut _,
8802        &ldb,
8803        info,
8804    )
8805}
8806
8807#[inline]
8808pub unsafe fn zgbsv(
8809    n: i32,
8810    kl: i32,
8811    ku: i32,
8812    nrhs: i32,
8813    ab: &mut [c64],
8814    ldab: i32,
8815    ipiv: &mut [i32],
8816    b: &mut [c64],
8817    ldb: i32,
8818    info: &mut i32,
8819) {
8820    ffi::zgbsv_(
8821        &n,
8822        &kl,
8823        &ku,
8824        &nrhs,
8825        ab.as_mut_ptr() as *mut _,
8826        &ldab,
8827        ipiv.as_mut_ptr(),
8828        b.as_mut_ptr() as *mut _,
8829        &ldb,
8830        info,
8831    )
8832}
8833
8834#[inline]
8835pub unsafe fn sgbsvx(
8836    fact: u8,
8837    trans: u8,
8838    n: i32,
8839    kl: i32,
8840    ku: i32,
8841    nrhs: i32,
8842    ab: &mut [f32],
8843    ldab: i32,
8844    afb: &mut [f32],
8845    ldafb: i32,
8846    ipiv: &mut [i32],
8847    equed: &mut u8,
8848    r: &mut [f32],
8849    c: &mut [f32],
8850    b: &mut [f32],
8851    ldb: i32,
8852    x: &mut [f32],
8853    ldx: i32,
8854    rcond: &mut f32,
8855    ferr: &mut [f32],
8856    berr: &mut [f32],
8857    work: &mut [f32],
8858    iwork: &mut [i32],
8859    info: &mut i32,
8860) {
8861    ffi::sgbsvx_(
8862        &(fact as c_char),
8863        &(trans as c_char),
8864        &n,
8865        &kl,
8866        &ku,
8867        &nrhs,
8868        ab.as_mut_ptr(),
8869        &ldab,
8870        afb.as_mut_ptr(),
8871        &ldafb,
8872        ipiv.as_mut_ptr(),
8873        equed as *mut _ as *mut _,
8874        r.as_mut_ptr(),
8875        c.as_mut_ptr(),
8876        b.as_mut_ptr(),
8877        &ldb,
8878        x.as_mut_ptr(),
8879        &ldx,
8880        rcond,
8881        ferr.as_mut_ptr(),
8882        berr.as_mut_ptr(),
8883        work.as_mut_ptr(),
8884        iwork.as_mut_ptr(),
8885        info,
8886    )
8887}
8888
8889#[inline]
8890pub unsafe fn dgbsvx(
8891    fact: u8,
8892    trans: u8,
8893    n: i32,
8894    kl: i32,
8895    ku: i32,
8896    nrhs: i32,
8897    ab: &mut [f64],
8898    ldab: i32,
8899    afb: &mut [f64],
8900    ldafb: i32,
8901    ipiv: &mut [i32],
8902    equed: &mut u8,
8903    r: &mut [f64],
8904    c: &mut [f64],
8905    b: &mut [f64],
8906    ldb: i32,
8907    x: &mut [f64],
8908    ldx: i32,
8909    rcond: &mut f64,
8910    ferr: &mut [f64],
8911    berr: &mut [f64],
8912    work: &mut [f64],
8913    iwork: &mut [i32],
8914    info: &mut i32,
8915) {
8916    ffi::dgbsvx_(
8917        &(fact as c_char),
8918        &(trans as c_char),
8919        &n,
8920        &kl,
8921        &ku,
8922        &nrhs,
8923        ab.as_mut_ptr(),
8924        &ldab,
8925        afb.as_mut_ptr(),
8926        &ldafb,
8927        ipiv.as_mut_ptr(),
8928        equed as *mut _ as *mut _,
8929        r.as_mut_ptr(),
8930        c.as_mut_ptr(),
8931        b.as_mut_ptr(),
8932        &ldb,
8933        x.as_mut_ptr(),
8934        &ldx,
8935        rcond,
8936        ferr.as_mut_ptr(),
8937        berr.as_mut_ptr(),
8938        work.as_mut_ptr(),
8939        iwork.as_mut_ptr(),
8940        info,
8941    )
8942}
8943
8944#[inline]
8945pub unsafe fn cgbsvx(
8946    fact: u8,
8947    trans: u8,
8948    n: i32,
8949    kl: i32,
8950    ku: i32,
8951    nrhs: i32,
8952    ab: &mut [c32],
8953    ldab: i32,
8954    afb: &mut [c32],
8955    ldafb: i32,
8956    ipiv: &mut [i32],
8957    equed: &mut u8,
8958    r: &mut [f32],
8959    c: &mut [f32],
8960    b: &mut [c32],
8961    ldb: i32,
8962    x: &mut [c32],
8963    ldx: i32,
8964    rcond: &mut f32,
8965    ferr: &mut [f32],
8966    berr: &mut [f32],
8967    work: &mut [c32],
8968    rwork: &mut [f32],
8969    info: &mut i32,
8970) {
8971    ffi::cgbsvx_(
8972        &(fact as c_char),
8973        &(trans as c_char),
8974        &n,
8975        &kl,
8976        &ku,
8977        &nrhs,
8978        ab.as_mut_ptr() as *mut _,
8979        &ldab,
8980        afb.as_mut_ptr() as *mut _,
8981        &ldafb,
8982        ipiv.as_mut_ptr(),
8983        equed as *mut _ as *mut _,
8984        r.as_mut_ptr(),
8985        c.as_mut_ptr(),
8986        b.as_mut_ptr() as *mut _,
8987        &ldb,
8988        x.as_mut_ptr() as *mut _,
8989        &ldx,
8990        rcond,
8991        ferr.as_mut_ptr(),
8992        berr.as_mut_ptr(),
8993        work.as_mut_ptr() as *mut _,
8994        rwork.as_mut_ptr(),
8995        info,
8996    )
8997}
8998
8999#[inline]
9000pub unsafe fn zgbsvx(
9001    fact: u8,
9002    trans: u8,
9003    n: i32,
9004    kl: i32,
9005    ku: i32,
9006    nrhs: i32,
9007    ab: &mut [c64],
9008    ldab: i32,
9009    afb: &mut [c64],
9010    ldafb: i32,
9011    ipiv: &mut [i32],
9012    equed: &mut u8,
9013    r: &mut [f64],
9014    c: &mut [f64],
9015    b: &mut [c64],
9016    ldb: i32,
9017    x: &mut [c64],
9018    ldx: i32,
9019    rcond: &mut f64,
9020    ferr: &mut [f64],
9021    berr: &mut [f64],
9022    work: &mut [c64],
9023    rwork: &mut [f64],
9024    info: &mut i32,
9025) {
9026    ffi::zgbsvx_(
9027        &(fact as c_char),
9028        &(trans as c_char),
9029        &n,
9030        &kl,
9031        &ku,
9032        &nrhs,
9033        ab.as_mut_ptr() as *mut _,
9034        &ldab,
9035        afb.as_mut_ptr() as *mut _,
9036        &ldafb,
9037        ipiv.as_mut_ptr(),
9038        equed as *mut _ as *mut _,
9039        r.as_mut_ptr(),
9040        c.as_mut_ptr(),
9041        b.as_mut_ptr() as *mut _,
9042        &ldb,
9043        x.as_mut_ptr() as *mut _,
9044        &ldx,
9045        rcond,
9046        ferr.as_mut_ptr(),
9047        berr.as_mut_ptr(),
9048        work.as_mut_ptr() as *mut _,
9049        rwork.as_mut_ptr(),
9050        info,
9051    )
9052}
9053
9054#[inline]
9055pub unsafe fn dgbsvxx(
9056    fact: u8,
9057    trans: u8,
9058    n: i32,
9059    kl: i32,
9060    ku: i32,
9061    nrhs: i32,
9062    ab: &mut [f64],
9063    ldab: i32,
9064    afb: &mut [f64],
9065    ldafb: i32,
9066    ipiv: &mut [i32],
9067    equed: &mut u8,
9068    r: &mut [f64],
9069    c: &mut [f64],
9070    b: &mut [f64],
9071    ldb: i32,
9072    x: &mut [f64],
9073    ldx: i32,
9074    rcond: &mut f64,
9075    rpvgrw: &mut f64,
9076    berr: &mut [f64],
9077    n_err_bnds: i32,
9078    err_bnds_norm: &mut [f64],
9079    err_bnds_comp: &mut [f64],
9080    nparams: &[i32],
9081    params: &mut [f64],
9082    work: &mut [f64],
9083    iwork: &mut [i32],
9084    info: &mut i32,
9085) {
9086    ffi::dgbsvxx_(
9087        &(fact as c_char),
9088        &(trans as c_char),
9089        &n,
9090        &kl,
9091        &ku,
9092        &nrhs,
9093        ab.as_mut_ptr(),
9094        &ldab,
9095        afb.as_mut_ptr(),
9096        &ldafb,
9097        ipiv.as_mut_ptr(),
9098        equed as *mut _ as *mut _,
9099        r.as_mut_ptr(),
9100        c.as_mut_ptr(),
9101        b.as_mut_ptr(),
9102        &ldb,
9103        x.as_mut_ptr(),
9104        &ldx,
9105        rcond,
9106        rpvgrw,
9107        berr.as_mut_ptr(),
9108        &n_err_bnds,
9109        err_bnds_norm.as_mut_ptr(),
9110        err_bnds_comp.as_mut_ptr(),
9111        nparams.as_ptr(),
9112        params.as_mut_ptr(),
9113        work.as_mut_ptr(),
9114        iwork.as_mut_ptr(),
9115        info,
9116    )
9117}
9118
9119#[inline]
9120pub unsafe fn sgbsvxx(
9121    fact: u8,
9122    trans: u8,
9123    n: i32,
9124    kl: i32,
9125    ku: i32,
9126    nrhs: i32,
9127    ab: &mut [f32],
9128    ldab: i32,
9129    afb: &mut [f32],
9130    ldafb: i32,
9131    ipiv: &mut [i32],
9132    equed: &mut u8,
9133    r: &mut [f32],
9134    c: &mut [f32],
9135    b: &mut [f32],
9136    ldb: i32,
9137    x: &mut [f32],
9138    ldx: i32,
9139    rcond: &mut f32,
9140    rpvgrw: &mut f32,
9141    berr: &mut [f32],
9142    n_err_bnds: i32,
9143    err_bnds_norm: &mut [f32],
9144    err_bnds_comp: &mut [f32],
9145    nparams: &[i32],
9146    params: &mut [f32],
9147    work: &mut [f32],
9148    iwork: &mut [i32],
9149    info: &mut i32,
9150) {
9151    ffi::sgbsvxx_(
9152        &(fact as c_char),
9153        &(trans as c_char),
9154        &n,
9155        &kl,
9156        &ku,
9157        &nrhs,
9158        ab.as_mut_ptr(),
9159        &ldab,
9160        afb.as_mut_ptr(),
9161        &ldafb,
9162        ipiv.as_mut_ptr(),
9163        equed as *mut _ as *mut _,
9164        r.as_mut_ptr(),
9165        c.as_mut_ptr(),
9166        b.as_mut_ptr(),
9167        &ldb,
9168        x.as_mut_ptr(),
9169        &ldx,
9170        rcond,
9171        rpvgrw,
9172        berr.as_mut_ptr(),
9173        &n_err_bnds,
9174        err_bnds_norm.as_mut_ptr(),
9175        err_bnds_comp.as_mut_ptr(),
9176        nparams.as_ptr(),
9177        params.as_mut_ptr(),
9178        work.as_mut_ptr(),
9179        iwork.as_mut_ptr(),
9180        info,
9181    )
9182}
9183
9184#[inline]
9185pub unsafe fn zgbsvxx(
9186    fact: u8,
9187    trans: u8,
9188    n: i32,
9189    kl: i32,
9190    ku: i32,
9191    nrhs: i32,
9192    ab: &mut [c64],
9193    ldab: i32,
9194    afb: &mut [c64],
9195    ldafb: i32,
9196    ipiv: &mut [i32],
9197    equed: &mut u8,
9198    r: &mut [f64],
9199    c: &mut [f64],
9200    b: &mut [c64],
9201    ldb: i32,
9202    x: &mut [c64],
9203    ldx: i32,
9204    rcond: &mut f64,
9205    rpvgrw: &mut f64,
9206    berr: &mut [f64],
9207    n_err_bnds: i32,
9208    err_bnds_norm: &mut [f64],
9209    err_bnds_comp: &mut [f64],
9210    nparams: &[i32],
9211    params: &mut [f64],
9212    work: &mut [c64],
9213    rwork: &mut [f64],
9214    info: &mut i32,
9215) {
9216    ffi::zgbsvxx_(
9217        &(fact as c_char),
9218        &(trans as c_char),
9219        &n,
9220        &kl,
9221        &ku,
9222        &nrhs,
9223        ab.as_mut_ptr() as *mut _,
9224        &ldab,
9225        afb.as_mut_ptr() as *mut _,
9226        &ldafb,
9227        ipiv.as_mut_ptr(),
9228        equed as *mut _ as *mut _,
9229        r.as_mut_ptr(),
9230        c.as_mut_ptr(),
9231        b.as_mut_ptr() as *mut _,
9232        &ldb,
9233        x.as_mut_ptr() as *mut _,
9234        &ldx,
9235        rcond,
9236        rpvgrw,
9237        berr.as_mut_ptr(),
9238        &n_err_bnds,
9239        err_bnds_norm.as_mut_ptr(),
9240        err_bnds_comp.as_mut_ptr(),
9241        nparams.as_ptr(),
9242        params.as_mut_ptr(),
9243        work.as_mut_ptr() as *mut _,
9244        rwork.as_mut_ptr(),
9245        info,
9246    )
9247}
9248
9249#[inline]
9250pub unsafe fn cgbsvxx(
9251    fact: u8,
9252    trans: u8,
9253    n: i32,
9254    kl: i32,
9255    ku: i32,
9256    nrhs: i32,
9257    ab: &mut [c32],
9258    ldab: i32,
9259    afb: &mut [c32],
9260    ldafb: i32,
9261    ipiv: &mut [i32],
9262    equed: &mut u8,
9263    r: &mut [f32],
9264    c: &mut [f32],
9265    b: &mut [c32],
9266    ldb: i32,
9267    x: &mut [c32],
9268    ldx: i32,
9269    rcond: &mut f32,
9270    rpvgrw: &mut f32,
9271    berr: &mut [f32],
9272    n_err_bnds: i32,
9273    err_bnds_norm: &mut [f32],
9274    err_bnds_comp: &mut [f32],
9275    nparams: &[i32],
9276    params: &mut [f32],
9277    work: &mut [c32],
9278    rwork: &mut [f32],
9279    info: &mut i32,
9280) {
9281    ffi::cgbsvxx_(
9282        &(fact as c_char),
9283        &(trans as c_char),
9284        &n,
9285        &kl,
9286        &ku,
9287        &nrhs,
9288        ab.as_mut_ptr() as *mut _,
9289        &ldab,
9290        afb.as_mut_ptr() as *mut _,
9291        &ldafb,
9292        ipiv.as_mut_ptr(),
9293        equed as *mut _ as *mut _,
9294        r.as_mut_ptr(),
9295        c.as_mut_ptr(),
9296        b.as_mut_ptr() as *mut _,
9297        &ldb,
9298        x.as_mut_ptr() as *mut _,
9299        &ldx,
9300        rcond,
9301        rpvgrw,
9302        berr.as_mut_ptr(),
9303        &n_err_bnds,
9304        err_bnds_norm.as_mut_ptr(),
9305        err_bnds_comp.as_mut_ptr(),
9306        nparams.as_ptr(),
9307        params.as_mut_ptr(),
9308        work.as_mut_ptr() as *mut _,
9309        rwork.as_mut_ptr(),
9310        info,
9311    )
9312}
9313
9314#[inline]
9315pub unsafe fn sgtsv(
9316    n: i32,
9317    nrhs: i32,
9318    dl: &mut [f32],
9319    d: &mut [f32],
9320    du: &mut [f32],
9321    b: &mut [f32],
9322    ldb: i32,
9323    info: &mut i32,
9324) {
9325    ffi::sgtsv_(
9326        &n,
9327        &nrhs,
9328        dl.as_mut_ptr(),
9329        d.as_mut_ptr(),
9330        du.as_mut_ptr(),
9331        b.as_mut_ptr(),
9332        &ldb,
9333        info,
9334    )
9335}
9336
9337#[inline]
9338pub unsafe fn dgtsv(
9339    n: i32,
9340    nrhs: i32,
9341    dl: &mut [f64],
9342    d: &mut [f64],
9343    du: &mut [f64],
9344    b: &mut [f64],
9345    ldb: i32,
9346    info: &mut i32,
9347) {
9348    ffi::dgtsv_(
9349        &n,
9350        &nrhs,
9351        dl.as_mut_ptr(),
9352        d.as_mut_ptr(),
9353        du.as_mut_ptr(),
9354        b.as_mut_ptr(),
9355        &ldb,
9356        info,
9357    )
9358}
9359
9360#[inline]
9361pub unsafe fn cgtsv(
9362    n: i32,
9363    nrhs: i32,
9364    dl: &mut [c32],
9365    d: &mut [c32],
9366    du: &mut [c32],
9367    b: &mut [c32],
9368    ldb: i32,
9369    info: &mut i32,
9370) {
9371    ffi::cgtsv_(
9372        &n,
9373        &nrhs,
9374        dl.as_mut_ptr() as *mut _,
9375        d.as_mut_ptr() as *mut _,
9376        du.as_mut_ptr() as *mut _,
9377        b.as_mut_ptr() as *mut _,
9378        &ldb,
9379        info,
9380    )
9381}
9382
9383#[inline]
9384pub unsafe fn zgtsv(
9385    n: i32,
9386    nrhs: i32,
9387    dl: &mut [c64],
9388    d: &mut [c64],
9389    du: &mut [c64],
9390    b: &mut [c64],
9391    ldb: i32,
9392    info: &mut i32,
9393) {
9394    ffi::zgtsv_(
9395        &n,
9396        &nrhs,
9397        dl.as_mut_ptr() as *mut _,
9398        d.as_mut_ptr() as *mut _,
9399        du.as_mut_ptr() as *mut _,
9400        b.as_mut_ptr() as *mut _,
9401        &ldb,
9402        info,
9403    )
9404}
9405
9406#[inline]
9407pub unsafe fn sgtsvx(
9408    fact: u8,
9409    trans: u8,
9410    n: i32,
9411    nrhs: i32,
9412    dl: &[f32],
9413    d: &[f32],
9414    du: &[f32],
9415    dlf: &mut [f32],
9416    df: &mut [f32],
9417    duf: &mut [f32],
9418    du2: &mut [f32],
9419    ipiv: &mut [i32],
9420    b: &[f32],
9421    ldb: i32,
9422    x: &mut [f32],
9423    ldx: i32,
9424    rcond: &mut f32,
9425    ferr: &mut [f32],
9426    berr: &mut [f32],
9427    work: &mut [f32],
9428    iwork: &mut [i32],
9429    info: &mut i32,
9430) {
9431    ffi::sgtsvx_(
9432        &(fact as c_char),
9433        &(trans as c_char),
9434        &n,
9435        &nrhs,
9436        dl.as_ptr(),
9437        d.as_ptr(),
9438        du.as_ptr(),
9439        dlf.as_mut_ptr(),
9440        df.as_mut_ptr(),
9441        duf.as_mut_ptr(),
9442        du2.as_mut_ptr(),
9443        ipiv.as_mut_ptr(),
9444        b.as_ptr(),
9445        &ldb,
9446        x.as_mut_ptr(),
9447        &ldx,
9448        rcond,
9449        ferr.as_mut_ptr(),
9450        berr.as_mut_ptr(),
9451        work.as_mut_ptr(),
9452        iwork.as_mut_ptr(),
9453        info,
9454    )
9455}
9456
9457#[inline]
9458pub unsafe fn dgtsvx(
9459    fact: u8,
9460    trans: u8,
9461    n: i32,
9462    nrhs: i32,
9463    dl: &[f64],
9464    d: &[f64],
9465    du: &[f64],
9466    dlf: &mut [f64],
9467    df: &mut [f64],
9468    duf: &mut [f64],
9469    du2: &mut [f64],
9470    ipiv: &mut [i32],
9471    b: &[f64],
9472    ldb: i32,
9473    x: &mut [f64],
9474    ldx: i32,
9475    rcond: &mut f64,
9476    ferr: &mut [f64],
9477    berr: &mut [f64],
9478    work: &mut [f64],
9479    iwork: &mut [i32],
9480    info: &mut i32,
9481) {
9482    ffi::dgtsvx_(
9483        &(fact as c_char),
9484        &(trans as c_char),
9485        &n,
9486        &nrhs,
9487        dl.as_ptr(),
9488        d.as_ptr(),
9489        du.as_ptr(),
9490        dlf.as_mut_ptr(),
9491        df.as_mut_ptr(),
9492        duf.as_mut_ptr(),
9493        du2.as_mut_ptr(),
9494        ipiv.as_mut_ptr(),
9495        b.as_ptr(),
9496        &ldb,
9497        x.as_mut_ptr(),
9498        &ldx,
9499        rcond,
9500        ferr.as_mut_ptr(),
9501        berr.as_mut_ptr(),
9502        work.as_mut_ptr(),
9503        iwork.as_mut_ptr(),
9504        info,
9505    )
9506}
9507
9508#[inline]
9509pub unsafe fn cgtsvx(
9510    fact: u8,
9511    trans: u8,
9512    n: i32,
9513    nrhs: i32,
9514    dl: &[c32],
9515    d: &[c32],
9516    du: &[c32],
9517    dlf: &mut [c32],
9518    df: &mut [c32],
9519    duf: &mut [c32],
9520    du2: &mut [c32],
9521    ipiv: &mut [i32],
9522    b: &[c32],
9523    ldb: i32,
9524    x: &mut [c32],
9525    ldx: i32,
9526    rcond: &mut f32,
9527    ferr: &mut [f32],
9528    berr: &mut [f32],
9529    work: &mut [c32],
9530    rwork: &mut [f32],
9531    info: &mut i32,
9532) {
9533    ffi::cgtsvx_(
9534        &(fact as c_char),
9535        &(trans as c_char),
9536        &n,
9537        &nrhs,
9538        dl.as_ptr() as *const _,
9539        d.as_ptr() as *const _,
9540        du.as_ptr() as *const _,
9541        dlf.as_mut_ptr() as *mut _,
9542        df.as_mut_ptr() as *mut _,
9543        duf.as_mut_ptr() as *mut _,
9544        du2.as_mut_ptr() as *mut _,
9545        ipiv.as_mut_ptr(),
9546        b.as_ptr() as *const _,
9547        &ldb,
9548        x.as_mut_ptr() as *mut _,
9549        &ldx,
9550        rcond,
9551        ferr.as_mut_ptr(),
9552        berr.as_mut_ptr(),
9553        work.as_mut_ptr() as *mut _,
9554        rwork.as_mut_ptr(),
9555        info,
9556    )
9557}
9558
9559#[inline]
9560pub unsafe fn zgtsvx(
9561    fact: u8,
9562    trans: u8,
9563    n: i32,
9564    nrhs: i32,
9565    dl: &[c64],
9566    d: &[c64],
9567    du: &[c64],
9568    dlf: &mut [c64],
9569    df: &mut [c64],
9570    duf: &mut [c64],
9571    du2: &mut [c64],
9572    ipiv: &mut [i32],
9573    b: &[c64],
9574    ldb: i32,
9575    x: &mut [c64],
9576    ldx: i32,
9577    rcond: &mut f64,
9578    ferr: &mut [f64],
9579    berr: &mut [f64],
9580    work: &mut [c64],
9581    rwork: &mut [f64],
9582    info: &mut i32,
9583) {
9584    ffi::zgtsvx_(
9585        &(fact as c_char),
9586        &(trans as c_char),
9587        &n,
9588        &nrhs,
9589        dl.as_ptr() as *const _,
9590        d.as_ptr() as *const _,
9591        du.as_ptr() as *const _,
9592        dlf.as_mut_ptr() as *mut _,
9593        df.as_mut_ptr() as *mut _,
9594        duf.as_mut_ptr() as *mut _,
9595        du2.as_mut_ptr() as *mut _,
9596        ipiv.as_mut_ptr(),
9597        b.as_ptr() as *const _,
9598        &ldb,
9599        x.as_mut_ptr() as *mut _,
9600        &ldx,
9601        rcond,
9602        ferr.as_mut_ptr(),
9603        berr.as_mut_ptr(),
9604        work.as_mut_ptr() as *mut _,
9605        rwork.as_mut_ptr(),
9606        info,
9607    )
9608}
9609
9610#[inline]
9611pub unsafe fn sposv(
9612    uplo: u8,
9613    n: i32,
9614    nrhs: i32,
9615    a: &mut [f32],
9616    lda: i32,
9617    b: &mut [f32],
9618    ldb: i32,
9619    info: &mut i32,
9620) {
9621    ffi::sposv_(
9622        &(uplo as c_char),
9623        &n,
9624        &nrhs,
9625        a.as_mut_ptr(),
9626        &lda,
9627        b.as_mut_ptr(),
9628        &ldb,
9629        info,
9630    )
9631}
9632
9633#[inline]
9634pub unsafe fn dposv(
9635    uplo: u8,
9636    n: i32,
9637    nrhs: i32,
9638    a: &mut [f64],
9639    lda: i32,
9640    b: &mut [f64],
9641    ldb: i32,
9642    info: &mut i32,
9643) {
9644    ffi::dposv_(
9645        &(uplo as c_char),
9646        &n,
9647        &nrhs,
9648        a.as_mut_ptr(),
9649        &lda,
9650        b.as_mut_ptr(),
9651        &ldb,
9652        info,
9653    )
9654}
9655
9656#[inline]
9657pub unsafe fn cposv(
9658    uplo: u8,
9659    n: i32,
9660    nrhs: i32,
9661    a: &mut [c32],
9662    lda: i32,
9663    b: &mut [c32],
9664    ldb: i32,
9665    info: &mut i32,
9666) {
9667    ffi::cposv_(
9668        &(uplo as c_char),
9669        &n,
9670        &nrhs,
9671        a.as_mut_ptr() as *mut _,
9672        &lda,
9673        b.as_mut_ptr() as *mut _,
9674        &ldb,
9675        info,
9676    )
9677}
9678
9679#[inline]
9680pub unsafe fn zposv(
9681    uplo: u8,
9682    n: i32,
9683    nrhs: i32,
9684    a: &mut [c64],
9685    lda: i32,
9686    b: &mut [c64],
9687    ldb: i32,
9688    info: &mut i32,
9689) {
9690    ffi::zposv_(
9691        &(uplo as c_char),
9692        &n,
9693        &nrhs,
9694        a.as_mut_ptr() as *mut _,
9695        &lda,
9696        b.as_mut_ptr() as *mut _,
9697        &ldb,
9698        info,
9699    )
9700}
9701
9702#[inline]
9703pub unsafe fn dsposv(
9704    uplo: u8,
9705    n: i32,
9706    nrhs: i32,
9707    a: &mut [f64],
9708    lda: i32,
9709    b: &[f64],
9710    ldb: i32,
9711    x: &mut [f64],
9712    ldx: i32,
9713    work: &mut [f64],
9714    swork: &mut [f32],
9715    iter: &mut i32,
9716    info: &mut i32,
9717) {
9718    ffi::dsposv_(
9719        &(uplo as c_char),
9720        &n,
9721        &nrhs,
9722        a.as_mut_ptr(),
9723        &lda,
9724        b.as_ptr(),
9725        &ldb,
9726        x.as_mut_ptr(),
9727        &ldx,
9728        work.as_mut_ptr(),
9729        swork.as_mut_ptr(),
9730        iter,
9731        info,
9732    )
9733}
9734
9735#[inline]
9736pub unsafe fn zcposv(
9737    uplo: u8,
9738    n: i32,
9739    nrhs: i32,
9740    a: &mut [c64],
9741    lda: i32,
9742    b: &[c64],
9743    ldb: i32,
9744    x: &mut [c64],
9745    ldx: i32,
9746    work: &mut [c64],
9747    swork: &mut [c32],
9748    rwork: &mut [f64],
9749    iter: &mut i32,
9750    info: &mut i32,
9751) {
9752    ffi::zcposv_(
9753        &(uplo as c_char),
9754        &n,
9755        &nrhs,
9756        a.as_mut_ptr() as *mut _,
9757        &lda,
9758        b.as_ptr() as *const _,
9759        &ldb,
9760        x.as_mut_ptr() as *mut _,
9761        &ldx,
9762        work.as_mut_ptr() as *mut _,
9763        swork.as_mut_ptr() as *mut _,
9764        rwork.as_mut_ptr(),
9765        iter,
9766        info,
9767    )
9768}
9769
9770#[inline]
9771pub unsafe fn sposvx(
9772    fact: u8,
9773    uplo: u8,
9774    n: i32,
9775    nrhs: i32,
9776    a: &mut [f32],
9777    lda: i32,
9778    af: &mut [f32],
9779    ldaf: i32,
9780    equed: &mut u8,
9781    s: &mut [f32],
9782    b: &mut [f32],
9783    ldb: i32,
9784    x: &mut [f32],
9785    ldx: i32,
9786    rcond: &mut f32,
9787    ferr: &mut [f32],
9788    berr: &mut [f32],
9789    work: &mut [f32],
9790    iwork: &mut [i32],
9791    info: &mut i32,
9792) {
9793    ffi::sposvx_(
9794        &(fact as c_char),
9795        &(uplo as c_char),
9796        &n,
9797        &nrhs,
9798        a.as_mut_ptr(),
9799        &lda,
9800        af.as_mut_ptr(),
9801        &ldaf,
9802        equed as *mut _ as *mut _,
9803        s.as_mut_ptr(),
9804        b.as_mut_ptr(),
9805        &ldb,
9806        x.as_mut_ptr(),
9807        &ldx,
9808        rcond,
9809        ferr.as_mut_ptr(),
9810        berr.as_mut_ptr(),
9811        work.as_mut_ptr(),
9812        iwork.as_mut_ptr(),
9813        info,
9814    )
9815}
9816
9817#[inline]
9818pub unsafe fn dposvx(
9819    fact: u8,
9820    uplo: u8,
9821    n: i32,
9822    nrhs: i32,
9823    a: &mut [f64],
9824    lda: i32,
9825    af: &mut [f64],
9826    ldaf: i32,
9827    equed: &mut u8,
9828    s: &mut [f64],
9829    b: &mut [f64],
9830    ldb: i32,
9831    x: &mut [f64],
9832    ldx: i32,
9833    rcond: &mut f64,
9834    ferr: &mut [f64],
9835    berr: &mut [f64],
9836    work: &mut [f64],
9837    iwork: &mut [i32],
9838    info: &mut i32,
9839) {
9840    ffi::dposvx_(
9841        &(fact as c_char),
9842        &(uplo as c_char),
9843        &n,
9844        &nrhs,
9845        a.as_mut_ptr(),
9846        &lda,
9847        af.as_mut_ptr(),
9848        &ldaf,
9849        equed as *mut _ as *mut _,
9850        s.as_mut_ptr(),
9851        b.as_mut_ptr(),
9852        &ldb,
9853        x.as_mut_ptr(),
9854        &ldx,
9855        rcond,
9856        ferr.as_mut_ptr(),
9857        berr.as_mut_ptr(),
9858        work.as_mut_ptr(),
9859        iwork.as_mut_ptr(),
9860        info,
9861    )
9862}
9863
9864#[inline]
9865pub unsafe fn cposvx(
9866    fact: u8,
9867    uplo: u8,
9868    n: i32,
9869    nrhs: i32,
9870    a: &mut [c32],
9871    lda: i32,
9872    af: &mut [c32],
9873    ldaf: i32,
9874    equed: &mut u8,
9875    s: &mut [f32],
9876    b: &mut [c32],
9877    ldb: i32,
9878    x: &mut [c32],
9879    ldx: i32,
9880    rcond: &mut f32,
9881    ferr: &mut [f32],
9882    berr: &mut [f32],
9883    work: &mut [c32],
9884    rwork: &mut [f32],
9885    info: &mut i32,
9886) {
9887    ffi::cposvx_(
9888        &(fact as c_char),
9889        &(uplo as c_char),
9890        &n,
9891        &nrhs,
9892        a.as_mut_ptr() as *mut _,
9893        &lda,
9894        af.as_mut_ptr() as *mut _,
9895        &ldaf,
9896        equed as *mut _ as *mut _,
9897        s.as_mut_ptr(),
9898        b.as_mut_ptr() as *mut _,
9899        &ldb,
9900        x.as_mut_ptr() as *mut _,
9901        &ldx,
9902        rcond,
9903        ferr.as_mut_ptr(),
9904        berr.as_mut_ptr(),
9905        work.as_mut_ptr() as *mut _,
9906        rwork.as_mut_ptr(),
9907        info,
9908    )
9909}
9910
9911#[inline]
9912pub unsafe fn zposvx(
9913    fact: u8,
9914    uplo: u8,
9915    n: i32,
9916    nrhs: i32,
9917    a: &mut [c64],
9918    lda: i32,
9919    af: &mut [c64],
9920    ldaf: i32,
9921    equed: &mut u8,
9922    s: &mut [f64],
9923    b: &mut [c64],
9924    ldb: i32,
9925    x: &mut [c64],
9926    ldx: i32,
9927    rcond: &mut f64,
9928    ferr: &mut [f64],
9929    berr: &mut [f64],
9930    work: &mut [c64],
9931    rwork: &mut [f64],
9932    info: &mut i32,
9933) {
9934    ffi::zposvx_(
9935        &(fact as c_char),
9936        &(uplo as c_char),
9937        &n,
9938        &nrhs,
9939        a.as_mut_ptr() as *mut _,
9940        &lda,
9941        af.as_mut_ptr() as *mut _,
9942        &ldaf,
9943        equed as *mut _ as *mut _,
9944        s.as_mut_ptr(),
9945        b.as_mut_ptr() as *mut _,
9946        &ldb,
9947        x.as_mut_ptr() as *mut _,
9948        &ldx,
9949        rcond,
9950        ferr.as_mut_ptr(),
9951        berr.as_mut_ptr(),
9952        work.as_mut_ptr() as *mut _,
9953        rwork.as_mut_ptr(),
9954        info,
9955    )
9956}
9957
9958#[inline]
9959pub unsafe fn dposvxx(
9960    fact: u8,
9961    uplo: u8,
9962    n: i32,
9963    nrhs: i32,
9964    a: &mut [f64],
9965    lda: i32,
9966    af: &mut [f64],
9967    ldaf: i32,
9968    equed: &mut u8,
9969    s: &mut [f64],
9970    b: &mut [f64],
9971    ldb: i32,
9972    x: &mut [f64],
9973    ldx: i32,
9974    rcond: &mut f64,
9975    rpvgrw: &mut f64,
9976    berr: &mut [f64],
9977    n_err_bnds: i32,
9978    err_bnds_norm: &mut [f64],
9979    err_bnds_comp: &mut [f64],
9980    nparams: &[i32],
9981    params: &mut [f64],
9982    work: &mut [f64],
9983    iwork: &mut [i32],
9984    info: &mut i32,
9985) {
9986    ffi::dposvxx_(
9987        &(fact as c_char),
9988        &(uplo as c_char),
9989        &n,
9990        &nrhs,
9991        a.as_mut_ptr(),
9992        &lda,
9993        af.as_mut_ptr(),
9994        &ldaf,
9995        equed as *mut _ as *mut _,
9996        s.as_mut_ptr(),
9997        b.as_mut_ptr(),
9998        &ldb,
9999        x.as_mut_ptr(),
10000        &ldx,
10001        rcond,
10002        rpvgrw,
10003        berr.as_mut_ptr(),
10004        &n_err_bnds,
10005        err_bnds_norm.as_mut_ptr(),
10006        err_bnds_comp.as_mut_ptr(),
10007        nparams.as_ptr(),
10008        params.as_mut_ptr(),
10009        work.as_mut_ptr(),
10010        iwork.as_mut_ptr(),
10011        info,
10012    )
10013}
10014
10015#[inline]
10016pub unsafe fn sposvxx(
10017    fact: u8,
10018    uplo: u8,
10019    n: i32,
10020    nrhs: i32,
10021    a: &mut [f32],
10022    lda: i32,
10023    af: &mut [f32],
10024    ldaf: i32,
10025    equed: &mut u8,
10026    s: &mut [f32],
10027    b: &mut [f32],
10028    ldb: i32,
10029    x: &mut [f32],
10030    ldx: i32,
10031    rcond: &mut f32,
10032    rpvgrw: &mut f32,
10033    berr: &mut [f32],
10034    n_err_bnds: i32,
10035    err_bnds_norm: &mut [f32],
10036    err_bnds_comp: &mut [f32],
10037    nparams: &[i32],
10038    params: &mut [f32],
10039    work: &mut [f32],
10040    iwork: &mut [i32],
10041    info: &mut i32,
10042) {
10043    ffi::sposvxx_(
10044        &(fact as c_char),
10045        &(uplo as c_char),
10046        &n,
10047        &nrhs,
10048        a.as_mut_ptr(),
10049        &lda,
10050        af.as_mut_ptr(),
10051        &ldaf,
10052        equed as *mut _ as *mut _,
10053        s.as_mut_ptr(),
10054        b.as_mut_ptr(),
10055        &ldb,
10056        x.as_mut_ptr(),
10057        &ldx,
10058        rcond,
10059        rpvgrw,
10060        berr.as_mut_ptr(),
10061        &n_err_bnds,
10062        err_bnds_norm.as_mut_ptr(),
10063        err_bnds_comp.as_mut_ptr(),
10064        nparams.as_ptr(),
10065        params.as_mut_ptr(),
10066        work.as_mut_ptr(),
10067        iwork.as_mut_ptr(),
10068        info,
10069    )
10070}
10071
10072#[inline]
10073pub unsafe fn zposvxx(
10074    fact: u8,
10075    uplo: u8,
10076    n: i32,
10077    nrhs: i32,
10078    a: &mut [c64],
10079    lda: i32,
10080    af: &mut [c64],
10081    ldaf: i32,
10082    equed: &mut u8,
10083    s: &mut [f64],
10084    b: &mut [c64],
10085    ldb: i32,
10086    x: &mut [c64],
10087    ldx: i32,
10088    rcond: &mut f64,
10089    rpvgrw: &mut f64,
10090    berr: &mut [f64],
10091    n_err_bnds: i32,
10092    err_bnds_norm: &mut [f64],
10093    err_bnds_comp: &mut [f64],
10094    nparams: &[i32],
10095    params: &mut [f64],
10096    work: &mut [c64],
10097    rwork: &mut [f64],
10098    info: &mut i32,
10099) {
10100    ffi::zposvxx_(
10101        &(fact as c_char),
10102        &(uplo as c_char),
10103        &n,
10104        &nrhs,
10105        a.as_mut_ptr() as *mut _,
10106        &lda,
10107        af.as_mut_ptr() as *mut _,
10108        &ldaf,
10109        equed as *mut _ as *mut _,
10110        s.as_mut_ptr(),
10111        b.as_mut_ptr() as *mut _,
10112        &ldb,
10113        x.as_mut_ptr() as *mut _,
10114        &ldx,
10115        rcond,
10116        rpvgrw,
10117        berr.as_mut_ptr(),
10118        &n_err_bnds,
10119        err_bnds_norm.as_mut_ptr(),
10120        err_bnds_comp.as_mut_ptr(),
10121        nparams.as_ptr(),
10122        params.as_mut_ptr(),
10123        work.as_mut_ptr() as *mut _,
10124        rwork.as_mut_ptr(),
10125        info,
10126    )
10127}
10128
10129#[inline]
10130pub unsafe fn cposvxx(
10131    fact: u8,
10132    uplo: u8,
10133    n: i32,
10134    nrhs: i32,
10135    a: &mut [c32],
10136    lda: i32,
10137    af: &mut [c32],
10138    ldaf: i32,
10139    equed: &mut u8,
10140    s: &mut [f32],
10141    b: &mut [c32],
10142    ldb: i32,
10143    x: &mut [c32],
10144    ldx: i32,
10145    rcond: &mut f32,
10146    rpvgrw: &mut f32,
10147    berr: &mut [f32],
10148    n_err_bnds: i32,
10149    err_bnds_norm: &mut [f32],
10150    err_bnds_comp: &mut [f32],
10151    nparams: &[i32],
10152    params: &mut [f32],
10153    work: &mut [c32],
10154    rwork: &mut [f32],
10155    info: &mut i32,
10156) {
10157    ffi::cposvxx_(
10158        &(fact as c_char),
10159        &(uplo as c_char),
10160        &n,
10161        &nrhs,
10162        a.as_mut_ptr() as *mut _,
10163        &lda,
10164        af.as_mut_ptr() as *mut _,
10165        &ldaf,
10166        equed as *mut _ as *mut _,
10167        s.as_mut_ptr(),
10168        b.as_mut_ptr() as *mut _,
10169        &ldb,
10170        x.as_mut_ptr() as *mut _,
10171        &ldx,
10172        rcond,
10173        rpvgrw,
10174        berr.as_mut_ptr(),
10175        &n_err_bnds,
10176        err_bnds_norm.as_mut_ptr(),
10177        err_bnds_comp.as_mut_ptr(),
10178        nparams.as_ptr(),
10179        params.as_mut_ptr(),
10180        work.as_mut_ptr() as *mut _,
10181        rwork.as_mut_ptr(),
10182        info,
10183    )
10184}
10185
10186#[inline]
10187pub unsafe fn sppsv(
10188    uplo: u8,
10189    n: i32,
10190    nrhs: i32,
10191    ap: &mut [f32],
10192    b: &mut [f32],
10193    ldb: i32,
10194    info: &mut i32,
10195) {
10196    ffi::sppsv_(
10197        &(uplo as c_char),
10198        &n,
10199        &nrhs,
10200        ap.as_mut_ptr(),
10201        b.as_mut_ptr(),
10202        &ldb,
10203        info,
10204    )
10205}
10206
10207#[inline]
10208pub unsafe fn dppsv(
10209    uplo: u8,
10210    n: i32,
10211    nrhs: i32,
10212    ap: &mut [f64],
10213    b: &mut [f64],
10214    ldb: i32,
10215    info: &mut i32,
10216) {
10217    ffi::dppsv_(
10218        &(uplo as c_char),
10219        &n,
10220        &nrhs,
10221        ap.as_mut_ptr(),
10222        b.as_mut_ptr(),
10223        &ldb,
10224        info,
10225    )
10226}
10227
10228#[inline]
10229pub unsafe fn cppsv(
10230    uplo: u8,
10231    n: i32,
10232    nrhs: i32,
10233    ap: &mut [c32],
10234    b: &mut [c32],
10235    ldb: i32,
10236    info: &mut i32,
10237) {
10238    ffi::cppsv_(
10239        &(uplo as c_char),
10240        &n,
10241        &nrhs,
10242        ap.as_mut_ptr() as *mut _,
10243        b.as_mut_ptr() as *mut _,
10244        &ldb,
10245        info,
10246    )
10247}
10248
10249#[inline]
10250pub unsafe fn zppsv(
10251    uplo: u8,
10252    n: i32,
10253    nrhs: i32,
10254    ap: &mut [c64],
10255    b: &mut [c64],
10256    ldb: i32,
10257    info: &mut i32,
10258) {
10259    ffi::zppsv_(
10260        &(uplo as c_char),
10261        &n,
10262        &nrhs,
10263        ap.as_mut_ptr() as *mut _,
10264        b.as_mut_ptr() as *mut _,
10265        &ldb,
10266        info,
10267    )
10268}
10269
10270#[inline]
10271pub unsafe fn sppsvx(
10272    fact: u8,
10273    uplo: u8,
10274    n: i32,
10275    nrhs: i32,
10276    ap: &mut [f32],
10277    afp: &mut [f32],
10278    equed: &mut u8,
10279    s: &mut [f32],
10280    b: &mut [f32],
10281    ldb: i32,
10282    x: &mut [f32],
10283    ldx: i32,
10284    rcond: &mut f32,
10285    ferr: &mut [f32],
10286    berr: &mut [f32],
10287    work: &mut [f32],
10288    iwork: &mut [i32],
10289    info: &mut i32,
10290) {
10291    ffi::sppsvx_(
10292        &(fact as c_char),
10293        &(uplo as c_char),
10294        &n,
10295        &nrhs,
10296        ap.as_mut_ptr(),
10297        afp.as_mut_ptr(),
10298        equed as *mut _ as *mut _,
10299        s.as_mut_ptr(),
10300        b.as_mut_ptr(),
10301        &ldb,
10302        x.as_mut_ptr(),
10303        &ldx,
10304        rcond,
10305        ferr.as_mut_ptr(),
10306        berr.as_mut_ptr(),
10307        work.as_mut_ptr(),
10308        iwork.as_mut_ptr(),
10309        info,
10310    )
10311}
10312
10313#[inline]
10314pub unsafe fn dppsvx(
10315    fact: u8,
10316    uplo: u8,
10317    n: i32,
10318    nrhs: i32,
10319    ap: &mut [f64],
10320    afp: &mut [f64],
10321    equed: &mut u8,
10322    s: &mut [f64],
10323    b: &mut [f64],
10324    ldb: i32,
10325    x: &mut [f64],
10326    ldx: i32,
10327    rcond: &mut f64,
10328    ferr: &mut [f64],
10329    berr: &mut [f64],
10330    work: &mut [f64],
10331    iwork: &mut [i32],
10332    info: &mut i32,
10333) {
10334    ffi::dppsvx_(
10335        &(fact as c_char),
10336        &(uplo as c_char),
10337        &n,
10338        &nrhs,
10339        ap.as_mut_ptr(),
10340        afp.as_mut_ptr(),
10341        equed as *mut _ as *mut _,
10342        s.as_mut_ptr(),
10343        b.as_mut_ptr(),
10344        &ldb,
10345        x.as_mut_ptr(),
10346        &ldx,
10347        rcond,
10348        ferr.as_mut_ptr(),
10349        berr.as_mut_ptr(),
10350        work.as_mut_ptr(),
10351        iwork.as_mut_ptr(),
10352        info,
10353    )
10354}
10355
10356#[inline]
10357pub unsafe fn cppsvx(
10358    fact: u8,
10359    uplo: u8,
10360    n: i32,
10361    nrhs: i32,
10362    ap: &mut [c32],
10363    afp: &mut [c32],
10364    equed: &mut u8,
10365    s: &mut [f32],
10366    b: &mut [c32],
10367    ldb: i32,
10368    x: &mut [c32],
10369    ldx: i32,
10370    rcond: &mut f32,
10371    ferr: &mut [f32],
10372    berr: &mut [f32],
10373    work: &mut [c32],
10374    rwork: &mut [f32],
10375    info: &mut i32,
10376) {
10377    ffi::cppsvx_(
10378        &(fact as c_char),
10379        &(uplo as c_char),
10380        &n,
10381        &nrhs,
10382        ap.as_mut_ptr() as *mut _,
10383        afp.as_mut_ptr() as *mut _,
10384        equed as *mut _ as *mut _,
10385        s.as_mut_ptr(),
10386        b.as_mut_ptr() as *mut _,
10387        &ldb,
10388        x.as_mut_ptr() as *mut _,
10389        &ldx,
10390        rcond,
10391        ferr.as_mut_ptr(),
10392        berr.as_mut_ptr(),
10393        work.as_mut_ptr() as *mut _,
10394        rwork.as_mut_ptr(),
10395        info,
10396    )
10397}
10398
10399#[inline]
10400pub unsafe fn zppsvx(
10401    fact: u8,
10402    uplo: u8,
10403    n: i32,
10404    nrhs: i32,
10405    ap: &mut [c64],
10406    afp: &mut [c64],
10407    equed: &mut u8,
10408    s: &mut [f64],
10409    b: &mut [c64],
10410    ldb: i32,
10411    x: &mut [c64],
10412    ldx: i32,
10413    rcond: &mut f64,
10414    ferr: &mut [f64],
10415    berr: &mut [f64],
10416    work: &mut [c64],
10417    rwork: &mut [f64],
10418    info: &mut i32,
10419) {
10420    ffi::zppsvx_(
10421        &(fact as c_char),
10422        &(uplo as c_char),
10423        &n,
10424        &nrhs,
10425        ap.as_mut_ptr() as *mut _,
10426        afp.as_mut_ptr() as *mut _,
10427        equed as *mut _ as *mut _,
10428        s.as_mut_ptr(),
10429        b.as_mut_ptr() as *mut _,
10430        &ldb,
10431        x.as_mut_ptr() as *mut _,
10432        &ldx,
10433        rcond,
10434        ferr.as_mut_ptr(),
10435        berr.as_mut_ptr(),
10436        work.as_mut_ptr() as *mut _,
10437        rwork.as_mut_ptr(),
10438        info,
10439    )
10440}
10441
10442#[inline]
10443pub unsafe fn spbsv(
10444    uplo: u8,
10445    n: i32,
10446    kd: i32,
10447    nrhs: i32,
10448    ab: &mut [f32],
10449    ldab: i32,
10450    b: &mut [f32],
10451    ldb: i32,
10452    info: &mut i32,
10453) {
10454    ffi::spbsv_(
10455        &(uplo as c_char),
10456        &n,
10457        &kd,
10458        &nrhs,
10459        ab.as_mut_ptr(),
10460        &ldab,
10461        b.as_mut_ptr(),
10462        &ldb,
10463        info,
10464    )
10465}
10466
10467#[inline]
10468pub unsafe fn dpbsv(
10469    uplo: u8,
10470    n: i32,
10471    kd: i32,
10472    nrhs: i32,
10473    ab: &mut [f64],
10474    ldab: i32,
10475    b: &mut [f64],
10476    ldb: i32,
10477    info: &mut i32,
10478) {
10479    ffi::dpbsv_(
10480        &(uplo as c_char),
10481        &n,
10482        &kd,
10483        &nrhs,
10484        ab.as_mut_ptr(),
10485        &ldab,
10486        b.as_mut_ptr(),
10487        &ldb,
10488        info,
10489    )
10490}
10491
10492#[inline]
10493pub unsafe fn cpbsv(
10494    uplo: u8,
10495    n: i32,
10496    kd: i32,
10497    nrhs: i32,
10498    ab: &mut [c32],
10499    ldab: i32,
10500    b: &mut [c32],
10501    ldb: i32,
10502    info: &mut i32,
10503) {
10504    ffi::cpbsv_(
10505        &(uplo as c_char),
10506        &n,
10507        &kd,
10508        &nrhs,
10509        ab.as_mut_ptr() as *mut _,
10510        &ldab,
10511        b.as_mut_ptr() as *mut _,
10512        &ldb,
10513        info,
10514    )
10515}
10516
10517#[inline]
10518pub unsafe fn zpbsv(
10519    uplo: u8,
10520    n: i32,
10521    kd: i32,
10522    nrhs: i32,
10523    ab: &mut [c64],
10524    ldab: i32,
10525    b: &mut [c64],
10526    ldb: i32,
10527    info: &mut i32,
10528) {
10529    ffi::zpbsv_(
10530        &(uplo as c_char),
10531        &n,
10532        &kd,
10533        &nrhs,
10534        ab.as_mut_ptr() as *mut _,
10535        &ldab,
10536        b.as_mut_ptr() as *mut _,
10537        &ldb,
10538        info,
10539    )
10540}
10541
10542#[inline]
10543pub unsafe fn spbsvx(
10544    fact: u8,
10545    uplo: u8,
10546    n: i32,
10547    kd: i32,
10548    nrhs: i32,
10549    ab: &mut [f32],
10550    ldab: i32,
10551    afb: &mut [f32],
10552    ldafb: i32,
10553    equed: &mut u8,
10554    s: &mut [f32],
10555    b: &mut [f32],
10556    ldb: i32,
10557    x: &mut [f32],
10558    ldx: i32,
10559    rcond: &mut f32,
10560    ferr: &mut [f32],
10561    berr: &mut [f32],
10562    work: &mut [f32],
10563    iwork: &mut [i32],
10564    info: &mut i32,
10565) {
10566    ffi::spbsvx_(
10567        &(fact as c_char),
10568        &(uplo as c_char),
10569        &n,
10570        &kd,
10571        &nrhs,
10572        ab.as_mut_ptr(),
10573        &ldab,
10574        afb.as_mut_ptr(),
10575        &ldafb,
10576        equed as *mut _ as *mut _,
10577        s.as_mut_ptr(),
10578        b.as_mut_ptr(),
10579        &ldb,
10580        x.as_mut_ptr(),
10581        &ldx,
10582        rcond,
10583        ferr.as_mut_ptr(),
10584        berr.as_mut_ptr(),
10585        work.as_mut_ptr(),
10586        iwork.as_mut_ptr(),
10587        info,
10588    )
10589}
10590
10591#[inline]
10592pub unsafe fn dpbsvx(
10593    fact: u8,
10594    uplo: u8,
10595    n: i32,
10596    kd: i32,
10597    nrhs: i32,
10598    ab: &mut [f64],
10599    ldab: i32,
10600    afb: &mut [f64],
10601    ldafb: i32,
10602    equed: &mut u8,
10603    s: &mut [f64],
10604    b: &mut [f64],
10605    ldb: i32,
10606    x: &mut [f64],
10607    ldx: i32,
10608    rcond: &mut f64,
10609    ferr: &mut [f64],
10610    berr: &mut [f64],
10611    work: &mut [f64],
10612    iwork: &mut [i32],
10613    info: &mut i32,
10614) {
10615    ffi::dpbsvx_(
10616        &(fact as c_char),
10617        &(uplo as c_char),
10618        &n,
10619        &kd,
10620        &nrhs,
10621        ab.as_mut_ptr(),
10622        &ldab,
10623        afb.as_mut_ptr(),
10624        &ldafb,
10625        equed as *mut _ as *mut _,
10626        s.as_mut_ptr(),
10627        b.as_mut_ptr(),
10628        &ldb,
10629        x.as_mut_ptr(),
10630        &ldx,
10631        rcond,
10632        ferr.as_mut_ptr(),
10633        berr.as_mut_ptr(),
10634        work.as_mut_ptr(),
10635        iwork.as_mut_ptr(),
10636        info,
10637    )
10638}
10639
10640#[inline]
10641pub unsafe fn cpbsvx(
10642    fact: u8,
10643    uplo: u8,
10644    n: i32,
10645    kd: i32,
10646    nrhs: i32,
10647    ab: &mut [c32],
10648    ldab: i32,
10649    afb: &mut [c32],
10650    ldafb: i32,
10651    equed: &mut u8,
10652    s: &mut [f32],
10653    b: &mut [c32],
10654    ldb: i32,
10655    x: &mut [c32],
10656    ldx: i32,
10657    rcond: &mut f32,
10658    ferr: &mut [f32],
10659    berr: &mut [f32],
10660    work: &mut [c32],
10661    rwork: &mut [f32],
10662    info: &mut i32,
10663) {
10664    ffi::cpbsvx_(
10665        &(fact as c_char),
10666        &(uplo as c_char),
10667        &n,
10668        &kd,
10669        &nrhs,
10670        ab.as_mut_ptr() as *mut _,
10671        &ldab,
10672        afb.as_mut_ptr() as *mut _,
10673        &ldafb,
10674        equed as *mut _ as *mut _,
10675        s.as_mut_ptr(),
10676        b.as_mut_ptr() as *mut _,
10677        &ldb,
10678        x.as_mut_ptr() as *mut _,
10679        &ldx,
10680        rcond,
10681        ferr.as_mut_ptr(),
10682        berr.as_mut_ptr(),
10683        work.as_mut_ptr() as *mut _,
10684        rwork.as_mut_ptr(),
10685        info,
10686    )
10687}
10688
10689#[inline]
10690pub unsafe fn zpbsvx(
10691    fact: u8,
10692    uplo: u8,
10693    n: i32,
10694    kd: i32,
10695    nrhs: i32,
10696    ab: &mut [c64],
10697    ldab: i32,
10698    afb: &mut [c64],
10699    ldafb: i32,
10700    equed: &mut u8,
10701    s: &mut [f64],
10702    b: &mut [c64],
10703    ldb: i32,
10704    x: &mut [c64],
10705    ldx: i32,
10706    rcond: &mut f64,
10707    ferr: &mut [f64],
10708    berr: &mut [f64],
10709    work: &mut [c64],
10710    rwork: &mut [f64],
10711    info: &mut i32,
10712) {
10713    ffi::zpbsvx_(
10714        &(fact as c_char),
10715        &(uplo as c_char),
10716        &n,
10717        &kd,
10718        &nrhs,
10719        ab.as_mut_ptr() as *mut _,
10720        &ldab,
10721        afb.as_mut_ptr() as *mut _,
10722        &ldafb,
10723        equed as *mut _ as *mut _,
10724        s.as_mut_ptr(),
10725        b.as_mut_ptr() as *mut _,
10726        &ldb,
10727        x.as_mut_ptr() as *mut _,
10728        &ldx,
10729        rcond,
10730        ferr.as_mut_ptr(),
10731        berr.as_mut_ptr(),
10732        work.as_mut_ptr() as *mut _,
10733        rwork.as_mut_ptr(),
10734        info,
10735    )
10736}
10737
10738#[inline]
10739pub unsafe fn sptsv(
10740    n: i32,
10741    nrhs: i32,
10742    d: &mut [f32],
10743    e: &mut [f32],
10744    b: &mut [f32],
10745    ldb: i32,
10746    info: &mut i32,
10747) {
10748    ffi::sptsv_(
10749        &n,
10750        &nrhs,
10751        d.as_mut_ptr(),
10752        e.as_mut_ptr(),
10753        b.as_mut_ptr(),
10754        &ldb,
10755        info,
10756    )
10757}
10758
10759#[inline]
10760pub unsafe fn dptsv(
10761    n: i32,
10762    nrhs: i32,
10763    d: &mut [f64],
10764    e: &mut [f64],
10765    b: &mut [f64],
10766    ldb: i32,
10767    info: &mut i32,
10768) {
10769    ffi::dptsv_(
10770        &n,
10771        &nrhs,
10772        d.as_mut_ptr(),
10773        e.as_mut_ptr(),
10774        b.as_mut_ptr(),
10775        &ldb,
10776        info,
10777    )
10778}
10779
10780#[inline]
10781pub unsafe fn cptsv(
10782    n: i32,
10783    nrhs: i32,
10784    d: &mut [f32],
10785    e: &mut [c32],
10786    b: &mut [c32],
10787    ldb: i32,
10788    info: &mut i32,
10789) {
10790    ffi::cptsv_(
10791        &n,
10792        &nrhs,
10793        d.as_mut_ptr(),
10794        e.as_mut_ptr() as *mut _,
10795        b.as_mut_ptr() as *mut _,
10796        &ldb,
10797        info,
10798    )
10799}
10800
10801#[inline]
10802pub unsafe fn zptsv(
10803    n: i32,
10804    nrhs: i32,
10805    d: &mut [f64],
10806    e: &mut [c64],
10807    b: &mut [c64],
10808    ldb: i32,
10809    info: &mut i32,
10810) {
10811    ffi::zptsv_(
10812        &n,
10813        &nrhs,
10814        d.as_mut_ptr(),
10815        e.as_mut_ptr() as *mut _,
10816        b.as_mut_ptr() as *mut _,
10817        &ldb,
10818        info,
10819    )
10820}
10821
10822#[inline]
10823pub unsafe fn sptsvx(
10824    fact: u8,
10825    n: i32,
10826    nrhs: i32,
10827    d: &[f32],
10828    e: &[f32],
10829    df: &mut [f32],
10830    ef: &mut [f32],
10831    b: &[f32],
10832    ldb: i32,
10833    x: &mut [f32],
10834    ldx: i32,
10835    rcond: &mut f32,
10836    ferr: &mut [f32],
10837    berr: &mut [f32],
10838    work: &mut [f32],
10839    info: &mut i32,
10840) {
10841    ffi::sptsvx_(
10842        &(fact as c_char),
10843        &n,
10844        &nrhs,
10845        d.as_ptr(),
10846        e.as_ptr(),
10847        df.as_mut_ptr(),
10848        ef.as_mut_ptr(),
10849        b.as_ptr(),
10850        &ldb,
10851        x.as_mut_ptr(),
10852        &ldx,
10853        rcond,
10854        ferr.as_mut_ptr(),
10855        berr.as_mut_ptr(),
10856        work.as_mut_ptr(),
10857        info,
10858    )
10859}
10860
10861#[inline]
10862pub unsafe fn dptsvx(
10863    fact: u8,
10864    n: i32,
10865    nrhs: i32,
10866    d: &[f64],
10867    e: &[f64],
10868    df: &mut [f64],
10869    ef: &mut [f64],
10870    b: &[f64],
10871    ldb: i32,
10872    x: &mut [f64],
10873    ldx: i32,
10874    rcond: &mut f64,
10875    ferr: &mut [f64],
10876    berr: &mut [f64],
10877    work: &mut [f64],
10878    info: &mut i32,
10879) {
10880    ffi::dptsvx_(
10881        &(fact as c_char),
10882        &n,
10883        &nrhs,
10884        d.as_ptr(),
10885        e.as_ptr(),
10886        df.as_mut_ptr(),
10887        ef.as_mut_ptr(),
10888        b.as_ptr(),
10889        &ldb,
10890        x.as_mut_ptr(),
10891        &ldx,
10892        rcond,
10893        ferr.as_mut_ptr(),
10894        berr.as_mut_ptr(),
10895        work.as_mut_ptr(),
10896        info,
10897    )
10898}
10899
10900#[inline]
10901pub unsafe fn cptsvx(
10902    fact: u8,
10903    n: i32,
10904    nrhs: i32,
10905    d: &[f32],
10906    e: &[c32],
10907    df: &mut [f32],
10908    ef: &mut [c32],
10909    b: &[c32],
10910    ldb: i32,
10911    x: &mut [c32],
10912    ldx: i32,
10913    rcond: &mut f32,
10914    ferr: &mut [f32],
10915    berr: &mut [f32],
10916    work: &mut [c32],
10917    rwork: &mut [f32],
10918    info: &mut i32,
10919) {
10920    ffi::cptsvx_(
10921        &(fact as c_char),
10922        &n,
10923        &nrhs,
10924        d.as_ptr(),
10925        e.as_ptr() as *const _,
10926        df.as_mut_ptr(),
10927        ef.as_mut_ptr() as *mut _,
10928        b.as_ptr() as *const _,
10929        &ldb,
10930        x.as_mut_ptr() as *mut _,
10931        &ldx,
10932        rcond,
10933        ferr.as_mut_ptr(),
10934        berr.as_mut_ptr(),
10935        work.as_mut_ptr() as *mut _,
10936        rwork.as_mut_ptr(),
10937        info,
10938    )
10939}
10940
10941#[inline]
10942pub unsafe fn zptsvx(
10943    fact: u8,
10944    n: i32,
10945    nrhs: i32,
10946    d: &[f64],
10947    e: &[c64],
10948    df: &mut [f64],
10949    ef: &mut [c64],
10950    b: &[c64],
10951    ldb: i32,
10952    x: &mut [c64],
10953    ldx: i32,
10954    rcond: &mut f64,
10955    ferr: &mut [f64],
10956    berr: &mut [f64],
10957    work: &mut [c64],
10958    rwork: &mut [f64],
10959    info: &mut i32,
10960) {
10961    ffi::zptsvx_(
10962        &(fact as c_char),
10963        &n,
10964        &nrhs,
10965        d.as_ptr(),
10966        e.as_ptr() as *const _,
10967        df.as_mut_ptr(),
10968        ef.as_mut_ptr() as *mut _,
10969        b.as_ptr() as *const _,
10970        &ldb,
10971        x.as_mut_ptr() as *mut _,
10972        &ldx,
10973        rcond,
10974        ferr.as_mut_ptr(),
10975        berr.as_mut_ptr(),
10976        work.as_mut_ptr() as *mut _,
10977        rwork.as_mut_ptr(),
10978        info,
10979    )
10980}
10981
10982#[inline]
10983pub unsafe fn ssysv(
10984    uplo: u8,
10985    n: i32,
10986    nrhs: i32,
10987    a: &mut [f32],
10988    lda: i32,
10989    ipiv: &mut [i32],
10990    b: &mut [f32],
10991    ldb: i32,
10992    work: &mut [f32],
10993    lwork: i32,
10994    info: &mut i32,
10995) {
10996    ffi::ssysv_(
10997        &(uplo as c_char),
10998        &n,
10999        &nrhs,
11000        a.as_mut_ptr(),
11001        &lda,
11002        ipiv.as_mut_ptr(),
11003        b.as_mut_ptr(),
11004        &ldb,
11005        work.as_mut_ptr(),
11006        &lwork,
11007        info,
11008    )
11009}
11010
11011#[inline]
11012pub unsafe fn dsysv(
11013    uplo: u8,
11014    n: i32,
11015    nrhs: i32,
11016    a: &mut [f64],
11017    lda: i32,
11018    ipiv: &mut [i32],
11019    b: &mut [f64],
11020    ldb: i32,
11021    work: &mut [f64],
11022    lwork: i32,
11023    info: &mut i32,
11024) {
11025    ffi::dsysv_(
11026        &(uplo as c_char),
11027        &n,
11028        &nrhs,
11029        a.as_mut_ptr(),
11030        &lda,
11031        ipiv.as_mut_ptr(),
11032        b.as_mut_ptr(),
11033        &ldb,
11034        work.as_mut_ptr(),
11035        &lwork,
11036        info,
11037    )
11038}
11039
11040#[inline]
11041pub unsafe fn csysv(
11042    uplo: u8,
11043    n: i32,
11044    nrhs: i32,
11045    a: &mut [c32],
11046    lda: i32,
11047    ipiv: &mut [i32],
11048    b: &mut [c32],
11049    ldb: i32,
11050    work: &mut [c32],
11051    lwork: i32,
11052    info: &mut i32,
11053) {
11054    ffi::csysv_(
11055        &(uplo as c_char),
11056        &n,
11057        &nrhs,
11058        a.as_mut_ptr() as *mut _,
11059        &lda,
11060        ipiv.as_mut_ptr(),
11061        b.as_mut_ptr() as *mut _,
11062        &ldb,
11063        work.as_mut_ptr() as *mut _,
11064        &lwork,
11065        info,
11066    )
11067}
11068
11069#[inline]
11070pub unsafe fn zsysv(
11071    uplo: u8,
11072    n: i32,
11073    nrhs: i32,
11074    a: &mut [c64],
11075    lda: i32,
11076    ipiv: &mut [i32],
11077    b: &mut [c64],
11078    ldb: i32,
11079    work: &mut [c64],
11080    lwork: i32,
11081    info: &mut i32,
11082) {
11083    ffi::zsysv_(
11084        &(uplo as c_char),
11085        &n,
11086        &nrhs,
11087        a.as_mut_ptr() as *mut _,
11088        &lda,
11089        ipiv.as_mut_ptr(),
11090        b.as_mut_ptr() as *mut _,
11091        &ldb,
11092        work.as_mut_ptr() as *mut _,
11093        &lwork,
11094        info,
11095    )
11096}
11097
11098#[inline]
11099pub unsafe fn ssysvx(
11100    fact: u8,
11101    uplo: u8,
11102    n: i32,
11103    nrhs: i32,
11104    a: &[f32],
11105    lda: i32,
11106    af: &mut [f32],
11107    ldaf: i32,
11108    ipiv: &mut [i32],
11109    b: &[f32],
11110    ldb: i32,
11111    x: &mut [f32],
11112    ldx: i32,
11113    rcond: &mut f32,
11114    ferr: &mut [f32],
11115    berr: &mut [f32],
11116    work: &mut [f32],
11117    lwork: i32,
11118    iwork: &mut [i32],
11119    info: &mut i32,
11120) {
11121    ffi::ssysvx_(
11122        &(fact as c_char),
11123        &(uplo as c_char),
11124        &n,
11125        &nrhs,
11126        a.as_ptr(),
11127        &lda,
11128        af.as_mut_ptr(),
11129        &ldaf,
11130        ipiv.as_mut_ptr(),
11131        b.as_ptr(),
11132        &ldb,
11133        x.as_mut_ptr(),
11134        &ldx,
11135        rcond,
11136        ferr.as_mut_ptr(),
11137        berr.as_mut_ptr(),
11138        work.as_mut_ptr(),
11139        &lwork,
11140        iwork.as_mut_ptr(),
11141        info,
11142    )
11143}
11144
11145#[inline]
11146pub unsafe fn dsysvx(
11147    fact: u8,
11148    uplo: u8,
11149    n: i32,
11150    nrhs: i32,
11151    a: &[f64],
11152    lda: i32,
11153    af: &mut [f64],
11154    ldaf: i32,
11155    ipiv: &mut [i32],
11156    b: &[f64],
11157    ldb: i32,
11158    x: &mut [f64],
11159    ldx: i32,
11160    rcond: &mut f64,
11161    ferr: &mut [f64],
11162    berr: &mut [f64],
11163    work: &mut [f64],
11164    lwork: i32,
11165    iwork: &mut [i32],
11166    info: &mut i32,
11167) {
11168    ffi::dsysvx_(
11169        &(fact as c_char),
11170        &(uplo as c_char),
11171        &n,
11172        &nrhs,
11173        a.as_ptr(),
11174        &lda,
11175        af.as_mut_ptr(),
11176        &ldaf,
11177        ipiv.as_mut_ptr(),
11178        b.as_ptr(),
11179        &ldb,
11180        x.as_mut_ptr(),
11181        &ldx,
11182        rcond,
11183        ferr.as_mut_ptr(),
11184        berr.as_mut_ptr(),
11185        work.as_mut_ptr(),
11186        &lwork,
11187        iwork.as_mut_ptr(),
11188        info,
11189    )
11190}
11191
11192#[inline]
11193pub unsafe fn csysvx(
11194    fact: u8,
11195    uplo: u8,
11196    n: i32,
11197    nrhs: i32,
11198    a: &[c32],
11199    lda: i32,
11200    af: &mut [c32],
11201    ldaf: i32,
11202    ipiv: &mut [i32],
11203    b: &[c32],
11204    ldb: i32,
11205    x: &mut [c32],
11206    ldx: i32,
11207    rcond: &mut f32,
11208    ferr: &mut [f32],
11209    berr: &mut [f32],
11210    work: &mut [c32],
11211    lwork: i32,
11212    rwork: &mut [f32],
11213    info: &mut i32,
11214) {
11215    ffi::csysvx_(
11216        &(fact as c_char),
11217        &(uplo as c_char),
11218        &n,
11219        &nrhs,
11220        a.as_ptr() as *const _,
11221        &lda,
11222        af.as_mut_ptr() as *mut _,
11223        &ldaf,
11224        ipiv.as_mut_ptr(),
11225        b.as_ptr() as *const _,
11226        &ldb,
11227        x.as_mut_ptr() as *mut _,
11228        &ldx,
11229        rcond,
11230        ferr.as_mut_ptr(),
11231        berr.as_mut_ptr(),
11232        work.as_mut_ptr() as *mut _,
11233        &lwork,
11234        rwork.as_mut_ptr(),
11235        info,
11236    )
11237}
11238
11239#[inline]
11240pub unsafe fn zsysvx(
11241    fact: u8,
11242    uplo: u8,
11243    n: i32,
11244    nrhs: i32,
11245    a: &[c64],
11246    lda: i32,
11247    af: &mut [c64],
11248    ldaf: i32,
11249    ipiv: &mut [i32],
11250    b: &[c64],
11251    ldb: i32,
11252    x: &mut [c64],
11253    ldx: i32,
11254    rcond: &mut f64,
11255    ferr: &mut [f64],
11256    berr: &mut [f64],
11257    work: &mut [c64],
11258    lwork: i32,
11259    rwork: &mut [f64],
11260    info: &mut i32,
11261) {
11262    ffi::zsysvx_(
11263        &(fact as c_char),
11264        &(uplo as c_char),
11265        &n,
11266        &nrhs,
11267        a.as_ptr() as *const _,
11268        &lda,
11269        af.as_mut_ptr() as *mut _,
11270        &ldaf,
11271        ipiv.as_mut_ptr(),
11272        b.as_ptr() as *const _,
11273        &ldb,
11274        x.as_mut_ptr() as *mut _,
11275        &ldx,
11276        rcond,
11277        ferr.as_mut_ptr(),
11278        berr.as_mut_ptr(),
11279        work.as_mut_ptr() as *mut _,
11280        &lwork,
11281        rwork.as_mut_ptr(),
11282        info,
11283    )
11284}
11285
11286#[inline]
11287pub unsafe fn dsysvxx(
11288    fact: u8,
11289    uplo: u8,
11290    n: i32,
11291    nrhs: i32,
11292    a: &mut [f64],
11293    lda: i32,
11294    af: &mut [f64],
11295    ldaf: i32,
11296    ipiv: &mut [i32],
11297    equed: &mut u8,
11298    s: &mut [f64],
11299    b: &mut [f64],
11300    ldb: i32,
11301    x: &mut [f64],
11302    ldx: i32,
11303    rcond: &mut f64,
11304    rpvgrw: &mut f64,
11305    berr: &mut [f64],
11306    n_err_bnds: i32,
11307    err_bnds_norm: &mut [f64],
11308    err_bnds_comp: &mut [f64],
11309    nparams: &[i32],
11310    params: &mut [f64],
11311    work: &mut [f64],
11312    iwork: &mut [i32],
11313    info: &mut i32,
11314) {
11315    ffi::dsysvxx_(
11316        &(fact as c_char),
11317        &(uplo as c_char),
11318        &n,
11319        &nrhs,
11320        a.as_mut_ptr(),
11321        &lda,
11322        af.as_mut_ptr(),
11323        &ldaf,
11324        ipiv.as_mut_ptr(),
11325        equed as *mut _ as *mut _,
11326        s.as_mut_ptr(),
11327        b.as_mut_ptr(),
11328        &ldb,
11329        x.as_mut_ptr(),
11330        &ldx,
11331        rcond,
11332        rpvgrw,
11333        berr.as_mut_ptr(),
11334        &n_err_bnds,
11335        err_bnds_norm.as_mut_ptr(),
11336        err_bnds_comp.as_mut_ptr(),
11337        nparams.as_ptr(),
11338        params.as_mut_ptr(),
11339        work.as_mut_ptr(),
11340        iwork.as_mut_ptr(),
11341        info,
11342    )
11343}
11344
11345#[inline]
11346pub unsafe fn ssysvxx(
11347    fact: u8,
11348    uplo: u8,
11349    n: i32,
11350    nrhs: i32,
11351    a: &mut [f32],
11352    lda: i32,
11353    af: &mut [f32],
11354    ldaf: i32,
11355    ipiv: &mut [i32],
11356    equed: &mut u8,
11357    s: &mut [f32],
11358    b: &mut [f32],
11359    ldb: i32,
11360    x: &mut [f32],
11361    ldx: i32,
11362    rcond: &mut f32,
11363    rpvgrw: &mut f32,
11364    berr: &mut [f32],
11365    n_err_bnds: i32,
11366    err_bnds_norm: &mut [f32],
11367    err_bnds_comp: &mut [f32],
11368    nparams: &[i32],
11369    params: &mut [f32],
11370    work: &mut [f32],
11371    iwork: &mut [i32],
11372    info: &mut i32,
11373) {
11374    ffi::ssysvxx_(
11375        &(fact as c_char),
11376        &(uplo as c_char),
11377        &n,
11378        &nrhs,
11379        a.as_mut_ptr(),
11380        &lda,
11381        af.as_mut_ptr(),
11382        &ldaf,
11383        ipiv.as_mut_ptr(),
11384        equed as *mut _ as *mut _,
11385        s.as_mut_ptr(),
11386        b.as_mut_ptr(),
11387        &ldb,
11388        x.as_mut_ptr(),
11389        &ldx,
11390        rcond,
11391        rpvgrw,
11392        berr.as_mut_ptr(),
11393        &n_err_bnds,
11394        err_bnds_norm.as_mut_ptr(),
11395        err_bnds_comp.as_mut_ptr(),
11396        nparams.as_ptr(),
11397        params.as_mut_ptr(),
11398        work.as_mut_ptr(),
11399        iwork.as_mut_ptr(),
11400        info,
11401    )
11402}
11403
11404#[inline]
11405pub unsafe fn zsysvxx(
11406    fact: u8,
11407    uplo: u8,
11408    n: i32,
11409    nrhs: i32,
11410    a: &mut [c64],
11411    lda: i32,
11412    af: &mut [c64],
11413    ldaf: i32,
11414    ipiv: &mut [i32],
11415    equed: &mut u8,
11416    s: &mut [f64],
11417    b: &mut [c64],
11418    ldb: i32,
11419    x: &mut [c64],
11420    ldx: i32,
11421    rcond: &mut f64,
11422    rpvgrw: &mut f64,
11423    berr: &mut [f64],
11424    n_err_bnds: i32,
11425    err_bnds_norm: &mut [f64],
11426    err_bnds_comp: &mut [f64],
11427    nparams: &[i32],
11428    params: &mut [f64],
11429    work: &mut [c64],
11430    rwork: &mut [f64],
11431    info: &mut i32,
11432) {
11433    ffi::zsysvxx_(
11434        &(fact as c_char),
11435        &(uplo as c_char),
11436        &n,
11437        &nrhs,
11438        a.as_mut_ptr() as *mut _,
11439        &lda,
11440        af.as_mut_ptr() as *mut _,
11441        &ldaf,
11442        ipiv.as_mut_ptr(),
11443        equed as *mut _ as *mut _,
11444        s.as_mut_ptr(),
11445        b.as_mut_ptr() as *mut _,
11446        &ldb,
11447        x.as_mut_ptr() as *mut _,
11448        &ldx,
11449        rcond,
11450        rpvgrw,
11451        berr.as_mut_ptr(),
11452        &n_err_bnds,
11453        err_bnds_norm.as_mut_ptr(),
11454        err_bnds_comp.as_mut_ptr(),
11455        nparams.as_ptr(),
11456        params.as_mut_ptr(),
11457        work.as_mut_ptr() as *mut _,
11458        rwork.as_mut_ptr(),
11459        info,
11460    )
11461}
11462
11463#[inline]
11464pub unsafe fn csysvxx(
11465    fact: u8,
11466    uplo: u8,
11467    n: i32,
11468    nrhs: i32,
11469    a: &mut [c32],
11470    lda: i32,
11471    af: &mut [c32],
11472    ldaf: i32,
11473    ipiv: &mut [i32],
11474    equed: &mut u8,
11475    s: &mut [f32],
11476    b: &mut [c32],
11477    ldb: i32,
11478    x: &mut [c32],
11479    ldx: i32,
11480    rcond: &mut f32,
11481    rpvgrw: &mut f32,
11482    berr: &mut [f32],
11483    n_err_bnds: i32,
11484    err_bnds_norm: &mut [f32],
11485    err_bnds_comp: &mut [f32],
11486    nparams: &[i32],
11487    params: &mut [f32],
11488    work: &mut [c32],
11489    rwork: &mut [f32],
11490    info: &mut i32,
11491) {
11492    ffi::csysvxx_(
11493        &(fact as c_char),
11494        &(uplo as c_char),
11495        &n,
11496        &nrhs,
11497        a.as_mut_ptr() as *mut _,
11498        &lda,
11499        af.as_mut_ptr() as *mut _,
11500        &ldaf,
11501        ipiv.as_mut_ptr(),
11502        equed as *mut _ as *mut _,
11503        s.as_mut_ptr(),
11504        b.as_mut_ptr() as *mut _,
11505        &ldb,
11506        x.as_mut_ptr() as *mut _,
11507        &ldx,
11508        rcond,
11509        rpvgrw,
11510        berr.as_mut_ptr(),
11511        &n_err_bnds,
11512        err_bnds_norm.as_mut_ptr(),
11513        err_bnds_comp.as_mut_ptr(),
11514        nparams.as_ptr(),
11515        params.as_mut_ptr(),
11516        work.as_mut_ptr() as *mut _,
11517        rwork.as_mut_ptr(),
11518        info,
11519    )
11520}
11521
11522#[inline]
11523pub unsafe fn chesv(
11524    uplo: u8,
11525    n: i32,
11526    nrhs: i32,
11527    a: &mut [c32],
11528    lda: i32,
11529    ipiv: &mut [i32],
11530    b: &mut [c32],
11531    ldb: i32,
11532    work: &mut [c32],
11533    lwork: i32,
11534    info: &mut i32,
11535) {
11536    ffi::chesv_(
11537        &(uplo as c_char),
11538        &n,
11539        &nrhs,
11540        a.as_mut_ptr() as *mut _,
11541        &lda,
11542        ipiv.as_mut_ptr(),
11543        b.as_mut_ptr() as *mut _,
11544        &ldb,
11545        work.as_mut_ptr() as *mut _,
11546        &lwork,
11547        info,
11548    )
11549}
11550
11551#[inline]
11552pub unsafe fn zhesv(
11553    uplo: u8,
11554    n: i32,
11555    nrhs: i32,
11556    a: &mut [c64],
11557    lda: i32,
11558    ipiv: &mut [i32],
11559    b: &mut [c64],
11560    ldb: i32,
11561    work: &mut [c64],
11562    lwork: i32,
11563    info: &mut i32,
11564) {
11565    ffi::zhesv_(
11566        &(uplo as c_char),
11567        &n,
11568        &nrhs,
11569        a.as_mut_ptr() as *mut _,
11570        &lda,
11571        ipiv.as_mut_ptr(),
11572        b.as_mut_ptr() as *mut _,
11573        &ldb,
11574        work.as_mut_ptr() as *mut _,
11575        &lwork,
11576        info,
11577    )
11578}
11579
11580#[inline]
11581pub unsafe fn chesvx(
11582    fact: u8,
11583    uplo: u8,
11584    n: i32,
11585    nrhs: i32,
11586    a: &[c32],
11587    lda: i32,
11588    af: &mut [c32],
11589    ldaf: i32,
11590    ipiv: &mut [i32],
11591    b: &[c32],
11592    ldb: i32,
11593    x: &mut [c32],
11594    ldx: i32,
11595    rcond: &mut f32,
11596    ferr: &mut [f32],
11597    berr: &mut [f32],
11598    work: &mut [c32],
11599    lwork: i32,
11600    rwork: &mut [f32],
11601    info: &mut i32,
11602) {
11603    ffi::chesvx_(
11604        &(fact as c_char),
11605        &(uplo as c_char),
11606        &n,
11607        &nrhs,
11608        a.as_ptr() as *const _,
11609        &lda,
11610        af.as_mut_ptr() as *mut _,
11611        &ldaf,
11612        ipiv.as_mut_ptr(),
11613        b.as_ptr() as *const _,
11614        &ldb,
11615        x.as_mut_ptr() as *mut _,
11616        &ldx,
11617        rcond,
11618        ferr.as_mut_ptr(),
11619        berr.as_mut_ptr(),
11620        work.as_mut_ptr() as *mut _,
11621        &lwork,
11622        rwork.as_mut_ptr(),
11623        info,
11624    )
11625}
11626
11627#[inline]
11628pub unsafe fn zhesvx(
11629    fact: u8,
11630    uplo: u8,
11631    n: i32,
11632    nrhs: i32,
11633    a: &[c64],
11634    lda: i32,
11635    af: &mut [c64],
11636    ldaf: i32,
11637    ipiv: &mut [i32],
11638    b: &[c64],
11639    ldb: i32,
11640    x: &mut [c64],
11641    ldx: i32,
11642    rcond: &mut f64,
11643    ferr: &mut [f64],
11644    berr: &mut [f64],
11645    work: &mut [c64],
11646    lwork: i32,
11647    rwork: &mut [f64],
11648    info: &mut i32,
11649) {
11650    ffi::zhesvx_(
11651        &(fact as c_char),
11652        &(uplo as c_char),
11653        &n,
11654        &nrhs,
11655        a.as_ptr() as *const _,
11656        &lda,
11657        af.as_mut_ptr() as *mut _,
11658        &ldaf,
11659        ipiv.as_mut_ptr(),
11660        b.as_ptr() as *const _,
11661        &ldb,
11662        x.as_mut_ptr() as *mut _,
11663        &ldx,
11664        rcond,
11665        ferr.as_mut_ptr(),
11666        berr.as_mut_ptr(),
11667        work.as_mut_ptr() as *mut _,
11668        &lwork,
11669        rwork.as_mut_ptr(),
11670        info,
11671    )
11672}
11673
11674#[inline]
11675pub unsafe fn zhesvxx(
11676    fact: u8,
11677    uplo: u8,
11678    n: i32,
11679    nrhs: i32,
11680    a: &mut [c64],
11681    lda: i32,
11682    af: &mut [c64],
11683    ldaf: i32,
11684    ipiv: &mut [i32],
11685    equed: &mut u8,
11686    s: &mut [f64],
11687    b: &mut [c64],
11688    ldb: i32,
11689    x: &mut [c64],
11690    ldx: i32,
11691    rcond: &mut f64,
11692    rpvgrw: &mut f64,
11693    berr: &mut [f64],
11694    n_err_bnds: i32,
11695    err_bnds_norm: &mut [f64],
11696    err_bnds_comp: &mut [f64],
11697    nparams: &[i32],
11698    params: &mut [f64],
11699    work: &mut [c64],
11700    rwork: &mut [f64],
11701    info: &mut i32,
11702) {
11703    ffi::zhesvxx_(
11704        &(fact as c_char),
11705        &(uplo as c_char),
11706        &n,
11707        &nrhs,
11708        a.as_mut_ptr() as *mut _,
11709        &lda,
11710        af.as_mut_ptr() as *mut _,
11711        &ldaf,
11712        ipiv.as_mut_ptr(),
11713        equed as *mut _ as *mut _,
11714        s.as_mut_ptr(),
11715        b.as_mut_ptr() as *mut _,
11716        &ldb,
11717        x.as_mut_ptr() as *mut _,
11718        &ldx,
11719        rcond,
11720        rpvgrw,
11721        berr.as_mut_ptr(),
11722        &n_err_bnds,
11723        err_bnds_norm.as_mut_ptr(),
11724        err_bnds_comp.as_mut_ptr(),
11725        nparams.as_ptr(),
11726        params.as_mut_ptr(),
11727        work.as_mut_ptr() as *mut _,
11728        rwork.as_mut_ptr(),
11729        info,
11730    )
11731}
11732
11733#[inline]
11734pub unsafe fn chesvxx(
11735    fact: u8,
11736    uplo: u8,
11737    n: i32,
11738    nrhs: i32,
11739    a: &mut [c32],
11740    lda: i32,
11741    af: &mut [c32],
11742    ldaf: i32,
11743    ipiv: &mut [i32],
11744    equed: &mut u8,
11745    s: &mut [f32],
11746    b: &mut [c32],
11747    ldb: i32,
11748    x: &mut [c32],
11749    ldx: i32,
11750    rcond: &mut f32,
11751    rpvgrw: &mut f32,
11752    berr: &mut [f32],
11753    n_err_bnds: i32,
11754    err_bnds_norm: &mut [f32],
11755    err_bnds_comp: &mut [f32],
11756    nparams: &[i32],
11757    params: &mut [f32],
11758    work: &mut [c32],
11759    rwork: &mut [f32],
11760    info: &mut i32,
11761) {
11762    ffi::chesvxx_(
11763        &(fact as c_char),
11764        &(uplo as c_char),
11765        &n,
11766        &nrhs,
11767        a.as_mut_ptr() as *mut _,
11768        &lda,
11769        af.as_mut_ptr() as *mut _,
11770        &ldaf,
11771        ipiv.as_mut_ptr(),
11772        equed as *mut _ as *mut _,
11773        s.as_mut_ptr(),
11774        b.as_mut_ptr() as *mut _,
11775        &ldb,
11776        x.as_mut_ptr() as *mut _,
11777        &ldx,
11778        rcond,
11779        rpvgrw,
11780        berr.as_mut_ptr(),
11781        &n_err_bnds,
11782        err_bnds_norm.as_mut_ptr(),
11783        err_bnds_comp.as_mut_ptr(),
11784        nparams.as_ptr(),
11785        params.as_mut_ptr(),
11786        work.as_mut_ptr() as *mut _,
11787        rwork.as_mut_ptr(),
11788        info,
11789    )
11790}
11791
11792#[inline]
11793pub unsafe fn sspsv(
11794    uplo: u8,
11795    n: i32,
11796    nrhs: i32,
11797    ap: &mut [f32],
11798    ipiv: &mut [i32],
11799    b: &mut [f32],
11800    ldb: i32,
11801    info: &mut i32,
11802) {
11803    ffi::sspsv_(
11804        &(uplo as c_char),
11805        &n,
11806        &nrhs,
11807        ap.as_mut_ptr(),
11808        ipiv.as_mut_ptr(),
11809        b.as_mut_ptr(),
11810        &ldb,
11811        info,
11812    )
11813}
11814
11815#[inline]
11816pub unsafe fn dspsv(
11817    uplo: u8,
11818    n: i32,
11819    nrhs: i32,
11820    ap: &mut [f64],
11821    ipiv: &mut [i32],
11822    b: &mut [f64],
11823    ldb: i32,
11824    info: &mut i32,
11825) {
11826    ffi::dspsv_(
11827        &(uplo as c_char),
11828        &n,
11829        &nrhs,
11830        ap.as_mut_ptr(),
11831        ipiv.as_mut_ptr(),
11832        b.as_mut_ptr(),
11833        &ldb,
11834        info,
11835    )
11836}
11837
11838#[inline]
11839pub unsafe fn cspsv(
11840    uplo: u8,
11841    n: i32,
11842    nrhs: i32,
11843    ap: &mut [c32],
11844    ipiv: &mut [i32],
11845    b: &mut [c32],
11846    ldb: i32,
11847    info: &mut i32,
11848) {
11849    ffi::cspsv_(
11850        &(uplo as c_char),
11851        &n,
11852        &nrhs,
11853        ap.as_mut_ptr() as *mut _,
11854        ipiv.as_mut_ptr(),
11855        b.as_mut_ptr() as *mut _,
11856        &ldb,
11857        info,
11858    )
11859}
11860
11861#[inline]
11862pub unsafe fn zspsv(
11863    uplo: u8,
11864    n: i32,
11865    nrhs: i32,
11866    ap: &mut [c64],
11867    ipiv: &mut [i32],
11868    b: &mut [c64],
11869    ldb: i32,
11870    info: &mut i32,
11871) {
11872    ffi::zspsv_(
11873        &(uplo as c_char),
11874        &n,
11875        &nrhs,
11876        ap.as_mut_ptr() as *mut _,
11877        ipiv.as_mut_ptr(),
11878        b.as_mut_ptr() as *mut _,
11879        &ldb,
11880        info,
11881    )
11882}
11883
11884#[inline]
11885pub unsafe fn sspsvx(
11886    fact: u8,
11887    uplo: u8,
11888    n: i32,
11889    nrhs: i32,
11890    ap: &[f32],
11891    afp: &mut [f32],
11892    ipiv: &mut [i32],
11893    b: &[f32],
11894    ldb: i32,
11895    x: &mut [f32],
11896    ldx: i32,
11897    rcond: &mut f32,
11898    ferr: &mut [f32],
11899    berr: &mut [f32],
11900    work: &mut [f32],
11901    iwork: &mut [i32],
11902    info: &mut i32,
11903) {
11904    ffi::sspsvx_(
11905        &(fact as c_char),
11906        &(uplo as c_char),
11907        &n,
11908        &nrhs,
11909        ap.as_ptr(),
11910        afp.as_mut_ptr(),
11911        ipiv.as_mut_ptr(),
11912        b.as_ptr(),
11913        &ldb,
11914        x.as_mut_ptr(),
11915        &ldx,
11916        rcond,
11917        ferr.as_mut_ptr(),
11918        berr.as_mut_ptr(),
11919        work.as_mut_ptr(),
11920        iwork.as_mut_ptr(),
11921        info,
11922    )
11923}
11924
11925#[inline]
11926pub unsafe fn dspsvx(
11927    fact: u8,
11928    uplo: u8,
11929    n: i32,
11930    nrhs: i32,
11931    ap: &[f64],
11932    afp: &mut [f64],
11933    ipiv: &mut [i32],
11934    b: &[f64],
11935    ldb: i32,
11936    x: &mut [f64],
11937    ldx: i32,
11938    rcond: &mut f64,
11939    ferr: &mut [f64],
11940    berr: &mut [f64],
11941    work: &mut [f64],
11942    iwork: &mut [i32],
11943    info: &mut i32,
11944) {
11945    ffi::dspsvx_(
11946        &(fact as c_char),
11947        &(uplo as c_char),
11948        &n,
11949        &nrhs,
11950        ap.as_ptr(),
11951        afp.as_mut_ptr(),
11952        ipiv.as_mut_ptr(),
11953        b.as_ptr(),
11954        &ldb,
11955        x.as_mut_ptr(),
11956        &ldx,
11957        rcond,
11958        ferr.as_mut_ptr(),
11959        berr.as_mut_ptr(),
11960        work.as_mut_ptr(),
11961        iwork.as_mut_ptr(),
11962        info,
11963    )
11964}
11965
11966#[inline]
11967pub unsafe fn cspsvx(
11968    fact: u8,
11969    uplo: u8,
11970    n: i32,
11971    nrhs: i32,
11972    ap: &[c32],
11973    afp: &mut [c32],
11974    ipiv: &mut [i32],
11975    b: &[c32],
11976    ldb: i32,
11977    x: &mut [c32],
11978    ldx: i32,
11979    rcond: &mut f32,
11980    ferr: &mut [f32],
11981    berr: &mut [f32],
11982    work: &mut [c32],
11983    rwork: &mut [f32],
11984    info: &mut i32,
11985) {
11986    ffi::cspsvx_(
11987        &(fact as c_char),
11988        &(uplo as c_char),
11989        &n,
11990        &nrhs,
11991        ap.as_ptr() as *const _,
11992        afp.as_mut_ptr() as *mut _,
11993        ipiv.as_mut_ptr(),
11994        b.as_ptr() as *const _,
11995        &ldb,
11996        x.as_mut_ptr() as *mut _,
11997        &ldx,
11998        rcond,
11999        ferr.as_mut_ptr(),
12000        berr.as_mut_ptr(),
12001        work.as_mut_ptr() as *mut _,
12002        rwork.as_mut_ptr(),
12003        info,
12004    )
12005}
12006
12007#[inline]
12008pub unsafe fn zspsvx(
12009    fact: u8,
12010    uplo: u8,
12011    n: i32,
12012    nrhs: i32,
12013    ap: &[c64],
12014    afp: &mut [c64],
12015    ipiv: &mut [i32],
12016    b: &[c64],
12017    ldb: i32,
12018    x: &mut [c64],
12019    ldx: i32,
12020    rcond: &mut f64,
12021    ferr: &mut [f64],
12022    berr: &mut [f64],
12023    work: &mut [c64],
12024    rwork: &mut [f64],
12025    info: &mut i32,
12026) {
12027    ffi::zspsvx_(
12028        &(fact as c_char),
12029        &(uplo as c_char),
12030        &n,
12031        &nrhs,
12032        ap.as_ptr() as *const _,
12033        afp.as_mut_ptr() as *mut _,
12034        ipiv.as_mut_ptr(),
12035        b.as_ptr() as *const _,
12036        &ldb,
12037        x.as_mut_ptr() as *mut _,
12038        &ldx,
12039        rcond,
12040        ferr.as_mut_ptr(),
12041        berr.as_mut_ptr(),
12042        work.as_mut_ptr() as *mut _,
12043        rwork.as_mut_ptr(),
12044        info,
12045    )
12046}
12047
12048#[inline]
12049pub unsafe fn chpsv(
12050    uplo: u8,
12051    n: i32,
12052    nrhs: i32,
12053    ap: &mut [c32],
12054    ipiv: &mut [i32],
12055    b: &mut [c32],
12056    ldb: i32,
12057    info: &mut i32,
12058) {
12059    ffi::chpsv_(
12060        &(uplo as c_char),
12061        &n,
12062        &nrhs,
12063        ap.as_mut_ptr() as *mut _,
12064        ipiv.as_mut_ptr(),
12065        b.as_mut_ptr() as *mut _,
12066        &ldb,
12067        info,
12068    )
12069}
12070
12071#[inline]
12072pub unsafe fn zhpsv(
12073    uplo: u8,
12074    n: i32,
12075    nrhs: i32,
12076    ap: &mut [c64],
12077    ipiv: &mut [i32],
12078    b: &mut [c64],
12079    ldb: i32,
12080    info: &mut i32,
12081) {
12082    ffi::zhpsv_(
12083        &(uplo as c_char),
12084        &n,
12085        &nrhs,
12086        ap.as_mut_ptr() as *mut _,
12087        ipiv.as_mut_ptr(),
12088        b.as_mut_ptr() as *mut _,
12089        &ldb,
12090        info,
12091    )
12092}
12093
12094#[inline]
12095pub unsafe fn chpsvx(
12096    fact: u8,
12097    uplo: u8,
12098    n: i32,
12099    nrhs: i32,
12100    ap: &[c32],
12101    afp: &mut [c32],
12102    ipiv: &mut [i32],
12103    b: &[c32],
12104    ldb: i32,
12105    x: &mut [c32],
12106    ldx: i32,
12107    rcond: &mut f32,
12108    ferr: &mut [f32],
12109    berr: &mut [f32],
12110    work: &mut [c32],
12111    rwork: &mut [f32],
12112    info: &mut i32,
12113) {
12114    ffi::chpsvx_(
12115        &(fact as c_char),
12116        &(uplo as c_char),
12117        &n,
12118        &nrhs,
12119        ap.as_ptr() as *const _,
12120        afp.as_mut_ptr() as *mut _,
12121        ipiv.as_mut_ptr(),
12122        b.as_ptr() as *const _,
12123        &ldb,
12124        x.as_mut_ptr() as *mut _,
12125        &ldx,
12126        rcond,
12127        ferr.as_mut_ptr(),
12128        berr.as_mut_ptr(),
12129        work.as_mut_ptr() as *mut _,
12130        rwork.as_mut_ptr(),
12131        info,
12132    )
12133}
12134
12135#[inline]
12136pub unsafe fn zhpsvx(
12137    fact: u8,
12138    uplo: u8,
12139    n: i32,
12140    nrhs: i32,
12141    ap: &[c64],
12142    afp: &mut [c64],
12143    ipiv: &mut [i32],
12144    b: &[c64],
12145    ldb: i32,
12146    x: &mut [c64],
12147    ldx: i32,
12148    rcond: &mut f64,
12149    ferr: &mut [f64],
12150    berr: &mut [f64],
12151    work: &mut [c64],
12152    rwork: &mut [f64],
12153    info: &mut i32,
12154) {
12155    ffi::zhpsvx_(
12156        &(fact as c_char),
12157        &(uplo as c_char),
12158        &n,
12159        &nrhs,
12160        ap.as_ptr() as *const _,
12161        afp.as_mut_ptr() as *mut _,
12162        ipiv.as_mut_ptr(),
12163        b.as_ptr() as *const _,
12164        &ldb,
12165        x.as_mut_ptr() as *mut _,
12166        &ldx,
12167        rcond,
12168        ferr.as_mut_ptr(),
12169        berr.as_mut_ptr(),
12170        work.as_mut_ptr() as *mut _,
12171        rwork.as_mut_ptr(),
12172        info,
12173    )
12174}
12175
12176#[inline]
12177pub unsafe fn sgeqrf(
12178    m: i32,
12179    n: i32,
12180    a: &mut [f32],
12181    lda: i32,
12182    tau: &mut [f32],
12183    work: &mut [f32],
12184    lwork: i32,
12185    info: &mut i32,
12186) {
12187    ffi::sgeqrf_(
12188        &m,
12189        &n,
12190        a.as_mut_ptr(),
12191        &lda,
12192        tau.as_mut_ptr(),
12193        work.as_mut_ptr(),
12194        &lwork,
12195        info,
12196    )
12197}
12198
12199#[inline]
12200pub unsafe fn dgeqrf(
12201    m: i32,
12202    n: i32,
12203    a: &mut [f64],
12204    lda: i32,
12205    tau: &mut [f64],
12206    work: &mut [f64],
12207    lwork: i32,
12208    info: &mut i32,
12209) {
12210    ffi::dgeqrf_(
12211        &m,
12212        &n,
12213        a.as_mut_ptr(),
12214        &lda,
12215        tau.as_mut_ptr(),
12216        work.as_mut_ptr(),
12217        &lwork,
12218        info,
12219    )
12220}
12221
12222#[inline]
12223pub unsafe fn cgeqrf(
12224    m: i32,
12225    n: i32,
12226    a: &mut [c32],
12227    lda: i32,
12228    tau: &mut [c32],
12229    work: &mut [c32],
12230    lwork: i32,
12231    info: &mut i32,
12232) {
12233    ffi::cgeqrf_(
12234        &m,
12235        &n,
12236        a.as_mut_ptr() as *mut _,
12237        &lda,
12238        tau.as_mut_ptr() as *mut _,
12239        work.as_mut_ptr() as *mut _,
12240        &lwork,
12241        info,
12242    )
12243}
12244
12245#[inline]
12246pub unsafe fn zgeqrf(
12247    m: i32,
12248    n: i32,
12249    a: &mut [c64],
12250    lda: i32,
12251    tau: &mut [c64],
12252    work: &mut [c64],
12253    lwork: i32,
12254    info: &mut i32,
12255) {
12256    ffi::zgeqrf_(
12257        &m,
12258        &n,
12259        a.as_mut_ptr() as *mut _,
12260        &lda,
12261        tau.as_mut_ptr() as *mut _,
12262        work.as_mut_ptr() as *mut _,
12263        &lwork,
12264        info,
12265    )
12266}
12267
12268#[inline]
12269pub unsafe fn sgeqpf(
12270    m: i32,
12271    n: i32,
12272    a: &mut [f32],
12273    lda: i32,
12274    jpvt: &mut [i32],
12275    tau: &mut [f32],
12276    work: &mut [f32],
12277    info: &mut i32,
12278) {
12279    ffi::sgeqpf_(
12280        &m,
12281        &n,
12282        a.as_mut_ptr(),
12283        &lda,
12284        jpvt.as_mut_ptr(),
12285        tau.as_mut_ptr(),
12286        work.as_mut_ptr(),
12287        info,
12288    )
12289}
12290
12291#[inline]
12292pub unsafe fn dgeqpf(
12293    m: i32,
12294    n: i32,
12295    a: &mut [f64],
12296    lda: i32,
12297    jpvt: &mut [i32],
12298    tau: &mut [f64],
12299    work: &mut [f64],
12300    info: &mut i32,
12301) {
12302    ffi::dgeqpf_(
12303        &m,
12304        &n,
12305        a.as_mut_ptr(),
12306        &lda,
12307        jpvt.as_mut_ptr(),
12308        tau.as_mut_ptr(),
12309        work.as_mut_ptr(),
12310        info,
12311    )
12312}
12313
12314#[inline]
12315pub unsafe fn cgeqpf(
12316    m: i32,
12317    n: i32,
12318    a: &mut [c32],
12319    lda: i32,
12320    jpvt: &mut [i32],
12321    tau: &mut [c32],
12322    work: &mut [c32],
12323    rwork: &mut [f32],
12324    info: &mut i32,
12325) {
12326    ffi::cgeqpf_(
12327        &m,
12328        &n,
12329        a.as_mut_ptr() as *mut _,
12330        &lda,
12331        jpvt.as_mut_ptr(),
12332        tau.as_mut_ptr() as *mut _,
12333        work.as_mut_ptr() as *mut _,
12334        rwork.as_mut_ptr(),
12335        info,
12336    )
12337}
12338
12339#[inline]
12340pub unsafe fn zgeqpf(
12341    m: i32,
12342    n: i32,
12343    a: &mut [c64],
12344    lda: i32,
12345    jpvt: &mut [i32],
12346    tau: &mut [c64],
12347    work: &mut [c64],
12348    rwork: &mut [f64],
12349    info: &mut i32,
12350) {
12351    ffi::zgeqpf_(
12352        &m,
12353        &n,
12354        a.as_mut_ptr() as *mut _,
12355        &lda,
12356        jpvt.as_mut_ptr(),
12357        tau.as_mut_ptr() as *mut _,
12358        work.as_mut_ptr() as *mut _,
12359        rwork.as_mut_ptr(),
12360        info,
12361    )
12362}
12363
12364#[inline]
12365pub unsafe fn sgeqp3(
12366    m: i32,
12367    n: i32,
12368    a: &mut [f32],
12369    lda: i32,
12370    jpvt: &mut [i32],
12371    tau: &mut [f32],
12372    work: &mut [f32],
12373    lwork: i32,
12374    info: &mut i32,
12375) {
12376    ffi::sgeqp3_(
12377        &m,
12378        &n,
12379        a.as_mut_ptr(),
12380        &lda,
12381        jpvt.as_mut_ptr(),
12382        tau.as_mut_ptr(),
12383        work.as_mut_ptr(),
12384        &lwork,
12385        info,
12386    )
12387}
12388
12389#[inline]
12390pub unsafe fn dgeqp3(
12391    m: i32,
12392    n: i32,
12393    a: &mut [f64],
12394    lda: i32,
12395    jpvt: &mut [i32],
12396    tau: &mut [f64],
12397    work: &mut [f64],
12398    lwork: i32,
12399    info: &mut i32,
12400) {
12401    ffi::dgeqp3_(
12402        &m,
12403        &n,
12404        a.as_mut_ptr(),
12405        &lda,
12406        jpvt.as_mut_ptr(),
12407        tau.as_mut_ptr(),
12408        work.as_mut_ptr(),
12409        &lwork,
12410        info,
12411    )
12412}
12413
12414#[inline]
12415pub unsafe fn cgeqp3(
12416    m: i32,
12417    n: i32,
12418    a: &mut [c32],
12419    lda: i32,
12420    jpvt: &mut [i32],
12421    tau: &mut [c32],
12422    work: &mut [c32],
12423    lwork: i32,
12424    rwork: &mut [f32],
12425    info: &mut i32,
12426) {
12427    ffi::cgeqp3_(
12428        &m,
12429        &n,
12430        a.as_mut_ptr() as *mut _,
12431        &lda,
12432        jpvt.as_mut_ptr(),
12433        tau.as_mut_ptr() as *mut _,
12434        work.as_mut_ptr() as *mut _,
12435        &lwork,
12436        rwork.as_mut_ptr(),
12437        info,
12438    )
12439}
12440
12441#[inline]
12442pub unsafe fn zgeqp3(
12443    m: i32,
12444    n: i32,
12445    a: &mut [c64],
12446    lda: i32,
12447    jpvt: &mut [i32],
12448    tau: &mut [c64],
12449    work: &mut [c64],
12450    lwork: i32,
12451    rwork: &mut [f64],
12452    info: &mut i32,
12453) {
12454    ffi::zgeqp3_(
12455        &m,
12456        &n,
12457        a.as_mut_ptr() as *mut _,
12458        &lda,
12459        jpvt.as_mut_ptr(),
12460        tau.as_mut_ptr() as *mut _,
12461        work.as_mut_ptr() as *mut _,
12462        &lwork,
12463        rwork.as_mut_ptr(),
12464        info,
12465    )
12466}
12467
12468#[inline]
12469pub unsafe fn sorgqr(
12470    m: i32,
12471    n: i32,
12472    k: i32,
12473    a: &mut [f32],
12474    lda: i32,
12475    tau: &[f32],
12476    work: &mut [f32],
12477    lwork: i32,
12478    info: &mut i32,
12479) {
12480    ffi::sorgqr_(
12481        &m,
12482        &n,
12483        &k,
12484        a.as_mut_ptr(),
12485        &lda,
12486        tau.as_ptr(),
12487        work.as_mut_ptr(),
12488        &lwork,
12489        info,
12490    )
12491}
12492
12493#[inline]
12494pub unsafe fn dorgqr(
12495    m: i32,
12496    n: i32,
12497    k: i32,
12498    a: &mut [f64],
12499    lda: i32,
12500    tau: &[f64],
12501    work: &mut [f64],
12502    lwork: i32,
12503    info: &mut i32,
12504) {
12505    ffi::dorgqr_(
12506        &m,
12507        &n,
12508        &k,
12509        a.as_mut_ptr(),
12510        &lda,
12511        tau.as_ptr(),
12512        work.as_mut_ptr(),
12513        &lwork,
12514        info,
12515    )
12516}
12517
12518#[inline]
12519pub unsafe fn sormqr(
12520    side: u8,
12521    trans: u8,
12522    m: i32,
12523    n: i32,
12524    k: i32,
12525    a: &[f32],
12526    lda: i32,
12527    tau: &[f32],
12528    c: &mut [f32],
12529    ldc: i32,
12530    work: &mut [f32],
12531    lwork: i32,
12532    info: &mut i32,
12533) {
12534    ffi::sormqr_(
12535        &(side as c_char),
12536        &(trans as c_char),
12537        &m,
12538        &n,
12539        &k,
12540        a.as_ptr(),
12541        &lda,
12542        tau.as_ptr(),
12543        c.as_mut_ptr(),
12544        &ldc,
12545        work.as_mut_ptr(),
12546        &lwork,
12547        info,
12548    )
12549}
12550
12551#[inline]
12552pub unsafe fn dormqr(
12553    side: u8,
12554    trans: u8,
12555    m: i32,
12556    n: i32,
12557    k: i32,
12558    a: &[f64],
12559    lda: i32,
12560    tau: &[f64],
12561    c: &mut [f64],
12562    ldc: i32,
12563    work: &mut [f64],
12564    lwork: i32,
12565    info: &mut i32,
12566) {
12567    ffi::dormqr_(
12568        &(side as c_char),
12569        &(trans as c_char),
12570        &m,
12571        &n,
12572        &k,
12573        a.as_ptr(),
12574        &lda,
12575        tau.as_ptr(),
12576        c.as_mut_ptr(),
12577        &ldc,
12578        work.as_mut_ptr(),
12579        &lwork,
12580        info,
12581    )
12582}
12583
12584#[inline]
12585pub unsafe fn cungqr(
12586    m: i32,
12587    n: i32,
12588    k: i32,
12589    a: &mut [c32],
12590    lda: i32,
12591    tau: &[c32],
12592    work: &mut [c32],
12593    lwork: i32,
12594    info: &mut i32,
12595) {
12596    ffi::cungqr_(
12597        &m,
12598        &n,
12599        &k,
12600        a.as_mut_ptr() as *mut _,
12601        &lda,
12602        tau.as_ptr() as *const _,
12603        work.as_mut_ptr() as *mut _,
12604        &lwork,
12605        info,
12606    )
12607}
12608
12609#[inline]
12610pub unsafe fn zungqr(
12611    m: i32,
12612    n: i32,
12613    k: i32,
12614    a: &mut [c64],
12615    lda: i32,
12616    tau: &[c64],
12617    work: &mut [c64],
12618    lwork: i32,
12619    info: &mut i32,
12620) {
12621    ffi::zungqr_(
12622        &m,
12623        &n,
12624        &k,
12625        a.as_mut_ptr() as *mut _,
12626        &lda,
12627        tau.as_ptr() as *const _,
12628        work.as_mut_ptr() as *mut _,
12629        &lwork,
12630        info,
12631    )
12632}
12633
12634#[inline]
12635pub unsafe fn cunmqr(
12636    side: u8,
12637    trans: u8,
12638    m: i32,
12639    n: i32,
12640    k: i32,
12641    a: &[c32],
12642    lda: i32,
12643    tau: &[c32],
12644    c: &mut [c32],
12645    ldc: i32,
12646    work: &mut [c32],
12647    lwork: i32,
12648    info: &mut i32,
12649) {
12650    ffi::cunmqr_(
12651        &(side as c_char),
12652        &(trans as c_char),
12653        &m,
12654        &n,
12655        &k,
12656        a.as_ptr() as *const _,
12657        &lda,
12658        tau.as_ptr() as *const _,
12659        c.as_mut_ptr() as *mut _,
12660        &ldc,
12661        work.as_mut_ptr() as *mut _,
12662        &lwork,
12663        info,
12664    )
12665}
12666
12667#[inline]
12668pub unsafe fn zunmqr(
12669    side: u8,
12670    trans: u8,
12671    m: i32,
12672    n: i32,
12673    k: i32,
12674    a: &[c64],
12675    lda: i32,
12676    tau: &[c64],
12677    c: &mut [c64],
12678    ldc: i32,
12679    work: &mut [c64],
12680    lwork: i32,
12681    info: &mut i32,
12682) {
12683    ffi::zunmqr_(
12684        &(side as c_char),
12685        &(trans as c_char),
12686        &m,
12687        &n,
12688        &k,
12689        a.as_ptr() as *const _,
12690        &lda,
12691        tau.as_ptr() as *const _,
12692        c.as_mut_ptr() as *mut _,
12693        &ldc,
12694        work.as_mut_ptr() as *mut _,
12695        &lwork,
12696        info,
12697    )
12698}
12699
12700#[inline]
12701pub unsafe fn sgelqf(
12702    m: i32,
12703    n: i32,
12704    a: &mut [f32],
12705    lda: i32,
12706    tau: &mut [f32],
12707    work: &mut [f32],
12708    lwork: i32,
12709    info: &mut i32,
12710) {
12711    ffi::sgelqf_(
12712        &m,
12713        &n,
12714        a.as_mut_ptr(),
12715        &lda,
12716        tau.as_mut_ptr(),
12717        work.as_mut_ptr(),
12718        &lwork,
12719        info,
12720    )
12721}
12722
12723#[inline]
12724pub unsafe fn dgelqf(
12725    m: i32,
12726    n: i32,
12727    a: &mut [f64],
12728    lda: i32,
12729    tau: &mut [f64],
12730    work: &mut [f64],
12731    lwork: i32,
12732    info: &mut i32,
12733) {
12734    ffi::dgelqf_(
12735        &m,
12736        &n,
12737        a.as_mut_ptr(),
12738        &lda,
12739        tau.as_mut_ptr(),
12740        work.as_mut_ptr(),
12741        &lwork,
12742        info,
12743    )
12744}
12745
12746#[inline]
12747pub unsafe fn cgelqf(
12748    m: i32,
12749    n: i32,
12750    a: &mut [c32],
12751    lda: i32,
12752    tau: &mut [c32],
12753    work: &mut [c32],
12754    lwork: i32,
12755    info: &mut i32,
12756) {
12757    ffi::cgelqf_(
12758        &m,
12759        &n,
12760        a.as_mut_ptr() as *mut _,
12761        &lda,
12762        tau.as_mut_ptr() as *mut _,
12763        work.as_mut_ptr() as *mut _,
12764        &lwork,
12765        info,
12766    )
12767}
12768
12769#[inline]
12770pub unsafe fn zgelqf(
12771    m: i32,
12772    n: i32,
12773    a: &mut [c64],
12774    lda: i32,
12775    tau: &mut [c64],
12776    work: &mut [c64],
12777    lwork: i32,
12778    info: &mut i32,
12779) {
12780    ffi::zgelqf_(
12781        &m,
12782        &n,
12783        a.as_mut_ptr() as *mut _,
12784        &lda,
12785        tau.as_mut_ptr() as *mut _,
12786        work.as_mut_ptr() as *mut _,
12787        &lwork,
12788        info,
12789    )
12790}
12791
12792#[inline]
12793pub unsafe fn sorglq(
12794    m: i32,
12795    n: i32,
12796    k: i32,
12797    a: &mut [f32],
12798    lda: i32,
12799    tau: &[f32],
12800    work: &mut [f32],
12801    lwork: i32,
12802    info: &mut i32,
12803) {
12804    ffi::sorglq_(
12805        &m,
12806        &n,
12807        &k,
12808        a.as_mut_ptr(),
12809        &lda,
12810        tau.as_ptr(),
12811        work.as_mut_ptr(),
12812        &lwork,
12813        info,
12814    )
12815}
12816
12817#[inline]
12818pub unsafe fn dorglq(
12819    m: i32,
12820    n: i32,
12821    k: i32,
12822    a: &mut [f64],
12823    lda: i32,
12824    tau: &[f64],
12825    work: &mut [f64],
12826    lwork: i32,
12827    info: &mut i32,
12828) {
12829    ffi::dorglq_(
12830        &m,
12831        &n,
12832        &k,
12833        a.as_mut_ptr(),
12834        &lda,
12835        tau.as_ptr(),
12836        work.as_mut_ptr(),
12837        &lwork,
12838        info,
12839    )
12840}
12841
12842#[inline]
12843pub unsafe fn sormlq(
12844    side: u8,
12845    trans: u8,
12846    m: i32,
12847    n: i32,
12848    k: i32,
12849    a: &[f32],
12850    lda: i32,
12851    tau: &[f32],
12852    c: &mut [f32],
12853    ldc: i32,
12854    work: &mut [f32],
12855    lwork: i32,
12856    info: &mut i32,
12857) {
12858    ffi::sormlq_(
12859        &(side as c_char),
12860        &(trans as c_char),
12861        &m,
12862        &n,
12863        &k,
12864        a.as_ptr(),
12865        &lda,
12866        tau.as_ptr(),
12867        c.as_mut_ptr(),
12868        &ldc,
12869        work.as_mut_ptr(),
12870        &lwork,
12871        info,
12872    )
12873}
12874
12875#[inline]
12876pub unsafe fn dormlq(
12877    side: u8,
12878    trans: u8,
12879    m: i32,
12880    n: i32,
12881    k: i32,
12882    a: &[f64],
12883    lda: i32,
12884    tau: &[f64],
12885    c: &mut [f64],
12886    ldc: i32,
12887    work: &mut [f64],
12888    lwork: i32,
12889    info: &mut i32,
12890) {
12891    ffi::dormlq_(
12892        &(side as c_char),
12893        &(trans as c_char),
12894        &m,
12895        &n,
12896        &k,
12897        a.as_ptr(),
12898        &lda,
12899        tau.as_ptr(),
12900        c.as_mut_ptr(),
12901        &ldc,
12902        work.as_mut_ptr(),
12903        &lwork,
12904        info,
12905    )
12906}
12907
12908#[inline]
12909pub unsafe fn cunglq(
12910    m: i32,
12911    n: i32,
12912    k: i32,
12913    a: &mut [c32],
12914    lda: i32,
12915    tau: &[c32],
12916    work: &mut [c32],
12917    lwork: i32,
12918    info: &mut i32,
12919) {
12920    ffi::cunglq_(
12921        &m,
12922        &n,
12923        &k,
12924        a.as_mut_ptr() as *mut _,
12925        &lda,
12926        tau.as_ptr() as *const _,
12927        work.as_mut_ptr() as *mut _,
12928        &lwork,
12929        info,
12930    )
12931}
12932
12933#[inline]
12934pub unsafe fn zunglq(
12935    m: i32,
12936    n: i32,
12937    k: i32,
12938    a: &mut [c64],
12939    lda: i32,
12940    tau: &[c64],
12941    work: &mut [c64],
12942    lwork: i32,
12943    info: &mut i32,
12944) {
12945    ffi::zunglq_(
12946        &m,
12947        &n,
12948        &k,
12949        a.as_mut_ptr() as *mut _,
12950        &lda,
12951        tau.as_ptr() as *const _,
12952        work.as_mut_ptr() as *mut _,
12953        &lwork,
12954        info,
12955    )
12956}
12957
12958#[inline]
12959pub unsafe fn cunmlq(
12960    side: u8,
12961    trans: u8,
12962    m: i32,
12963    n: i32,
12964    k: i32,
12965    a: &[c32],
12966    lda: i32,
12967    tau: &[c32],
12968    c: &mut [c32],
12969    ldc: i32,
12970    work: &mut [c32],
12971    lwork: i32,
12972    info: &mut i32,
12973) {
12974    ffi::cunmlq_(
12975        &(side as c_char),
12976        &(trans as c_char),
12977        &m,
12978        &n,
12979        &k,
12980        a.as_ptr() as *const _,
12981        &lda,
12982        tau.as_ptr() as *const _,
12983        c.as_mut_ptr() as *mut _,
12984        &ldc,
12985        work.as_mut_ptr() as *mut _,
12986        &lwork,
12987        info,
12988    )
12989}
12990
12991#[inline]
12992pub unsafe fn zunmlq(
12993    side: u8,
12994    trans: u8,
12995    m: i32,
12996    n: i32,
12997    k: i32,
12998    a: &[c64],
12999    lda: i32,
13000    tau: &[c64],
13001    c: &mut [c64],
13002    ldc: i32,
13003    work: &mut [c64],
13004    lwork: i32,
13005    info: &mut i32,
13006) {
13007    ffi::zunmlq_(
13008        &(side as c_char),
13009        &(trans as c_char),
13010        &m,
13011        &n,
13012        &k,
13013        a.as_ptr() as *const _,
13014        &lda,
13015        tau.as_ptr() as *const _,
13016        c.as_mut_ptr() as *mut _,
13017        &ldc,
13018        work.as_mut_ptr() as *mut _,
13019        &lwork,
13020        info,
13021    )
13022}
13023
13024#[inline]
13025pub unsafe fn sgeqlf(
13026    m: i32,
13027    n: i32,
13028    a: &mut [f32],
13029    lda: i32,
13030    tau: &mut [f32],
13031    work: &mut [f32],
13032    lwork: i32,
13033    info: &mut i32,
13034) {
13035    ffi::sgeqlf_(
13036        &m,
13037        &n,
13038        a.as_mut_ptr(),
13039        &lda,
13040        tau.as_mut_ptr(),
13041        work.as_mut_ptr(),
13042        &lwork,
13043        info,
13044    )
13045}
13046
13047#[inline]
13048pub unsafe fn dgeqlf(
13049    m: i32,
13050    n: i32,
13051    a: &mut [f64],
13052    lda: i32,
13053    tau: &mut [f64],
13054    work: &mut [f64],
13055    lwork: i32,
13056    info: &mut i32,
13057) {
13058    ffi::dgeqlf_(
13059        &m,
13060        &n,
13061        a.as_mut_ptr(),
13062        &lda,
13063        tau.as_mut_ptr(),
13064        work.as_mut_ptr(),
13065        &lwork,
13066        info,
13067    )
13068}
13069
13070#[inline]
13071pub unsafe fn cgeqlf(
13072    m: i32,
13073    n: i32,
13074    a: &mut [c32],
13075    lda: i32,
13076    tau: &mut [c32],
13077    work: &mut [c32],
13078    lwork: i32,
13079    info: &mut i32,
13080) {
13081    ffi::cgeqlf_(
13082        &m,
13083        &n,
13084        a.as_mut_ptr() as *mut _,
13085        &lda,
13086        tau.as_mut_ptr() as *mut _,
13087        work.as_mut_ptr() as *mut _,
13088        &lwork,
13089        info,
13090    )
13091}
13092
13093#[inline]
13094pub unsafe fn zgeqlf(
13095    m: i32,
13096    n: i32,
13097    a: &mut [c64],
13098    lda: i32,
13099    tau: &mut [c64],
13100    work: &mut [c64],
13101    lwork: i32,
13102    info: &mut i32,
13103) {
13104    ffi::zgeqlf_(
13105        &m,
13106        &n,
13107        a.as_mut_ptr() as *mut _,
13108        &lda,
13109        tau.as_mut_ptr() as *mut _,
13110        work.as_mut_ptr() as *mut _,
13111        &lwork,
13112        info,
13113    )
13114}
13115
13116#[inline]
13117pub unsafe fn sorgql(
13118    m: i32,
13119    n: i32,
13120    k: i32,
13121    a: &mut [f32],
13122    lda: i32,
13123    tau: &[f32],
13124    work: &mut [f32],
13125    lwork: i32,
13126    info: &mut i32,
13127) {
13128    ffi::sorgql_(
13129        &m,
13130        &n,
13131        &k,
13132        a.as_mut_ptr(),
13133        &lda,
13134        tau.as_ptr(),
13135        work.as_mut_ptr(),
13136        &lwork,
13137        info,
13138    )
13139}
13140
13141#[inline]
13142pub unsafe fn dorgql(
13143    m: i32,
13144    n: i32,
13145    k: i32,
13146    a: &mut [f64],
13147    lda: i32,
13148    tau: &[f64],
13149    work: &mut [f64],
13150    lwork: i32,
13151    info: &mut i32,
13152) {
13153    ffi::dorgql_(
13154        &m,
13155        &n,
13156        &k,
13157        a.as_mut_ptr(),
13158        &lda,
13159        tau.as_ptr(),
13160        work.as_mut_ptr(),
13161        &lwork,
13162        info,
13163    )
13164}
13165
13166#[inline]
13167pub unsafe fn cungql(
13168    m: i32,
13169    n: i32,
13170    k: i32,
13171    a: &mut [c32],
13172    lda: i32,
13173    tau: &[c32],
13174    work: &mut [c32],
13175    lwork: i32,
13176    info: &mut i32,
13177) {
13178    ffi::cungql_(
13179        &m,
13180        &n,
13181        &k,
13182        a.as_mut_ptr() as *mut _,
13183        &lda,
13184        tau.as_ptr() as *const _,
13185        work.as_mut_ptr() as *mut _,
13186        &lwork,
13187        info,
13188    )
13189}
13190
13191#[inline]
13192pub unsafe fn zungql(
13193    m: i32,
13194    n: i32,
13195    k: i32,
13196    a: &mut [c64],
13197    lda: i32,
13198    tau: &[c64],
13199    work: &mut [c64],
13200    lwork: i32,
13201    info: &mut i32,
13202) {
13203    ffi::zungql_(
13204        &m,
13205        &n,
13206        &k,
13207        a.as_mut_ptr() as *mut _,
13208        &lda,
13209        tau.as_ptr() as *const _,
13210        work.as_mut_ptr() as *mut _,
13211        &lwork,
13212        info,
13213    )
13214}
13215
13216#[inline]
13217pub unsafe fn sormql(
13218    side: u8,
13219    trans: u8,
13220    m: i32,
13221    n: i32,
13222    k: i32,
13223    a: &[f32],
13224    lda: i32,
13225    tau: &[f32],
13226    c: &mut [f32],
13227    ldc: i32,
13228    work: &mut [f32],
13229    lwork: i32,
13230    info: &mut i32,
13231) {
13232    ffi::sormql_(
13233        &(side as c_char),
13234        &(trans as c_char),
13235        &m,
13236        &n,
13237        &k,
13238        a.as_ptr(),
13239        &lda,
13240        tau.as_ptr(),
13241        c.as_mut_ptr(),
13242        &ldc,
13243        work.as_mut_ptr(),
13244        &lwork,
13245        info,
13246    )
13247}
13248
13249#[inline]
13250pub unsafe fn dormql(
13251    side: u8,
13252    trans: u8,
13253    m: i32,
13254    n: i32,
13255    k: i32,
13256    a: &[f64],
13257    lda: i32,
13258    tau: &[f64],
13259    c: &mut [f64],
13260    ldc: i32,
13261    work: &mut [f64],
13262    lwork: i32,
13263    info: &mut i32,
13264) {
13265    ffi::dormql_(
13266        &(side as c_char),
13267        &(trans as c_char),
13268        &m,
13269        &n,
13270        &k,
13271        a.as_ptr(),
13272        &lda,
13273        tau.as_ptr(),
13274        c.as_mut_ptr(),
13275        &ldc,
13276        work.as_mut_ptr(),
13277        &lwork,
13278        info,
13279    )
13280}
13281
13282#[inline]
13283pub unsafe fn cunmql(
13284    side: u8,
13285    trans: u8,
13286    m: i32,
13287    n: i32,
13288    k: i32,
13289    a: &[c32],
13290    lda: i32,
13291    tau: &[c32],
13292    c: &mut [c32],
13293    ldc: i32,
13294    work: &mut [c32],
13295    lwork: i32,
13296    info: &mut i32,
13297) {
13298    ffi::cunmql_(
13299        &(side as c_char),
13300        &(trans as c_char),
13301        &m,
13302        &n,
13303        &k,
13304        a.as_ptr() as *const _,
13305        &lda,
13306        tau.as_ptr() as *const _,
13307        c.as_mut_ptr() as *mut _,
13308        &ldc,
13309        work.as_mut_ptr() as *mut _,
13310        &lwork,
13311        info,
13312    )
13313}
13314
13315#[inline]
13316pub unsafe fn zunmql(
13317    side: u8,
13318    trans: u8,
13319    m: i32,
13320    n: i32,
13321    k: i32,
13322    a: &[c64],
13323    lda: i32,
13324    tau: &[c64],
13325    c: &mut [c64],
13326    ldc: i32,
13327    work: &mut [c64],
13328    lwork: i32,
13329    info: &mut i32,
13330) {
13331    ffi::zunmql_(
13332        &(side as c_char),
13333        &(trans as c_char),
13334        &m,
13335        &n,
13336        &k,
13337        a.as_ptr() as *const _,
13338        &lda,
13339        tau.as_ptr() as *const _,
13340        c.as_mut_ptr() as *mut _,
13341        &ldc,
13342        work.as_mut_ptr() as *mut _,
13343        &lwork,
13344        info,
13345    )
13346}
13347
13348#[inline]
13349pub unsafe fn sgerqf(
13350    m: i32,
13351    n: i32,
13352    a: &mut [f32],
13353    lda: i32,
13354    tau: &mut [f32],
13355    work: &mut [f32],
13356    lwork: i32,
13357    info: &mut i32,
13358) {
13359    ffi::sgerqf_(
13360        &m,
13361        &n,
13362        a.as_mut_ptr(),
13363        &lda,
13364        tau.as_mut_ptr(),
13365        work.as_mut_ptr(),
13366        &lwork,
13367        info,
13368    )
13369}
13370
13371#[inline]
13372pub unsafe fn dgerqf(
13373    m: i32,
13374    n: i32,
13375    a: &mut [f64],
13376    lda: i32,
13377    tau: &mut [f64],
13378    work: &mut [f64],
13379    lwork: i32,
13380    info: &mut i32,
13381) {
13382    ffi::dgerqf_(
13383        &m,
13384        &n,
13385        a.as_mut_ptr(),
13386        &lda,
13387        tau.as_mut_ptr(),
13388        work.as_mut_ptr(),
13389        &lwork,
13390        info,
13391    )
13392}
13393
13394#[inline]
13395pub unsafe fn cgerqf(
13396    m: i32,
13397    n: i32,
13398    a: &mut [c32],
13399    lda: i32,
13400    tau: &mut [c32],
13401    work: &mut [c32],
13402    lwork: i32,
13403    info: &mut i32,
13404) {
13405    ffi::cgerqf_(
13406        &m,
13407        &n,
13408        a.as_mut_ptr() as *mut _,
13409        &lda,
13410        tau.as_mut_ptr() as *mut _,
13411        work.as_mut_ptr() as *mut _,
13412        &lwork,
13413        info,
13414    )
13415}
13416
13417#[inline]
13418pub unsafe fn zgerqf(
13419    m: i32,
13420    n: i32,
13421    a: &mut [c64],
13422    lda: i32,
13423    tau: &mut [c64],
13424    work: &mut [c64],
13425    lwork: i32,
13426    info: &mut i32,
13427) {
13428    ffi::zgerqf_(
13429        &m,
13430        &n,
13431        a.as_mut_ptr() as *mut _,
13432        &lda,
13433        tau.as_mut_ptr() as *mut _,
13434        work.as_mut_ptr() as *mut _,
13435        &lwork,
13436        info,
13437    )
13438}
13439
13440#[inline]
13441pub unsafe fn sorgrq(
13442    m: i32,
13443    n: i32,
13444    k: i32,
13445    a: &mut [f32],
13446    lda: i32,
13447    tau: &[f32],
13448    work: &mut [f32],
13449    lwork: i32,
13450    info: &mut i32,
13451) {
13452    ffi::sorgrq_(
13453        &m,
13454        &n,
13455        &k,
13456        a.as_mut_ptr(),
13457        &lda,
13458        tau.as_ptr(),
13459        work.as_mut_ptr(),
13460        &lwork,
13461        info,
13462    )
13463}
13464
13465#[inline]
13466pub unsafe fn dorgrq(
13467    m: i32,
13468    n: i32,
13469    k: i32,
13470    a: &mut [f64],
13471    lda: i32,
13472    tau: &[f64],
13473    work: &mut [f64],
13474    lwork: i32,
13475    info: &mut i32,
13476) {
13477    ffi::dorgrq_(
13478        &m,
13479        &n,
13480        &k,
13481        a.as_mut_ptr(),
13482        &lda,
13483        tau.as_ptr(),
13484        work.as_mut_ptr(),
13485        &lwork,
13486        info,
13487    )
13488}
13489
13490#[inline]
13491pub unsafe fn cungrq(
13492    m: i32,
13493    n: i32,
13494    k: i32,
13495    a: &mut [c32],
13496    lda: i32,
13497    tau: &[c32],
13498    work: &mut [c32],
13499    lwork: i32,
13500    info: &mut i32,
13501) {
13502    ffi::cungrq_(
13503        &m,
13504        &n,
13505        &k,
13506        a.as_mut_ptr() as *mut _,
13507        &lda,
13508        tau.as_ptr() as *const _,
13509        work.as_mut_ptr() as *mut _,
13510        &lwork,
13511        info,
13512    )
13513}
13514
13515#[inline]
13516pub unsafe fn zungrq(
13517    m: i32,
13518    n: i32,
13519    k: i32,
13520    a: &mut [c64],
13521    lda: i32,
13522    tau: &[c64],
13523    work: &mut [c64],
13524    lwork: i32,
13525    info: &mut i32,
13526) {
13527    ffi::zungrq_(
13528        &m,
13529        &n,
13530        &k,
13531        a.as_mut_ptr() as *mut _,
13532        &lda,
13533        tau.as_ptr() as *const _,
13534        work.as_mut_ptr() as *mut _,
13535        &lwork,
13536        info,
13537    )
13538}
13539
13540#[inline]
13541pub unsafe fn sormrq(
13542    side: u8,
13543    trans: u8,
13544    m: i32,
13545    n: i32,
13546    k: i32,
13547    a: &[f32],
13548    lda: i32,
13549    tau: &[f32],
13550    c: &mut [f32],
13551    ldc: i32,
13552    work: &mut [f32],
13553    lwork: i32,
13554    info: &mut i32,
13555) {
13556    ffi::sormrq_(
13557        &(side as c_char),
13558        &(trans as c_char),
13559        &m,
13560        &n,
13561        &k,
13562        a.as_ptr(),
13563        &lda,
13564        tau.as_ptr(),
13565        c.as_mut_ptr(),
13566        &ldc,
13567        work.as_mut_ptr(),
13568        &lwork,
13569        info,
13570    )
13571}
13572
13573#[inline]
13574pub unsafe fn dormrq(
13575    side: u8,
13576    trans: u8,
13577    m: i32,
13578    n: i32,
13579    k: i32,
13580    a: &[f64],
13581    lda: i32,
13582    tau: &[f64],
13583    c: &mut [f64],
13584    ldc: i32,
13585    work: &mut [f64],
13586    lwork: i32,
13587    info: &mut i32,
13588) {
13589    ffi::dormrq_(
13590        &(side as c_char),
13591        &(trans as c_char),
13592        &m,
13593        &n,
13594        &k,
13595        a.as_ptr(),
13596        &lda,
13597        tau.as_ptr(),
13598        c.as_mut_ptr(),
13599        &ldc,
13600        work.as_mut_ptr(),
13601        &lwork,
13602        info,
13603    )
13604}
13605
13606#[inline]
13607pub unsafe fn cunmrq(
13608    side: u8,
13609    trans: u8,
13610    m: i32,
13611    n: i32,
13612    k: i32,
13613    a: &[c32],
13614    lda: i32,
13615    tau: &[c32],
13616    c: &mut [c32],
13617    ldc: i32,
13618    work: &mut [c32],
13619    lwork: i32,
13620    info: &mut i32,
13621) {
13622    ffi::cunmrq_(
13623        &(side as c_char),
13624        &(trans as c_char),
13625        &m,
13626        &n,
13627        &k,
13628        a.as_ptr() as *const _,
13629        &lda,
13630        tau.as_ptr() as *const _,
13631        c.as_mut_ptr() as *mut _,
13632        &ldc,
13633        work.as_mut_ptr() as *mut _,
13634        &lwork,
13635        info,
13636    )
13637}
13638
13639#[inline]
13640pub unsafe fn zunmrq(
13641    side: u8,
13642    trans: u8,
13643    m: i32,
13644    n: i32,
13645    k: i32,
13646    a: &[c64],
13647    lda: i32,
13648    tau: &[c64],
13649    c: &mut [c64],
13650    ldc: i32,
13651    work: &mut [c64],
13652    lwork: i32,
13653    info: &mut i32,
13654) {
13655    ffi::zunmrq_(
13656        &(side as c_char),
13657        &(trans as c_char),
13658        &m,
13659        &n,
13660        &k,
13661        a.as_ptr() as *const _,
13662        &lda,
13663        tau.as_ptr() as *const _,
13664        c.as_mut_ptr() as *mut _,
13665        &ldc,
13666        work.as_mut_ptr() as *mut _,
13667        &lwork,
13668        info,
13669    )
13670}
13671
13672#[inline]
13673pub unsafe fn stzrzf(
13674    m: i32,
13675    n: i32,
13676    a: &mut [f32],
13677    lda: i32,
13678    tau: &mut [f32],
13679    work: &mut [f32],
13680    lwork: i32,
13681    info: &mut i32,
13682) {
13683    ffi::stzrzf_(
13684        &m,
13685        &n,
13686        a.as_mut_ptr(),
13687        &lda,
13688        tau.as_mut_ptr(),
13689        work.as_mut_ptr(),
13690        &lwork,
13691        info,
13692    )
13693}
13694
13695#[inline]
13696pub unsafe fn dtzrzf(
13697    m: i32,
13698    n: i32,
13699    a: &mut [f64],
13700    lda: i32,
13701    tau: &mut [f64],
13702    work: &mut [f64],
13703    lwork: i32,
13704    info: &mut i32,
13705) {
13706    ffi::dtzrzf_(
13707        &m,
13708        &n,
13709        a.as_mut_ptr(),
13710        &lda,
13711        tau.as_mut_ptr(),
13712        work.as_mut_ptr(),
13713        &lwork,
13714        info,
13715    )
13716}
13717
13718#[inline]
13719pub unsafe fn ctzrzf(
13720    m: i32,
13721    n: i32,
13722    a: &mut [c32],
13723    lda: i32,
13724    tau: &mut [c32],
13725    work: &mut [c32],
13726    lwork: i32,
13727    info: &mut i32,
13728) {
13729    ffi::ctzrzf_(
13730        &m,
13731        &n,
13732        a.as_mut_ptr() as *mut _,
13733        &lda,
13734        tau.as_mut_ptr() as *mut _,
13735        work.as_mut_ptr() as *mut _,
13736        &lwork,
13737        info,
13738    )
13739}
13740
13741#[inline]
13742pub unsafe fn ztzrzf(
13743    m: i32,
13744    n: i32,
13745    a: &mut [c64],
13746    lda: i32,
13747    tau: &mut [c64],
13748    work: &mut [c64],
13749    lwork: i32,
13750    info: &mut i32,
13751) {
13752    ffi::ztzrzf_(
13753        &m,
13754        &n,
13755        a.as_mut_ptr() as *mut _,
13756        &lda,
13757        tau.as_mut_ptr() as *mut _,
13758        work.as_mut_ptr() as *mut _,
13759        &lwork,
13760        info,
13761    )
13762}
13763
13764#[inline]
13765pub unsafe fn sormrz(
13766    side: u8,
13767    trans: u8,
13768    m: i32,
13769    n: i32,
13770    k: i32,
13771    l: i32,
13772    a: &[f32],
13773    lda: i32,
13774    tau: &[f32],
13775    c: &mut [f32],
13776    ldc: i32,
13777    work: &mut [f32],
13778    lwork: i32,
13779    info: &mut i32,
13780) {
13781    ffi::sormrz_(
13782        &(side as c_char),
13783        &(trans as c_char),
13784        &m,
13785        &n,
13786        &k,
13787        &l,
13788        a.as_ptr(),
13789        &lda,
13790        tau.as_ptr(),
13791        c.as_mut_ptr(),
13792        &ldc,
13793        work.as_mut_ptr(),
13794        &lwork,
13795        info,
13796    )
13797}
13798
13799#[inline]
13800pub unsafe fn dormrz(
13801    side: u8,
13802    trans: u8,
13803    m: i32,
13804    n: i32,
13805    k: i32,
13806    l: i32,
13807    a: &[f64],
13808    lda: i32,
13809    tau: &[f64],
13810    c: &mut [f64],
13811    ldc: i32,
13812    work: &mut [f64],
13813    lwork: i32,
13814    info: &mut i32,
13815) {
13816    ffi::dormrz_(
13817        &(side as c_char),
13818        &(trans as c_char),
13819        &m,
13820        &n,
13821        &k,
13822        &l,
13823        a.as_ptr(),
13824        &lda,
13825        tau.as_ptr(),
13826        c.as_mut_ptr(),
13827        &ldc,
13828        work.as_mut_ptr(),
13829        &lwork,
13830        info,
13831    )
13832}
13833
13834#[inline]
13835pub unsafe fn cunmrz(
13836    side: u8,
13837    trans: u8,
13838    m: i32,
13839    n: i32,
13840    k: i32,
13841    l: i32,
13842    a: &[c32],
13843    lda: i32,
13844    tau: &[c32],
13845    c: &mut [c32],
13846    ldc: i32,
13847    work: &mut [c32],
13848    lwork: i32,
13849    info: &mut i32,
13850) {
13851    ffi::cunmrz_(
13852        &(side as c_char),
13853        &(trans as c_char),
13854        &m,
13855        &n,
13856        &k,
13857        &l,
13858        a.as_ptr() as *const _,
13859        &lda,
13860        tau.as_ptr() as *const _,
13861        c.as_mut_ptr() as *mut _,
13862        &ldc,
13863        work.as_mut_ptr() as *mut _,
13864        &lwork,
13865        info,
13866    )
13867}
13868
13869#[inline]
13870pub unsafe fn zunmrz(
13871    side: u8,
13872    trans: u8,
13873    m: i32,
13874    n: i32,
13875    k: i32,
13876    l: i32,
13877    a: &[c64],
13878    lda: i32,
13879    tau: &[c64],
13880    c: &mut [c64],
13881    ldc: i32,
13882    work: &mut [c64],
13883    lwork: i32,
13884    info: &mut i32,
13885) {
13886    ffi::zunmrz_(
13887        &(side as c_char),
13888        &(trans as c_char),
13889        &m,
13890        &n,
13891        &k,
13892        &l,
13893        a.as_ptr() as *const _,
13894        &lda,
13895        tau.as_ptr() as *const _,
13896        c.as_mut_ptr() as *mut _,
13897        &ldc,
13898        work.as_mut_ptr() as *mut _,
13899        &lwork,
13900        info,
13901    )
13902}
13903
13904#[inline]
13905pub unsafe fn sggqrf(
13906    n: i32,
13907    m: i32,
13908    p: i32,
13909    a: &mut [f32],
13910    lda: i32,
13911    taua: &mut [f32],
13912    b: &mut [f32],
13913    ldb: i32,
13914    taub: &mut [f32],
13915    work: &mut [f32],
13916    lwork: i32,
13917    info: &mut i32,
13918) {
13919    ffi::sggqrf_(
13920        &n,
13921        &m,
13922        &p,
13923        a.as_mut_ptr(),
13924        &lda,
13925        taua.as_mut_ptr(),
13926        b.as_mut_ptr(),
13927        &ldb,
13928        taub.as_mut_ptr(),
13929        work.as_mut_ptr(),
13930        &lwork,
13931        info,
13932    )
13933}
13934
13935#[inline]
13936pub unsafe fn dggqrf(
13937    n: i32,
13938    m: i32,
13939    p: i32,
13940    a: &mut [f64],
13941    lda: i32,
13942    taua: &mut [f64],
13943    b: &mut [f64],
13944    ldb: i32,
13945    taub: &mut [f64],
13946    work: &mut [f64],
13947    lwork: i32,
13948    info: &mut i32,
13949) {
13950    ffi::dggqrf_(
13951        &n,
13952        &m,
13953        &p,
13954        a.as_mut_ptr(),
13955        &lda,
13956        taua.as_mut_ptr(),
13957        b.as_mut_ptr(),
13958        &ldb,
13959        taub.as_mut_ptr(),
13960        work.as_mut_ptr(),
13961        &lwork,
13962        info,
13963    )
13964}
13965
13966#[inline]
13967pub unsafe fn cggqrf(
13968    n: i32,
13969    m: i32,
13970    p: i32,
13971    a: &mut [c32],
13972    lda: i32,
13973    taua: &mut [c32],
13974    b: &mut [c32],
13975    ldb: i32,
13976    taub: &mut [c32],
13977    work: &mut [c32],
13978    lwork: i32,
13979    info: &mut i32,
13980) {
13981    ffi::cggqrf_(
13982        &n,
13983        &m,
13984        &p,
13985        a.as_mut_ptr() as *mut _,
13986        &lda,
13987        taua.as_mut_ptr() as *mut _,
13988        b.as_mut_ptr() as *mut _,
13989        &ldb,
13990        taub.as_mut_ptr() as *mut _,
13991        work.as_mut_ptr() as *mut _,
13992        &lwork,
13993        info,
13994    )
13995}
13996
13997#[inline]
13998pub unsafe fn zggqrf(
13999    n: i32,
14000    m: i32,
14001    p: i32,
14002    a: &mut [c64],
14003    lda: i32,
14004    taua: &mut [c64],
14005    b: &mut [c64],
14006    ldb: i32,
14007    taub: &mut [c64],
14008    work: &mut [c64],
14009    lwork: i32,
14010    info: &mut i32,
14011) {
14012    ffi::zggqrf_(
14013        &n,
14014        &m,
14015        &p,
14016        a.as_mut_ptr() as *mut _,
14017        &lda,
14018        taua.as_mut_ptr() as *mut _,
14019        b.as_mut_ptr() as *mut _,
14020        &ldb,
14021        taub.as_mut_ptr() as *mut _,
14022        work.as_mut_ptr() as *mut _,
14023        &lwork,
14024        info,
14025    )
14026}
14027
14028#[inline]
14029pub unsafe fn sggrqf(
14030    m: i32,
14031    p: i32,
14032    n: i32,
14033    a: &mut [f32],
14034    lda: i32,
14035    taua: &mut [f32],
14036    b: &mut [f32],
14037    ldb: i32,
14038    taub: &mut [f32],
14039    work: &mut [f32],
14040    lwork: i32,
14041    info: &mut i32,
14042) {
14043    ffi::sggrqf_(
14044        &m,
14045        &p,
14046        &n,
14047        a.as_mut_ptr(),
14048        &lda,
14049        taua.as_mut_ptr(),
14050        b.as_mut_ptr(),
14051        &ldb,
14052        taub.as_mut_ptr(),
14053        work.as_mut_ptr(),
14054        &lwork,
14055        info,
14056    )
14057}
14058
14059#[inline]
14060pub unsafe fn dggrqf(
14061    m: i32,
14062    p: i32,
14063    n: i32,
14064    a: &mut [f64],
14065    lda: i32,
14066    taua: &mut [f64],
14067    b: &mut [f64],
14068    ldb: i32,
14069    taub: &mut [f64],
14070    work: &mut [f64],
14071    lwork: i32,
14072    info: &mut i32,
14073) {
14074    ffi::dggrqf_(
14075        &m,
14076        &p,
14077        &n,
14078        a.as_mut_ptr(),
14079        &lda,
14080        taua.as_mut_ptr(),
14081        b.as_mut_ptr(),
14082        &ldb,
14083        taub.as_mut_ptr(),
14084        work.as_mut_ptr(),
14085        &lwork,
14086        info,
14087    )
14088}
14089
14090#[inline]
14091pub unsafe fn cggrqf(
14092    m: i32,
14093    p: i32,
14094    n: i32,
14095    a: &mut [c32],
14096    lda: i32,
14097    taua: &mut [c32],
14098    b: &mut [c32],
14099    ldb: i32,
14100    taub: &mut [c32],
14101    work: &mut [c32],
14102    lwork: i32,
14103    info: &mut i32,
14104) {
14105    ffi::cggrqf_(
14106        &m,
14107        &p,
14108        &n,
14109        a.as_mut_ptr() as *mut _,
14110        &lda,
14111        taua.as_mut_ptr() as *mut _,
14112        b.as_mut_ptr() as *mut _,
14113        &ldb,
14114        taub.as_mut_ptr() as *mut _,
14115        work.as_mut_ptr() as *mut _,
14116        &lwork,
14117        info,
14118    )
14119}
14120
14121#[inline]
14122pub unsafe fn zggrqf(
14123    m: i32,
14124    p: i32,
14125    n: i32,
14126    a: &mut [c64],
14127    lda: i32,
14128    taua: &mut [c64],
14129    b: &mut [c64],
14130    ldb: i32,
14131    taub: &mut [c64],
14132    work: &mut [c64],
14133    lwork: i32,
14134    info: &mut i32,
14135) {
14136    ffi::zggrqf_(
14137        &m,
14138        &p,
14139        &n,
14140        a.as_mut_ptr() as *mut _,
14141        &lda,
14142        taua.as_mut_ptr() as *mut _,
14143        b.as_mut_ptr() as *mut _,
14144        &ldb,
14145        taub.as_mut_ptr() as *mut _,
14146        work.as_mut_ptr() as *mut _,
14147        &lwork,
14148        info,
14149    )
14150}
14151
14152#[inline]
14153pub unsafe fn sgebrd(
14154    m: i32,
14155    n: i32,
14156    a: &mut [f32],
14157    lda: i32,
14158    d: &mut [f32],
14159    e: &mut [f32],
14160    tauq: &mut [f32],
14161    taup: &mut [f32],
14162    work: &mut [f32],
14163    lwork: i32,
14164    info: &mut i32,
14165) {
14166    ffi::sgebrd_(
14167        &m,
14168        &n,
14169        a.as_mut_ptr(),
14170        &lda,
14171        d.as_mut_ptr(),
14172        e.as_mut_ptr(),
14173        tauq.as_mut_ptr(),
14174        taup.as_mut_ptr(),
14175        work.as_mut_ptr(),
14176        &lwork,
14177        info,
14178    )
14179}
14180
14181#[inline]
14182pub unsafe fn dgebrd(
14183    m: i32,
14184    n: i32,
14185    a: &mut [f64],
14186    lda: i32,
14187    d: &mut [f64],
14188    e: &mut [f64],
14189    tauq: &mut [f64],
14190    taup: &mut [f64],
14191    work: &mut [f64],
14192    lwork: i32,
14193    info: &mut i32,
14194) {
14195    ffi::dgebrd_(
14196        &m,
14197        &n,
14198        a.as_mut_ptr(),
14199        &lda,
14200        d.as_mut_ptr(),
14201        e.as_mut_ptr(),
14202        tauq.as_mut_ptr(),
14203        taup.as_mut_ptr(),
14204        work.as_mut_ptr(),
14205        &lwork,
14206        info,
14207    )
14208}
14209
14210#[inline]
14211pub unsafe fn cgebrd(
14212    m: i32,
14213    n: i32,
14214    a: &mut [c32],
14215    lda: i32,
14216    d: &mut [f32],
14217    e: &mut [f32],
14218    tauq: &mut [c32],
14219    taup: &mut [c32],
14220    work: &mut [c32],
14221    lwork: i32,
14222    info: &mut i32,
14223) {
14224    ffi::cgebrd_(
14225        &m,
14226        &n,
14227        a.as_mut_ptr() as *mut _,
14228        &lda,
14229        d.as_mut_ptr(),
14230        e.as_mut_ptr(),
14231        tauq.as_mut_ptr() as *mut _,
14232        taup.as_mut_ptr() as *mut _,
14233        work.as_mut_ptr() as *mut _,
14234        &lwork,
14235        info,
14236    )
14237}
14238
14239#[inline]
14240pub unsafe fn zgebrd(
14241    m: i32,
14242    n: i32,
14243    a: &mut [c64],
14244    lda: i32,
14245    d: &mut [f64],
14246    e: &mut [f64],
14247    tauq: &mut [c64],
14248    taup: &mut [c64],
14249    work: &mut [c64],
14250    lwork: i32,
14251    info: &mut i32,
14252) {
14253    ffi::zgebrd_(
14254        &m,
14255        &n,
14256        a.as_mut_ptr() as *mut _,
14257        &lda,
14258        d.as_mut_ptr(),
14259        e.as_mut_ptr(),
14260        tauq.as_mut_ptr() as *mut _,
14261        taup.as_mut_ptr() as *mut _,
14262        work.as_mut_ptr() as *mut _,
14263        &lwork,
14264        info,
14265    )
14266}
14267
14268#[inline]
14269pub unsafe fn sgbbrd(
14270    vect: u8,
14271    m: i32,
14272    n: i32,
14273    ncc: &[i32],
14274    kl: i32,
14275    ku: i32,
14276    ab: &mut [f32],
14277    ldab: i32,
14278    d: &mut [f32],
14279    e: &mut [f32],
14280    q: &mut [f32],
14281    ldq: i32,
14282    pt: &mut [f32],
14283    ldpt: i32,
14284    c: &mut [f32],
14285    ldc: i32,
14286    work: &mut [f32],
14287    info: &mut i32,
14288) {
14289    ffi::sgbbrd_(
14290        &(vect as c_char),
14291        &m,
14292        &n,
14293        ncc.as_ptr(),
14294        &kl,
14295        &ku,
14296        ab.as_mut_ptr(),
14297        &ldab,
14298        d.as_mut_ptr(),
14299        e.as_mut_ptr(),
14300        q.as_mut_ptr(),
14301        &ldq,
14302        pt.as_mut_ptr(),
14303        &ldpt,
14304        c.as_mut_ptr(),
14305        &ldc,
14306        work.as_mut_ptr(),
14307        info,
14308    )
14309}
14310
14311#[inline]
14312pub unsafe fn dgbbrd(
14313    vect: u8,
14314    m: i32,
14315    n: i32,
14316    ncc: &[i32],
14317    kl: i32,
14318    ku: i32,
14319    ab: &mut [f64],
14320    ldab: i32,
14321    d: &mut [f64],
14322    e: &mut [f64],
14323    q: &mut [f64],
14324    ldq: i32,
14325    pt: &mut [f64],
14326    ldpt: i32,
14327    c: &mut [f64],
14328    ldc: i32,
14329    work: &mut [f64],
14330    info: &mut i32,
14331) {
14332    ffi::dgbbrd_(
14333        &(vect as c_char),
14334        &m,
14335        &n,
14336        ncc.as_ptr(),
14337        &kl,
14338        &ku,
14339        ab.as_mut_ptr(),
14340        &ldab,
14341        d.as_mut_ptr(),
14342        e.as_mut_ptr(),
14343        q.as_mut_ptr(),
14344        &ldq,
14345        pt.as_mut_ptr(),
14346        &ldpt,
14347        c.as_mut_ptr(),
14348        &ldc,
14349        work.as_mut_ptr(),
14350        info,
14351    )
14352}
14353
14354#[inline]
14355pub unsafe fn cgbbrd(
14356    vect: u8,
14357    m: i32,
14358    n: i32,
14359    ncc: &[i32],
14360    kl: i32,
14361    ku: i32,
14362    ab: &mut [c32],
14363    ldab: i32,
14364    d: &mut [f32],
14365    e: &mut [f32],
14366    q: &mut [c32],
14367    ldq: i32,
14368    pt: &mut [c32],
14369    ldpt: i32,
14370    c: &mut [c32],
14371    ldc: i32,
14372    work: &mut [c32],
14373    rwork: &mut [f32],
14374    info: &mut i32,
14375) {
14376    ffi::cgbbrd_(
14377        &(vect as c_char),
14378        &m,
14379        &n,
14380        ncc.as_ptr(),
14381        &kl,
14382        &ku,
14383        ab.as_mut_ptr() as *mut _,
14384        &ldab,
14385        d.as_mut_ptr(),
14386        e.as_mut_ptr(),
14387        q.as_mut_ptr() as *mut _,
14388        &ldq,
14389        pt.as_mut_ptr() as *mut _,
14390        &ldpt,
14391        c.as_mut_ptr() as *mut _,
14392        &ldc,
14393        work.as_mut_ptr() as *mut _,
14394        rwork.as_mut_ptr(),
14395        info,
14396    )
14397}
14398
14399#[inline]
14400pub unsafe fn zgbbrd(
14401    vect: u8,
14402    m: i32,
14403    n: i32,
14404    ncc: &[i32],
14405    kl: i32,
14406    ku: i32,
14407    ab: &mut [c64],
14408    ldab: i32,
14409    d: &mut [f64],
14410    e: &mut [f64],
14411    q: &mut [c64],
14412    ldq: i32,
14413    pt: &mut [c64],
14414    ldpt: i32,
14415    c: &mut [c64],
14416    ldc: i32,
14417    work: &mut [c64],
14418    rwork: &mut [f64],
14419    info: &mut i32,
14420) {
14421    ffi::zgbbrd_(
14422        &(vect as c_char),
14423        &m,
14424        &n,
14425        ncc.as_ptr(),
14426        &kl,
14427        &ku,
14428        ab.as_mut_ptr() as *mut _,
14429        &ldab,
14430        d.as_mut_ptr(),
14431        e.as_mut_ptr(),
14432        q.as_mut_ptr() as *mut _,
14433        &ldq,
14434        pt.as_mut_ptr() as *mut _,
14435        &ldpt,
14436        c.as_mut_ptr() as *mut _,
14437        &ldc,
14438        work.as_mut_ptr() as *mut _,
14439        rwork.as_mut_ptr(),
14440        info,
14441    )
14442}
14443
14444#[inline]
14445pub unsafe fn sorgbr(
14446    vect: u8,
14447    m: i32,
14448    n: i32,
14449    k: i32,
14450    a: &mut [f32],
14451    lda: i32,
14452    tau: &[f32],
14453    work: &mut [f32],
14454    lwork: i32,
14455    info: &mut i32,
14456) {
14457    ffi::sorgbr_(
14458        &(vect as c_char),
14459        &m,
14460        &n,
14461        &k,
14462        a.as_mut_ptr(),
14463        &lda,
14464        tau.as_ptr(),
14465        work.as_mut_ptr(),
14466        &lwork,
14467        info,
14468    )
14469}
14470
14471#[inline]
14472pub unsafe fn dorgbr(
14473    vect: u8,
14474    m: i32,
14475    n: i32,
14476    k: i32,
14477    a: &mut [f64],
14478    lda: i32,
14479    tau: &[f64],
14480    work: &mut [f64],
14481    lwork: i32,
14482    info: &mut i32,
14483) {
14484    ffi::dorgbr_(
14485        &(vect as c_char),
14486        &m,
14487        &n,
14488        &k,
14489        a.as_mut_ptr(),
14490        &lda,
14491        tau.as_ptr(),
14492        work.as_mut_ptr(),
14493        &lwork,
14494        info,
14495    )
14496}
14497
14498#[inline]
14499pub unsafe fn sormbr(
14500    vect: u8,
14501    side: u8,
14502    trans: u8,
14503    m: i32,
14504    n: i32,
14505    k: i32,
14506    a: &[f32],
14507    lda: i32,
14508    tau: &[f32],
14509    c: &mut [f32],
14510    ldc: i32,
14511    work: &mut [f32],
14512    lwork: i32,
14513    info: &mut i32,
14514) {
14515    ffi::sormbr_(
14516        &(vect as c_char),
14517        &(side as c_char),
14518        &(trans as c_char),
14519        &m,
14520        &n,
14521        &k,
14522        a.as_ptr(),
14523        &lda,
14524        tau.as_ptr(),
14525        c.as_mut_ptr(),
14526        &ldc,
14527        work.as_mut_ptr(),
14528        &lwork,
14529        info,
14530    )
14531}
14532
14533#[inline]
14534pub unsafe fn dormbr(
14535    vect: u8,
14536    side: u8,
14537    trans: u8,
14538    m: i32,
14539    n: i32,
14540    k: i32,
14541    a: &[f64],
14542    lda: i32,
14543    tau: &[f64],
14544    c: &mut [f64],
14545    ldc: i32,
14546    work: &mut [f64],
14547    lwork: i32,
14548    info: &mut i32,
14549) {
14550    ffi::dormbr_(
14551        &(vect as c_char),
14552        &(side as c_char),
14553        &(trans as c_char),
14554        &m,
14555        &n,
14556        &k,
14557        a.as_ptr(),
14558        &lda,
14559        tau.as_ptr(),
14560        c.as_mut_ptr(),
14561        &ldc,
14562        work.as_mut_ptr(),
14563        &lwork,
14564        info,
14565    )
14566}
14567
14568#[inline]
14569pub unsafe fn cungbr(
14570    vect: u8,
14571    m: i32,
14572    n: i32,
14573    k: i32,
14574    a: &mut [c32],
14575    lda: i32,
14576    tau: &[c32],
14577    work: &mut [c32],
14578    lwork: i32,
14579    info: &mut i32,
14580) {
14581    ffi::cungbr_(
14582        &(vect as c_char),
14583        &m,
14584        &n,
14585        &k,
14586        a.as_mut_ptr() as *mut _,
14587        &lda,
14588        tau.as_ptr() as *const _,
14589        work.as_mut_ptr() as *mut _,
14590        &lwork,
14591        info,
14592    )
14593}
14594
14595#[inline]
14596pub unsafe fn zungbr(
14597    vect: u8,
14598    m: i32,
14599    n: i32,
14600    k: i32,
14601    a: &mut [c64],
14602    lda: i32,
14603    tau: &[c64],
14604    work: &mut [c64],
14605    lwork: i32,
14606    info: &mut i32,
14607) {
14608    ffi::zungbr_(
14609        &(vect as c_char),
14610        &m,
14611        &n,
14612        &k,
14613        a.as_mut_ptr() as *mut _,
14614        &lda,
14615        tau.as_ptr() as *const _,
14616        work.as_mut_ptr() as *mut _,
14617        &lwork,
14618        info,
14619    )
14620}
14621
14622#[inline]
14623pub unsafe fn cunmbr(
14624    vect: u8,
14625    side: u8,
14626    trans: u8,
14627    m: i32,
14628    n: i32,
14629    k: i32,
14630    a: &[c32],
14631    lda: i32,
14632    tau: &[c32],
14633    c: &mut [c32],
14634    ldc: i32,
14635    work: &mut [c32],
14636    lwork: i32,
14637    info: &mut i32,
14638) {
14639    ffi::cunmbr_(
14640        &(vect as c_char),
14641        &(side as c_char),
14642        &(trans as c_char),
14643        &m,
14644        &n,
14645        &k,
14646        a.as_ptr() as *const _,
14647        &lda,
14648        tau.as_ptr() as *const _,
14649        c.as_mut_ptr() as *mut _,
14650        &ldc,
14651        work.as_mut_ptr() as *mut _,
14652        &lwork,
14653        info,
14654    )
14655}
14656
14657#[inline]
14658pub unsafe fn zunmbr(
14659    vect: u8,
14660    side: u8,
14661    trans: u8,
14662    m: i32,
14663    n: i32,
14664    k: i32,
14665    a: &[c64],
14666    lda: i32,
14667    tau: &[c64],
14668    c: &mut [c64],
14669    ldc: i32,
14670    work: &mut [c64],
14671    lwork: i32,
14672    info: &mut i32,
14673) {
14674    ffi::zunmbr_(
14675        &(vect as c_char),
14676        &(side as c_char),
14677        &(trans as c_char),
14678        &m,
14679        &n,
14680        &k,
14681        a.as_ptr() as *const _,
14682        &lda,
14683        tau.as_ptr() as *const _,
14684        c.as_mut_ptr() as *mut _,
14685        &ldc,
14686        work.as_mut_ptr() as *mut _,
14687        &lwork,
14688        info,
14689    )
14690}
14691
14692#[inline]
14693pub unsafe fn sbdsqr(
14694    uplo: u8,
14695    n: i32,
14696    ncvt: &[i32],
14697    nru: &[i32],
14698    ncc: &[i32],
14699    d: &mut [f32],
14700    e: &mut [f32],
14701    vt: &mut [f32],
14702    ldvt: i32,
14703    u: &mut [f32],
14704    ldu: i32,
14705    c: &mut [f32],
14706    ldc: i32,
14707    work: &mut [f32],
14708    info: &mut i32,
14709) {
14710    ffi::sbdsqr_(
14711        &(uplo as c_char),
14712        &n,
14713        ncvt.as_ptr(),
14714        nru.as_ptr(),
14715        ncc.as_ptr(),
14716        d.as_mut_ptr(),
14717        e.as_mut_ptr(),
14718        vt.as_mut_ptr(),
14719        &ldvt,
14720        u.as_mut_ptr(),
14721        &ldu,
14722        c.as_mut_ptr(),
14723        &ldc,
14724        work.as_mut_ptr(),
14725        info,
14726    )
14727}
14728
14729#[inline]
14730pub unsafe fn dbdsqr(
14731    uplo: u8,
14732    n: i32,
14733    ncvt: &[i32],
14734    nru: &[i32],
14735    ncc: &[i32],
14736    d: &mut [f64],
14737    e: &mut [f64],
14738    vt: &mut [f64],
14739    ldvt: i32,
14740    u: &mut [f64],
14741    ldu: i32,
14742    c: &mut [f64],
14743    ldc: i32,
14744    work: &mut [f64],
14745    info: &mut i32,
14746) {
14747    ffi::dbdsqr_(
14748        &(uplo as c_char),
14749        &n,
14750        ncvt.as_ptr(),
14751        nru.as_ptr(),
14752        ncc.as_ptr(),
14753        d.as_mut_ptr(),
14754        e.as_mut_ptr(),
14755        vt.as_mut_ptr(),
14756        &ldvt,
14757        u.as_mut_ptr(),
14758        &ldu,
14759        c.as_mut_ptr(),
14760        &ldc,
14761        work.as_mut_ptr(),
14762        info,
14763    )
14764}
14765
14766#[inline]
14767pub unsafe fn cbdsqr(
14768    uplo: u8,
14769    n: i32,
14770    ncvt: &[i32],
14771    nru: &[i32],
14772    ncc: &[i32],
14773    d: &mut [f32],
14774    e: &mut [f32],
14775    vt: &mut [c32],
14776    ldvt: i32,
14777    u: &mut [c32],
14778    ldu: i32,
14779    c: &mut [c32],
14780    ldc: i32,
14781    work: &mut [f32],
14782    info: &mut i32,
14783) {
14784    ffi::cbdsqr_(
14785        &(uplo as c_char),
14786        &n,
14787        ncvt.as_ptr(),
14788        nru.as_ptr(),
14789        ncc.as_ptr(),
14790        d.as_mut_ptr(),
14791        e.as_mut_ptr(),
14792        vt.as_mut_ptr() as *mut _,
14793        &ldvt,
14794        u.as_mut_ptr() as *mut _,
14795        &ldu,
14796        c.as_mut_ptr() as *mut _,
14797        &ldc,
14798        work.as_mut_ptr(),
14799        info,
14800    )
14801}
14802
14803#[inline]
14804pub unsafe fn zbdsqr(
14805    uplo: u8,
14806    n: i32,
14807    ncvt: &[i32],
14808    nru: &[i32],
14809    ncc: &[i32],
14810    d: &mut [f64],
14811    e: &mut [f64],
14812    vt: &mut [c64],
14813    ldvt: i32,
14814    u: &mut [c64],
14815    ldu: i32,
14816    c: &mut [c64],
14817    ldc: i32,
14818    work: &mut [f64],
14819    info: &mut i32,
14820) {
14821    ffi::zbdsqr_(
14822        &(uplo as c_char),
14823        &n,
14824        ncvt.as_ptr(),
14825        nru.as_ptr(),
14826        ncc.as_ptr(),
14827        d.as_mut_ptr(),
14828        e.as_mut_ptr(),
14829        vt.as_mut_ptr() as *mut _,
14830        &ldvt,
14831        u.as_mut_ptr() as *mut _,
14832        &ldu,
14833        c.as_mut_ptr() as *mut _,
14834        &ldc,
14835        work.as_mut_ptr(),
14836        info,
14837    )
14838}
14839
14840#[inline]
14841pub unsafe fn sbdsdc(
14842    uplo: u8,
14843    compq: u8,
14844    n: i32,
14845    d: &mut [f32],
14846    e: &mut [f32],
14847    u: &mut [f32],
14848    ldu: i32,
14849    vt: &mut [f32],
14850    ldvt: i32,
14851    q: &mut [f32],
14852    iq: &mut [i32],
14853    work: &mut [f32],
14854    iwork: &mut [i32],
14855    info: &mut i32,
14856) {
14857    ffi::sbdsdc_(
14858        &(uplo as c_char),
14859        &(compq as c_char),
14860        &n,
14861        d.as_mut_ptr(),
14862        e.as_mut_ptr(),
14863        u.as_mut_ptr(),
14864        &ldu,
14865        vt.as_mut_ptr(),
14866        &ldvt,
14867        q.as_mut_ptr(),
14868        iq.as_mut_ptr(),
14869        work.as_mut_ptr(),
14870        iwork.as_mut_ptr(),
14871        info,
14872    )
14873}
14874
14875#[inline]
14876pub unsafe fn dbdsdc(
14877    uplo: u8,
14878    compq: u8,
14879    n: i32,
14880    d: &mut [f64],
14881    e: &mut [f64],
14882    u: &mut [f64],
14883    ldu: i32,
14884    vt: &mut [f64],
14885    ldvt: i32,
14886    q: &mut [f64],
14887    iq: &mut [i32],
14888    work: &mut [f64],
14889    iwork: &mut [i32],
14890    info: &mut i32,
14891) {
14892    ffi::dbdsdc_(
14893        &(uplo as c_char),
14894        &(compq as c_char),
14895        &n,
14896        d.as_mut_ptr(),
14897        e.as_mut_ptr(),
14898        u.as_mut_ptr(),
14899        &ldu,
14900        vt.as_mut_ptr(),
14901        &ldvt,
14902        q.as_mut_ptr(),
14903        iq.as_mut_ptr(),
14904        work.as_mut_ptr(),
14905        iwork.as_mut_ptr(),
14906        info,
14907    )
14908}
14909
14910#[inline]
14911pub unsafe fn sbdsvdx(
14912    uplo: u8,
14913    jobz: u8,
14914    range: u8,
14915    n: i32,
14916    d: &[f32],
14917    e: &[f32],
14918    vl: f32,
14919    vu: f32,
14920    il: i32,
14921    iu: i32,
14922    ns: &mut [i32],
14923    s: &mut [f32],
14924    z: &mut [f32],
14925    ldz: i32,
14926    work: &mut [f32],
14927    iwork: &mut [i32],
14928    info: &mut i32,
14929) {
14930    ffi::sbdsvdx_(
14931        &(uplo as c_char),
14932        &(jobz as c_char),
14933        &(range as c_char),
14934        &n,
14935        d.as_ptr(),
14936        e.as_ptr(),
14937        &vl,
14938        &vu,
14939        &il,
14940        &iu,
14941        ns.as_mut_ptr(),
14942        s.as_mut_ptr(),
14943        z.as_mut_ptr(),
14944        &ldz,
14945        work.as_mut_ptr(),
14946        iwork.as_mut_ptr(),
14947        info,
14948    )
14949}
14950
14951#[inline]
14952pub unsafe fn dbdsvdx(
14953    uplo: u8,
14954    jobz: u8,
14955    range: u8,
14956    n: i32,
14957    d: &[f64],
14958    e: &[f64],
14959    vl: f64,
14960    vu: f64,
14961    il: i32,
14962    iu: i32,
14963    ns: &mut [i32],
14964    s: &mut [f64],
14965    z: &mut [f64],
14966    ldz: i32,
14967    work: &mut [f64],
14968    iwork: &mut [i32],
14969    info: &mut i32,
14970) {
14971    ffi::dbdsvdx_(
14972        &(uplo as c_char),
14973        &(jobz as c_char),
14974        &(range as c_char),
14975        &n,
14976        d.as_ptr(),
14977        e.as_ptr(),
14978        &vl,
14979        &vu,
14980        &il,
14981        &iu,
14982        ns.as_mut_ptr(),
14983        s.as_mut_ptr(),
14984        z.as_mut_ptr(),
14985        &ldz,
14986        work.as_mut_ptr(),
14987        iwork.as_mut_ptr(),
14988        info,
14989    )
14990}
14991
14992#[inline]
14993pub unsafe fn ssytrd(
14994    uplo: u8,
14995    n: i32,
14996    a: &mut [f32],
14997    lda: i32,
14998    d: &mut [f32],
14999    e: &mut [f32],
15000    tau: &mut [f32],
15001    work: &mut [f32],
15002    lwork: i32,
15003    info: &mut i32,
15004) {
15005    ffi::ssytrd_(
15006        &(uplo as c_char),
15007        &n,
15008        a.as_mut_ptr(),
15009        &lda,
15010        d.as_mut_ptr(),
15011        e.as_mut_ptr(),
15012        tau.as_mut_ptr(),
15013        work.as_mut_ptr(),
15014        &lwork,
15015        info,
15016    )
15017}
15018
15019#[inline]
15020pub unsafe fn dsytrd(
15021    uplo: u8,
15022    n: i32,
15023    a: &mut [f64],
15024    lda: i32,
15025    d: &mut [f64],
15026    e: &mut [f64],
15027    tau: &mut [f64],
15028    work: &mut [f64],
15029    lwork: i32,
15030    info: &mut i32,
15031) {
15032    ffi::dsytrd_(
15033        &(uplo as c_char),
15034        &n,
15035        a.as_mut_ptr(),
15036        &lda,
15037        d.as_mut_ptr(),
15038        e.as_mut_ptr(),
15039        tau.as_mut_ptr(),
15040        work.as_mut_ptr(),
15041        &lwork,
15042        info,
15043    )
15044}
15045
15046#[inline]
15047pub unsafe fn sorgtr(
15048    uplo: u8,
15049    n: i32,
15050    a: &mut [f32],
15051    lda: i32,
15052    tau: &[f32],
15053    work: &mut [f32],
15054    lwork: i32,
15055    info: &mut i32,
15056) {
15057    ffi::sorgtr_(
15058        &(uplo as c_char),
15059        &n,
15060        a.as_mut_ptr(),
15061        &lda,
15062        tau.as_ptr(),
15063        work.as_mut_ptr(),
15064        &lwork,
15065        info,
15066    )
15067}
15068
15069#[inline]
15070pub unsafe fn dorgtr(
15071    uplo: u8,
15072    n: i32,
15073    a: &mut [f64],
15074    lda: i32,
15075    tau: &[f64],
15076    work: &mut [f64],
15077    lwork: i32,
15078    info: &mut i32,
15079) {
15080    ffi::dorgtr_(
15081        &(uplo as c_char),
15082        &n,
15083        a.as_mut_ptr(),
15084        &lda,
15085        tau.as_ptr(),
15086        work.as_mut_ptr(),
15087        &lwork,
15088        info,
15089    )
15090}
15091
15092#[inline]
15093pub unsafe fn sormtr(
15094    side: u8,
15095    uplo: u8,
15096    trans: u8,
15097    m: i32,
15098    n: i32,
15099    a: &[f32],
15100    lda: i32,
15101    tau: &[f32],
15102    c: &mut [f32],
15103    ldc: i32,
15104    work: &mut [f32],
15105    lwork: i32,
15106    info: &mut i32,
15107) {
15108    ffi::sormtr_(
15109        &(side as c_char),
15110        &(uplo as c_char),
15111        &(trans as c_char),
15112        &m,
15113        &n,
15114        a.as_ptr(),
15115        &lda,
15116        tau.as_ptr(),
15117        c.as_mut_ptr(),
15118        &ldc,
15119        work.as_mut_ptr(),
15120        &lwork,
15121        info,
15122    )
15123}
15124
15125#[inline]
15126pub unsafe fn dormtr(
15127    side: u8,
15128    uplo: u8,
15129    trans: u8,
15130    m: i32,
15131    n: i32,
15132    a: &[f64],
15133    lda: i32,
15134    tau: &[f64],
15135    c: &mut [f64],
15136    ldc: i32,
15137    work: &mut [f64],
15138    lwork: i32,
15139    info: &mut i32,
15140) {
15141    ffi::dormtr_(
15142        &(side as c_char),
15143        &(uplo as c_char),
15144        &(trans as c_char),
15145        &m,
15146        &n,
15147        a.as_ptr(),
15148        &lda,
15149        tau.as_ptr(),
15150        c.as_mut_ptr(),
15151        &ldc,
15152        work.as_mut_ptr(),
15153        &lwork,
15154        info,
15155    )
15156}
15157
15158#[inline]
15159pub unsafe fn chetrd(
15160    uplo: u8,
15161    n: i32,
15162    a: &mut [c32],
15163    lda: i32,
15164    d: &mut [f32],
15165    e: &mut [f32],
15166    tau: &mut [c32],
15167    work: &mut [c32],
15168    lwork: i32,
15169    info: &mut i32,
15170) {
15171    ffi::chetrd_(
15172        &(uplo as c_char),
15173        &n,
15174        a.as_mut_ptr() as *mut _,
15175        &lda,
15176        d.as_mut_ptr(),
15177        e.as_mut_ptr(),
15178        tau.as_mut_ptr() as *mut _,
15179        work.as_mut_ptr() as *mut _,
15180        &lwork,
15181        info,
15182    )
15183}
15184
15185#[inline]
15186pub unsafe fn zhetrd(
15187    uplo: u8,
15188    n: i32,
15189    a: &mut [c64],
15190    lda: i32,
15191    d: &mut [f64],
15192    e: &mut [f64],
15193    tau: &mut [c64],
15194    work: &mut [c64],
15195    lwork: i32,
15196    info: &mut i32,
15197) {
15198    ffi::zhetrd_(
15199        &(uplo as c_char),
15200        &n,
15201        a.as_mut_ptr() as *mut _,
15202        &lda,
15203        d.as_mut_ptr(),
15204        e.as_mut_ptr(),
15205        tau.as_mut_ptr() as *mut _,
15206        work.as_mut_ptr() as *mut _,
15207        &lwork,
15208        info,
15209    )
15210}
15211
15212#[inline]
15213pub unsafe fn cungtr(
15214    uplo: u8,
15215    n: i32,
15216    a: &mut [c32],
15217    lda: i32,
15218    tau: &[c32],
15219    work: &mut [c32],
15220    lwork: i32,
15221    info: &mut i32,
15222) {
15223    ffi::cungtr_(
15224        &(uplo as c_char),
15225        &n,
15226        a.as_mut_ptr() as *mut _,
15227        &lda,
15228        tau.as_ptr() as *const _,
15229        work.as_mut_ptr() as *mut _,
15230        &lwork,
15231        info,
15232    )
15233}
15234
15235#[inline]
15236pub unsafe fn zungtr(
15237    uplo: u8,
15238    n: i32,
15239    a: &mut [c64],
15240    lda: i32,
15241    tau: &[c64],
15242    work: &mut [c64],
15243    lwork: i32,
15244    info: &mut i32,
15245) {
15246    ffi::zungtr_(
15247        &(uplo as c_char),
15248        &n,
15249        a.as_mut_ptr() as *mut _,
15250        &lda,
15251        tau.as_ptr() as *const _,
15252        work.as_mut_ptr() as *mut _,
15253        &lwork,
15254        info,
15255    )
15256}
15257
15258#[inline]
15259pub unsafe fn cunmtr(
15260    side: u8,
15261    uplo: u8,
15262    trans: u8,
15263    m: i32,
15264    n: i32,
15265    a: &[c32],
15266    lda: i32,
15267    tau: &[c32],
15268    c: &mut [c32],
15269    ldc: i32,
15270    work: &mut [c32],
15271    lwork: i32,
15272    info: &mut i32,
15273) {
15274    ffi::cunmtr_(
15275        &(side as c_char),
15276        &(uplo as c_char),
15277        &(trans as c_char),
15278        &m,
15279        &n,
15280        a.as_ptr() as *const _,
15281        &lda,
15282        tau.as_ptr() as *const _,
15283        c.as_mut_ptr() as *mut _,
15284        &ldc,
15285        work.as_mut_ptr() as *mut _,
15286        &lwork,
15287        info,
15288    )
15289}
15290
15291#[inline]
15292pub unsafe fn zunmtr(
15293    side: u8,
15294    uplo: u8,
15295    trans: u8,
15296    m: i32,
15297    n: i32,
15298    a: &[c64],
15299    lda: i32,
15300    tau: &[c64],
15301    c: &mut [c64],
15302    ldc: i32,
15303    work: &mut [c64],
15304    lwork: i32,
15305    info: &mut i32,
15306) {
15307    ffi::zunmtr_(
15308        &(side as c_char),
15309        &(uplo as c_char),
15310        &(trans as c_char),
15311        &m,
15312        &n,
15313        a.as_ptr() as *const _,
15314        &lda,
15315        tau.as_ptr() as *const _,
15316        c.as_mut_ptr() as *mut _,
15317        &ldc,
15318        work.as_mut_ptr() as *mut _,
15319        &lwork,
15320        info,
15321    )
15322}
15323
15324#[inline]
15325pub unsafe fn ssptrd(
15326    uplo: u8,
15327    n: i32,
15328    ap: &mut [f32],
15329    d: &mut [f32],
15330    e: &mut [f32],
15331    tau: &mut [f32],
15332    info: &mut i32,
15333) {
15334    ffi::ssptrd_(
15335        &(uplo as c_char),
15336        &n,
15337        ap.as_mut_ptr(),
15338        d.as_mut_ptr(),
15339        e.as_mut_ptr(),
15340        tau.as_mut_ptr(),
15341        info,
15342    )
15343}
15344
15345#[inline]
15346pub unsafe fn dsptrd(
15347    uplo: u8,
15348    n: i32,
15349    ap: &mut [f64],
15350    d: &mut [f64],
15351    e: &mut [f64],
15352    tau: &mut [f64],
15353    info: &mut i32,
15354) {
15355    ffi::dsptrd_(
15356        &(uplo as c_char),
15357        &n,
15358        ap.as_mut_ptr(),
15359        d.as_mut_ptr(),
15360        e.as_mut_ptr(),
15361        tau.as_mut_ptr(),
15362        info,
15363    )
15364}
15365
15366#[inline]
15367pub unsafe fn sopgtr(
15368    uplo: u8,
15369    n: i32,
15370    ap: &[f32],
15371    tau: &[f32],
15372    q: &mut [f32],
15373    ldq: i32,
15374    work: &mut [f32],
15375    info: &mut i32,
15376) {
15377    ffi::sopgtr_(
15378        &(uplo as c_char),
15379        &n,
15380        ap.as_ptr(),
15381        tau.as_ptr(),
15382        q.as_mut_ptr(),
15383        &ldq,
15384        work.as_mut_ptr(),
15385        info,
15386    )
15387}
15388
15389#[inline]
15390pub unsafe fn dopgtr(
15391    uplo: u8,
15392    n: i32,
15393    ap: &[f64],
15394    tau: &[f64],
15395    q: &mut [f64],
15396    ldq: i32,
15397    work: &mut [f64],
15398    info: &mut i32,
15399) {
15400    ffi::dopgtr_(
15401        &(uplo as c_char),
15402        &n,
15403        ap.as_ptr(),
15404        tau.as_ptr(),
15405        q.as_mut_ptr(),
15406        &ldq,
15407        work.as_mut_ptr(),
15408        info,
15409    )
15410}
15411
15412#[inline]
15413pub unsafe fn sopmtr(
15414    side: u8,
15415    uplo: u8,
15416    trans: u8,
15417    m: i32,
15418    n: i32,
15419    ap: &[f32],
15420    tau: &[f32],
15421    c: &mut [f32],
15422    ldc: i32,
15423    work: &mut [f32],
15424    info: &mut i32,
15425) {
15426    ffi::sopmtr_(
15427        &(side as c_char),
15428        &(uplo as c_char),
15429        &(trans as c_char),
15430        &m,
15431        &n,
15432        ap.as_ptr(),
15433        tau.as_ptr(),
15434        c.as_mut_ptr(),
15435        &ldc,
15436        work.as_mut_ptr(),
15437        info,
15438    )
15439}
15440
15441#[inline]
15442pub unsafe fn dopmtr(
15443    side: u8,
15444    uplo: u8,
15445    trans: u8,
15446    m: i32,
15447    n: i32,
15448    ap: &[f64],
15449    tau: &[f64],
15450    c: &mut [f64],
15451    ldc: i32,
15452    work: &mut [f64],
15453    info: &mut i32,
15454) {
15455    ffi::dopmtr_(
15456        &(side as c_char),
15457        &(uplo as c_char),
15458        &(trans as c_char),
15459        &m,
15460        &n,
15461        ap.as_ptr(),
15462        tau.as_ptr(),
15463        c.as_mut_ptr(),
15464        &ldc,
15465        work.as_mut_ptr(),
15466        info,
15467    )
15468}
15469
15470#[inline]
15471pub unsafe fn chptrd(
15472    uplo: u8,
15473    n: i32,
15474    ap: &mut [c32],
15475    d: &mut [f32],
15476    e: &mut [f32],
15477    tau: &mut [c32],
15478    info: &mut i32,
15479) {
15480    ffi::chptrd_(
15481        &(uplo as c_char),
15482        &n,
15483        ap.as_mut_ptr() as *mut _,
15484        d.as_mut_ptr(),
15485        e.as_mut_ptr(),
15486        tau.as_mut_ptr() as *mut _,
15487        info,
15488    )
15489}
15490
15491#[inline]
15492pub unsafe fn zhptrd(
15493    uplo: u8,
15494    n: i32,
15495    ap: &mut [c64],
15496    d: &mut [f64],
15497    e: &mut [f64],
15498    tau: &mut [c64],
15499    info: &mut i32,
15500) {
15501    ffi::zhptrd_(
15502        &(uplo as c_char),
15503        &n,
15504        ap.as_mut_ptr() as *mut _,
15505        d.as_mut_ptr(),
15506        e.as_mut_ptr(),
15507        tau.as_mut_ptr() as *mut _,
15508        info,
15509    )
15510}
15511
15512#[inline]
15513pub unsafe fn cupgtr(
15514    uplo: u8,
15515    n: i32,
15516    ap: &[c32],
15517    tau: &[c32],
15518    q: &mut [c32],
15519    ldq: i32,
15520    work: &mut [c32],
15521    info: &mut i32,
15522) {
15523    ffi::cupgtr_(
15524        &(uplo as c_char),
15525        &n,
15526        ap.as_ptr() as *const _,
15527        tau.as_ptr() as *const _,
15528        q.as_mut_ptr() as *mut _,
15529        &ldq,
15530        work.as_mut_ptr() as *mut _,
15531        info,
15532    )
15533}
15534
15535#[inline]
15536pub unsafe fn zupgtr(
15537    uplo: u8,
15538    n: i32,
15539    ap: &[c64],
15540    tau: &[c64],
15541    q: &mut [c64],
15542    ldq: i32,
15543    work: &mut [c64],
15544    info: &mut i32,
15545) {
15546    ffi::zupgtr_(
15547        &(uplo as c_char),
15548        &n,
15549        ap.as_ptr() as *const _,
15550        tau.as_ptr() as *const _,
15551        q.as_mut_ptr() as *mut _,
15552        &ldq,
15553        work.as_mut_ptr() as *mut _,
15554        info,
15555    )
15556}
15557
15558#[inline]
15559pub unsafe fn cupmtr(
15560    side: u8,
15561    uplo: u8,
15562    trans: u8,
15563    m: i32,
15564    n: i32,
15565    ap: &[c32],
15566    tau: &[c32],
15567    c: &mut [c32],
15568    ldc: i32,
15569    work: &mut [c32],
15570    info: &mut i32,
15571) {
15572    ffi::cupmtr_(
15573        &(side as c_char),
15574        &(uplo as c_char),
15575        &(trans as c_char),
15576        &m,
15577        &n,
15578        ap.as_ptr() as *const _,
15579        tau.as_ptr() as *const _,
15580        c.as_mut_ptr() as *mut _,
15581        &ldc,
15582        work.as_mut_ptr() as *mut _,
15583        info,
15584    )
15585}
15586
15587#[inline]
15588pub unsafe fn zupmtr(
15589    side: u8,
15590    uplo: u8,
15591    trans: u8,
15592    m: i32,
15593    n: i32,
15594    ap: &[c64],
15595    tau: &[c64],
15596    c: &mut [c64],
15597    ldc: i32,
15598    work: &mut [c64],
15599    info: &mut i32,
15600) {
15601    ffi::zupmtr_(
15602        &(side as c_char),
15603        &(uplo as c_char),
15604        &(trans as c_char),
15605        &m,
15606        &n,
15607        ap.as_ptr() as *const _,
15608        tau.as_ptr() as *const _,
15609        c.as_mut_ptr() as *mut _,
15610        &ldc,
15611        work.as_mut_ptr() as *mut _,
15612        info,
15613    )
15614}
15615
15616#[inline]
15617pub unsafe fn ssbtrd(
15618    vect: u8,
15619    uplo: u8,
15620    n: i32,
15621    kd: i32,
15622    ab: &mut [f32],
15623    ldab: i32,
15624    d: &mut [f32],
15625    e: &mut [f32],
15626    q: &mut [f32],
15627    ldq: i32,
15628    work: &mut [f32],
15629    info: &mut i32,
15630) {
15631    ffi::ssbtrd_(
15632        &(vect as c_char),
15633        &(uplo as c_char),
15634        &n,
15635        &kd,
15636        ab.as_mut_ptr(),
15637        &ldab,
15638        d.as_mut_ptr(),
15639        e.as_mut_ptr(),
15640        q.as_mut_ptr(),
15641        &ldq,
15642        work.as_mut_ptr(),
15643        info,
15644    )
15645}
15646
15647#[inline]
15648pub unsafe fn dsbtrd(
15649    vect: u8,
15650    uplo: u8,
15651    n: i32,
15652    kd: i32,
15653    ab: &mut [f64],
15654    ldab: i32,
15655    d: &mut [f64],
15656    e: &mut [f64],
15657    q: &mut [f64],
15658    ldq: i32,
15659    work: &mut [f64],
15660    info: &mut i32,
15661) {
15662    ffi::dsbtrd_(
15663        &(vect as c_char),
15664        &(uplo as c_char),
15665        &n,
15666        &kd,
15667        ab.as_mut_ptr(),
15668        &ldab,
15669        d.as_mut_ptr(),
15670        e.as_mut_ptr(),
15671        q.as_mut_ptr(),
15672        &ldq,
15673        work.as_mut_ptr(),
15674        info,
15675    )
15676}
15677
15678#[inline]
15679pub unsafe fn chbtrd(
15680    vect: u8,
15681    uplo: u8,
15682    n: i32,
15683    kd: i32,
15684    ab: &mut [c32],
15685    ldab: i32,
15686    d: &mut [f32],
15687    e: &mut [f32],
15688    q: &mut [c32],
15689    ldq: i32,
15690    work: &mut [c32],
15691    info: &mut i32,
15692) {
15693    ffi::chbtrd_(
15694        &(vect as c_char),
15695        &(uplo as c_char),
15696        &n,
15697        &kd,
15698        ab.as_mut_ptr() as *mut _,
15699        &ldab,
15700        d.as_mut_ptr(),
15701        e.as_mut_ptr(),
15702        q.as_mut_ptr() as *mut _,
15703        &ldq,
15704        work.as_mut_ptr() as *mut _,
15705        info,
15706    )
15707}
15708
15709#[inline]
15710pub unsafe fn zhbtrd(
15711    vect: u8,
15712    uplo: u8,
15713    n: i32,
15714    kd: i32,
15715    ab: &mut [c64],
15716    ldab: i32,
15717    d: &mut [f64],
15718    e: &mut [f64],
15719    q: &mut [c64],
15720    ldq: i32,
15721    work: &mut [c64],
15722    info: &mut i32,
15723) {
15724    ffi::zhbtrd_(
15725        &(vect as c_char),
15726        &(uplo as c_char),
15727        &n,
15728        &kd,
15729        ab.as_mut_ptr() as *mut _,
15730        &ldab,
15731        d.as_mut_ptr(),
15732        e.as_mut_ptr(),
15733        q.as_mut_ptr() as *mut _,
15734        &ldq,
15735        work.as_mut_ptr() as *mut _,
15736        info,
15737    )
15738}
15739
15740#[inline]
15741pub unsafe fn ssterf(n: i32, d: &mut [f32], e: &mut [f32], info: &mut i32) {
15742    ffi::ssterf_(&n, d.as_mut_ptr(), e.as_mut_ptr(), info)
15743}
15744
15745#[inline]
15746pub unsafe fn dsterf(n: i32, d: &mut [f64], e: &mut [f64], info: &mut i32) {
15747    ffi::dsterf_(&n, d.as_mut_ptr(), e.as_mut_ptr(), info)
15748}
15749
15750#[inline]
15751pub unsafe fn ssteqr(
15752    compz: u8,
15753    n: i32,
15754    d: &mut [f32],
15755    e: &mut [f32],
15756    z: &mut [f32],
15757    ldz: i32,
15758    work: &mut [f32],
15759    info: &mut i32,
15760) {
15761    ffi::ssteqr_(
15762        &(compz as c_char),
15763        &n,
15764        d.as_mut_ptr(),
15765        e.as_mut_ptr(),
15766        z.as_mut_ptr(),
15767        &ldz,
15768        work.as_mut_ptr(),
15769        info,
15770    )
15771}
15772
15773#[inline]
15774pub unsafe fn dsteqr(
15775    compz: u8,
15776    n: i32,
15777    d: &mut [f64],
15778    e: &mut [f64],
15779    z: &mut [f64],
15780    ldz: i32,
15781    work: &mut [f64],
15782    info: &mut i32,
15783) {
15784    ffi::dsteqr_(
15785        &(compz as c_char),
15786        &n,
15787        d.as_mut_ptr(),
15788        e.as_mut_ptr(),
15789        z.as_mut_ptr(),
15790        &ldz,
15791        work.as_mut_ptr(),
15792        info,
15793    )
15794}
15795
15796#[inline]
15797pub unsafe fn csteqr(
15798    compz: u8,
15799    n: i32,
15800    d: &mut [f32],
15801    e: &mut [f32],
15802    z: &mut [c32],
15803    ldz: i32,
15804    work: &mut [f32],
15805    info: &mut i32,
15806) {
15807    ffi::csteqr_(
15808        &(compz as c_char),
15809        &n,
15810        d.as_mut_ptr(),
15811        e.as_mut_ptr(),
15812        z.as_mut_ptr() as *mut _,
15813        &ldz,
15814        work.as_mut_ptr(),
15815        info,
15816    )
15817}
15818
15819#[inline]
15820pub unsafe fn zsteqr(
15821    compz: u8,
15822    n: i32,
15823    d: &mut [f64],
15824    e: &mut [f64],
15825    z: &mut [c64],
15826    ldz: i32,
15827    work: &mut [f64],
15828    info: &mut i32,
15829) {
15830    ffi::zsteqr_(
15831        &(compz as c_char),
15832        &n,
15833        d.as_mut_ptr(),
15834        e.as_mut_ptr(),
15835        z.as_mut_ptr() as *mut _,
15836        &ldz,
15837        work.as_mut_ptr(),
15838        info,
15839    )
15840}
15841
15842#[inline]
15843pub unsafe fn sstemr(
15844    jobz: u8,
15845    range: u8,
15846    n: i32,
15847    d: &mut [f32],
15848    e: &mut [f32],
15849    vl: f32,
15850    vu: f32,
15851    il: i32,
15852    iu: i32,
15853    m: &mut i32,
15854    w: &mut [f32],
15855    z: &mut [f32],
15856    ldz: i32,
15857    nzc: &[i32],
15858    isuppz: &mut [i32],
15859    tryrac: &mut i32,
15860    work: &mut [f32],
15861    lwork: i32,
15862    iwork: &mut [i32],
15863    liwork: i32,
15864    info: &mut i32,
15865) {
15866    ffi::sstemr_(
15867        &(jobz as c_char),
15868        &(range as c_char),
15869        &n,
15870        d.as_mut_ptr(),
15871        e.as_mut_ptr(),
15872        &vl,
15873        &vu,
15874        &il,
15875        &iu,
15876        m,
15877        w.as_mut_ptr(),
15878        z.as_mut_ptr(),
15879        &ldz,
15880        nzc.as_ptr(),
15881        isuppz.as_mut_ptr(),
15882        tryrac,
15883        work.as_mut_ptr(),
15884        &lwork,
15885        iwork.as_mut_ptr(),
15886        &liwork,
15887        info,
15888    )
15889}
15890
15891#[inline]
15892pub unsafe fn dstemr(
15893    jobz: u8,
15894    range: u8,
15895    n: i32,
15896    d: &mut [f64],
15897    e: &mut [f64],
15898    vl: f64,
15899    vu: f64,
15900    il: i32,
15901    iu: i32,
15902    m: &mut i32,
15903    w: &mut [f64],
15904    z: &mut [f64],
15905    ldz: i32,
15906    nzc: &[i32],
15907    isuppz: &mut [i32],
15908    tryrac: &mut i32,
15909    work: &mut [f64],
15910    lwork: i32,
15911    iwork: &mut [i32],
15912    liwork: i32,
15913    info: &mut i32,
15914) {
15915    ffi::dstemr_(
15916        &(jobz as c_char),
15917        &(range as c_char),
15918        &n,
15919        d.as_mut_ptr(),
15920        e.as_mut_ptr(),
15921        &vl,
15922        &vu,
15923        &il,
15924        &iu,
15925        m,
15926        w.as_mut_ptr(),
15927        z.as_mut_ptr(),
15928        &ldz,
15929        nzc.as_ptr(),
15930        isuppz.as_mut_ptr(),
15931        tryrac,
15932        work.as_mut_ptr(),
15933        &lwork,
15934        iwork.as_mut_ptr(),
15935        &liwork,
15936        info,
15937    )
15938}
15939
15940#[inline]
15941pub unsafe fn cstemr(
15942    jobz: u8,
15943    range: u8,
15944    n: i32,
15945    d: &mut [f32],
15946    e: &mut [f32],
15947    vl: f32,
15948    vu: f32,
15949    il: i32,
15950    iu: i32,
15951    m: &mut i32,
15952    w: &mut [f32],
15953    z: &mut [c32],
15954    ldz: i32,
15955    nzc: &[i32],
15956    isuppz: &mut [i32],
15957    tryrac: &mut i32,
15958    work: &mut [f32],
15959    lwork: i32,
15960    iwork: &mut [i32],
15961    liwork: i32,
15962    info: &mut i32,
15963) {
15964    ffi::cstemr_(
15965        &(jobz as c_char),
15966        &(range as c_char),
15967        &n,
15968        d.as_mut_ptr(),
15969        e.as_mut_ptr(),
15970        &vl,
15971        &vu,
15972        &il,
15973        &iu,
15974        m,
15975        w.as_mut_ptr(),
15976        z.as_mut_ptr() as *mut _,
15977        &ldz,
15978        nzc.as_ptr(),
15979        isuppz.as_mut_ptr(),
15980        tryrac,
15981        work.as_mut_ptr(),
15982        &lwork,
15983        iwork.as_mut_ptr(),
15984        &liwork,
15985        info,
15986    )
15987}
15988
15989#[inline]
15990pub unsafe fn zstemr(
15991    jobz: u8,
15992    range: u8,
15993    n: i32,
15994    d: &mut [f64],
15995    e: &mut [f64],
15996    vl: f64,
15997    vu: f64,
15998    il: i32,
15999    iu: i32,
16000    m: &mut i32,
16001    w: &mut [f64],
16002    z: &mut [c64],
16003    ldz: i32,
16004    nzc: &[i32],
16005    isuppz: &mut [i32],
16006    tryrac: &mut i32,
16007    work: &mut [f64],
16008    lwork: i32,
16009    iwork: &mut [i32],
16010    liwork: i32,
16011    info: &mut i32,
16012) {
16013    ffi::zstemr_(
16014        &(jobz as c_char),
16015        &(range as c_char),
16016        &n,
16017        d.as_mut_ptr(),
16018        e.as_mut_ptr(),
16019        &vl,
16020        &vu,
16021        &il,
16022        &iu,
16023        m,
16024        w.as_mut_ptr(),
16025        z.as_mut_ptr() as *mut _,
16026        &ldz,
16027        nzc.as_ptr(),
16028        isuppz.as_mut_ptr(),
16029        tryrac,
16030        work.as_mut_ptr(),
16031        &lwork,
16032        iwork.as_mut_ptr(),
16033        &liwork,
16034        info,
16035    )
16036}
16037
16038#[inline]
16039pub unsafe fn sstedc(
16040    compz: u8,
16041    n: i32,
16042    d: &mut [f32],
16043    e: &mut [f32],
16044    z: &mut [f32],
16045    ldz: i32,
16046    work: &mut [f32],
16047    lwork: i32,
16048    iwork: &mut [i32],
16049    liwork: i32,
16050    info: &mut i32,
16051) {
16052    ffi::sstedc_(
16053        &(compz as c_char),
16054        &n,
16055        d.as_mut_ptr(),
16056        e.as_mut_ptr(),
16057        z.as_mut_ptr(),
16058        &ldz,
16059        work.as_mut_ptr(),
16060        &lwork,
16061        iwork.as_mut_ptr(),
16062        &liwork,
16063        info,
16064    )
16065}
16066
16067#[inline]
16068pub unsafe fn dstedc(
16069    compz: u8,
16070    n: i32,
16071    d: &mut [f64],
16072    e: &mut [f64],
16073    z: &mut [f64],
16074    ldz: i32,
16075    work: &mut [f64],
16076    lwork: i32,
16077    iwork: &mut [i32],
16078    liwork: i32,
16079    info: &mut i32,
16080) {
16081    ffi::dstedc_(
16082        &(compz as c_char),
16083        &n,
16084        d.as_mut_ptr(),
16085        e.as_mut_ptr(),
16086        z.as_mut_ptr(),
16087        &ldz,
16088        work.as_mut_ptr(),
16089        &lwork,
16090        iwork.as_mut_ptr(),
16091        &liwork,
16092        info,
16093    )
16094}
16095
16096#[inline]
16097pub unsafe fn cstedc(
16098    compz: u8,
16099    n: i32,
16100    d: &mut [f32],
16101    e: &mut [f32],
16102    z: &mut [c32],
16103    ldz: i32,
16104    work: &mut [c32],
16105    lwork: i32,
16106    rwork: &mut [f32],
16107    lrwork: i32,
16108    iwork: &mut [i32],
16109    liwork: i32,
16110    info: &mut i32,
16111) {
16112    ffi::cstedc_(
16113        &(compz as c_char),
16114        &n,
16115        d.as_mut_ptr(),
16116        e.as_mut_ptr(),
16117        z.as_mut_ptr() as *mut _,
16118        &ldz,
16119        work.as_mut_ptr() as *mut _,
16120        &lwork,
16121        rwork.as_mut_ptr(),
16122        &lrwork,
16123        iwork.as_mut_ptr(),
16124        &liwork,
16125        info,
16126    )
16127}
16128
16129#[inline]
16130pub unsafe fn zstedc(
16131    compz: u8,
16132    n: i32,
16133    d: &mut [f64],
16134    e: &mut [f64],
16135    z: &mut [c64],
16136    ldz: i32,
16137    work: &mut [c64],
16138    lwork: i32,
16139    rwork: &mut [f64],
16140    lrwork: i32,
16141    iwork: &mut [i32],
16142    liwork: i32,
16143    info: &mut i32,
16144) {
16145    ffi::zstedc_(
16146        &(compz as c_char),
16147        &n,
16148        d.as_mut_ptr(),
16149        e.as_mut_ptr(),
16150        z.as_mut_ptr() as *mut _,
16151        &ldz,
16152        work.as_mut_ptr() as *mut _,
16153        &lwork,
16154        rwork.as_mut_ptr(),
16155        &lrwork,
16156        iwork.as_mut_ptr(),
16157        &liwork,
16158        info,
16159    )
16160}
16161
16162#[inline]
16163pub unsafe fn sstegr(
16164    jobz: u8,
16165    range: u8,
16166    n: i32,
16167    d: &mut [f32],
16168    e: &mut [f32],
16169    vl: f32,
16170    vu: f32,
16171    il: i32,
16172    iu: i32,
16173    abstol: f32,
16174    m: &mut i32,
16175    w: &mut [f32],
16176    z: &mut [f32],
16177    ldz: i32,
16178    isuppz: &mut [i32],
16179    work: &mut [f32],
16180    lwork: i32,
16181    iwork: &mut [i32],
16182    liwork: i32,
16183    info: &mut i32,
16184) {
16185    ffi::sstegr_(
16186        &(jobz as c_char),
16187        &(range as c_char),
16188        &n,
16189        d.as_mut_ptr(),
16190        e.as_mut_ptr(),
16191        &vl,
16192        &vu,
16193        &il,
16194        &iu,
16195        &abstol,
16196        m,
16197        w.as_mut_ptr(),
16198        z.as_mut_ptr(),
16199        &ldz,
16200        isuppz.as_mut_ptr(),
16201        work.as_mut_ptr(),
16202        &lwork,
16203        iwork.as_mut_ptr(),
16204        &liwork,
16205        info,
16206    )
16207}
16208
16209#[inline]
16210pub unsafe fn dstegr(
16211    jobz: u8,
16212    range: u8,
16213    n: i32,
16214    d: &mut [f64],
16215    e: &mut [f64],
16216    vl: f64,
16217    vu: f64,
16218    il: i32,
16219    iu: i32,
16220    abstol: f64,
16221    m: &mut i32,
16222    w: &mut [f64],
16223    z: &mut [f64],
16224    ldz: i32,
16225    isuppz: &mut [i32],
16226    work: &mut [f64],
16227    lwork: i32,
16228    iwork: &mut [i32],
16229    liwork: i32,
16230    info: &mut i32,
16231) {
16232    ffi::dstegr_(
16233        &(jobz as c_char),
16234        &(range as c_char),
16235        &n,
16236        d.as_mut_ptr(),
16237        e.as_mut_ptr(),
16238        &vl,
16239        &vu,
16240        &il,
16241        &iu,
16242        &abstol,
16243        m,
16244        w.as_mut_ptr(),
16245        z.as_mut_ptr(),
16246        &ldz,
16247        isuppz.as_mut_ptr(),
16248        work.as_mut_ptr(),
16249        &lwork,
16250        iwork.as_mut_ptr(),
16251        &liwork,
16252        info,
16253    )
16254}
16255
16256#[inline]
16257pub unsafe fn cstegr(
16258    jobz: u8,
16259    range: u8,
16260    n: i32,
16261    d: &mut [f32],
16262    e: &mut [f32],
16263    vl: f32,
16264    vu: f32,
16265    il: i32,
16266    iu: i32,
16267    abstol: f32,
16268    m: &mut i32,
16269    w: &mut [f32],
16270    z: &mut [c32],
16271    ldz: i32,
16272    isuppz: &mut [i32],
16273    work: &mut [f32],
16274    lwork: i32,
16275    iwork: &mut [i32],
16276    liwork: i32,
16277    info: &mut i32,
16278) {
16279    ffi::cstegr_(
16280        &(jobz as c_char),
16281        &(range as c_char),
16282        &n,
16283        d.as_mut_ptr(),
16284        e.as_mut_ptr(),
16285        &vl,
16286        &vu,
16287        &il,
16288        &iu,
16289        &abstol,
16290        m,
16291        w.as_mut_ptr(),
16292        z.as_mut_ptr() as *mut _,
16293        &ldz,
16294        isuppz.as_mut_ptr(),
16295        work.as_mut_ptr(),
16296        &lwork,
16297        iwork.as_mut_ptr(),
16298        &liwork,
16299        info,
16300    )
16301}
16302
16303#[inline]
16304pub unsafe fn zstegr(
16305    jobz: u8,
16306    range: u8,
16307    n: i32,
16308    d: &mut [f64],
16309    e: &mut [f64],
16310    vl: f64,
16311    vu: f64,
16312    il: i32,
16313    iu: i32,
16314    abstol: f64,
16315    m: &mut i32,
16316    w: &mut [f64],
16317    z: &mut [c64],
16318    ldz: i32,
16319    isuppz: &mut [i32],
16320    work: &mut [f64],
16321    lwork: i32,
16322    iwork: &mut [i32],
16323    liwork: i32,
16324    info: &mut i32,
16325) {
16326    ffi::zstegr_(
16327        &(jobz as c_char),
16328        &(range as c_char),
16329        &n,
16330        d.as_mut_ptr(),
16331        e.as_mut_ptr(),
16332        &vl,
16333        &vu,
16334        &il,
16335        &iu,
16336        &abstol,
16337        m,
16338        w.as_mut_ptr(),
16339        z.as_mut_ptr() as *mut _,
16340        &ldz,
16341        isuppz.as_mut_ptr(),
16342        work.as_mut_ptr(),
16343        &lwork,
16344        iwork.as_mut_ptr(),
16345        &liwork,
16346        info,
16347    )
16348}
16349
16350#[inline]
16351pub unsafe fn spteqr(
16352    compz: u8,
16353    n: i32,
16354    d: &mut [f32],
16355    e: &mut [f32],
16356    z: &mut [f32],
16357    ldz: i32,
16358    work: &mut [f32],
16359    info: &mut i32,
16360) {
16361    ffi::spteqr_(
16362        &(compz as c_char),
16363        &n,
16364        d.as_mut_ptr(),
16365        e.as_mut_ptr(),
16366        z.as_mut_ptr(),
16367        &ldz,
16368        work.as_mut_ptr(),
16369        info,
16370    )
16371}
16372
16373#[inline]
16374pub unsafe fn dpteqr(
16375    compz: u8,
16376    n: i32,
16377    d: &mut [f64],
16378    e: &mut [f64],
16379    z: &mut [f64],
16380    ldz: i32,
16381    work: &mut [f64],
16382    info: &mut i32,
16383) {
16384    ffi::dpteqr_(
16385        &(compz as c_char),
16386        &n,
16387        d.as_mut_ptr(),
16388        e.as_mut_ptr(),
16389        z.as_mut_ptr(),
16390        &ldz,
16391        work.as_mut_ptr(),
16392        info,
16393    )
16394}
16395
16396#[inline]
16397pub unsafe fn cpteqr(
16398    compz: u8,
16399    n: i32,
16400    d: &mut [f32],
16401    e: &mut [f32],
16402    z: &mut [c32],
16403    ldz: i32,
16404    work: &mut [f32],
16405    info: &mut i32,
16406) {
16407    ffi::cpteqr_(
16408        &(compz as c_char),
16409        &n,
16410        d.as_mut_ptr(),
16411        e.as_mut_ptr(),
16412        z.as_mut_ptr() as *mut _,
16413        &ldz,
16414        work.as_mut_ptr(),
16415        info,
16416    )
16417}
16418
16419#[inline]
16420pub unsafe fn zpteqr(
16421    compz: u8,
16422    n: i32,
16423    d: &mut [f64],
16424    e: &mut [f64],
16425    z: &mut [c64],
16426    ldz: i32,
16427    work: &mut [f64],
16428    info: &mut i32,
16429) {
16430    ffi::zpteqr_(
16431        &(compz as c_char),
16432        &n,
16433        d.as_mut_ptr(),
16434        e.as_mut_ptr(),
16435        z.as_mut_ptr() as *mut _,
16436        &ldz,
16437        work.as_mut_ptr(),
16438        info,
16439    )
16440}
16441
16442#[inline]
16443pub unsafe fn sstebz(
16444    range: u8,
16445    order: u8,
16446    n: i32,
16447    vl: f32,
16448    vu: f32,
16449    il: i32,
16450    iu: i32,
16451    abstol: f32,
16452    d: &[f32],
16453    e: &[f32],
16454    m: &mut i32,
16455    nsplit: &mut [i32],
16456    w: &mut [f32],
16457    iblock: &mut [i32],
16458    isplit: &mut [i32],
16459    work: &mut [f32],
16460    iwork: &mut [i32],
16461    info: &mut i32,
16462) {
16463    ffi::sstebz_(
16464        &(range as c_char),
16465        &(order as c_char),
16466        &n,
16467        &vl,
16468        &vu,
16469        &il,
16470        &iu,
16471        &abstol,
16472        d.as_ptr(),
16473        e.as_ptr(),
16474        m,
16475        nsplit.as_mut_ptr(),
16476        w.as_mut_ptr(),
16477        iblock.as_mut_ptr(),
16478        isplit.as_mut_ptr(),
16479        work.as_mut_ptr(),
16480        iwork.as_mut_ptr(),
16481        info,
16482    )
16483}
16484
16485#[inline]
16486pub unsafe fn dstebz(
16487    range: u8,
16488    order: u8,
16489    n: i32,
16490    vl: f64,
16491    vu: f64,
16492    il: i32,
16493    iu: i32,
16494    abstol: f64,
16495    d: &[f64],
16496    e: &[f64],
16497    m: &mut i32,
16498    nsplit: &mut [i32],
16499    w: &mut [f64],
16500    iblock: &mut [i32],
16501    isplit: &mut [i32],
16502    work: &mut [f64],
16503    iwork: &mut [i32],
16504    info: &mut i32,
16505) {
16506    ffi::dstebz_(
16507        &(range as c_char),
16508        &(order as c_char),
16509        &n,
16510        &vl,
16511        &vu,
16512        &il,
16513        &iu,
16514        &abstol,
16515        d.as_ptr(),
16516        e.as_ptr(),
16517        m,
16518        nsplit.as_mut_ptr(),
16519        w.as_mut_ptr(),
16520        iblock.as_mut_ptr(),
16521        isplit.as_mut_ptr(),
16522        work.as_mut_ptr(),
16523        iwork.as_mut_ptr(),
16524        info,
16525    )
16526}
16527
16528#[inline]
16529pub unsafe fn sstein(
16530    n: i32,
16531    d: &[f32],
16532    e: &[f32],
16533    m: i32,
16534    w: &[f32],
16535    iblock: &[i32],
16536    isplit: &[i32],
16537    z: &mut [f32],
16538    ldz: i32,
16539    work: &mut [f32],
16540    iwork: &mut [i32],
16541    ifail: &mut [i32],
16542    info: &mut i32,
16543) {
16544    ffi::sstein_(
16545        &n,
16546        d.as_ptr(),
16547        e.as_ptr(),
16548        &m,
16549        w.as_ptr(),
16550        iblock.as_ptr(),
16551        isplit.as_ptr(),
16552        z.as_mut_ptr(),
16553        &ldz,
16554        work.as_mut_ptr(),
16555        iwork.as_mut_ptr(),
16556        ifail.as_mut_ptr(),
16557        info,
16558    )
16559}
16560
16561#[inline]
16562pub unsafe fn dstein(
16563    n: i32,
16564    d: &[f64],
16565    e: &[f64],
16566    m: i32,
16567    w: &[f64],
16568    iblock: &[i32],
16569    isplit: &[i32],
16570    z: &mut [f64],
16571    ldz: i32,
16572    work: &mut [f64],
16573    iwork: &mut [i32],
16574    ifail: &mut [i32],
16575    info: &mut i32,
16576) {
16577    ffi::dstein_(
16578        &n,
16579        d.as_ptr(),
16580        e.as_ptr(),
16581        &m,
16582        w.as_ptr(),
16583        iblock.as_ptr(),
16584        isplit.as_ptr(),
16585        z.as_mut_ptr(),
16586        &ldz,
16587        work.as_mut_ptr(),
16588        iwork.as_mut_ptr(),
16589        ifail.as_mut_ptr(),
16590        info,
16591    )
16592}
16593
16594#[inline]
16595pub unsafe fn cstein(
16596    n: i32,
16597    d: &[f32],
16598    e: &[f32],
16599    m: i32,
16600    w: &[f32],
16601    iblock: &[i32],
16602    isplit: &[i32],
16603    z: &mut [c32],
16604    ldz: i32,
16605    work: &mut [f32],
16606    iwork: &mut [i32],
16607    ifail: &mut [i32],
16608    info: &mut i32,
16609) {
16610    ffi::cstein_(
16611        &n,
16612        d.as_ptr(),
16613        e.as_ptr(),
16614        &m,
16615        w.as_ptr(),
16616        iblock.as_ptr(),
16617        isplit.as_ptr(),
16618        z.as_mut_ptr() as *mut _,
16619        &ldz,
16620        work.as_mut_ptr(),
16621        iwork.as_mut_ptr(),
16622        ifail.as_mut_ptr(),
16623        info,
16624    )
16625}
16626
16627#[inline]
16628pub unsafe fn zstein(
16629    n: i32,
16630    d: &[f64],
16631    e: &[f64],
16632    m: i32,
16633    w: &[f64],
16634    iblock: &[i32],
16635    isplit: &[i32],
16636    z: &mut [c64],
16637    ldz: i32,
16638    work: &mut [f64],
16639    iwork: &mut [i32],
16640    ifail: &mut [i32],
16641    info: &mut i32,
16642) {
16643    ffi::zstein_(
16644        &n,
16645        d.as_ptr(),
16646        e.as_ptr(),
16647        &m,
16648        w.as_ptr(),
16649        iblock.as_ptr(),
16650        isplit.as_ptr(),
16651        z.as_mut_ptr() as *mut _,
16652        &ldz,
16653        work.as_mut_ptr(),
16654        iwork.as_mut_ptr(),
16655        ifail.as_mut_ptr(),
16656        info,
16657    )
16658}
16659
16660#[inline]
16661pub unsafe fn sdisna(job: u8, m: i32, n: i32, d: &[f32], sep: &mut [f32], info: &mut i32) {
16662    ffi::sdisna_(&(job as c_char), &m, &n, d.as_ptr(), sep.as_mut_ptr(), info)
16663}
16664
16665#[inline]
16666pub unsafe fn ddisna(job: u8, m: i32, n: i32, d: &[f64], sep: &mut [f64], info: &mut i32) {
16667    ffi::ddisna_(&(job as c_char), &m, &n, d.as_ptr(), sep.as_mut_ptr(), info)
16668}
16669
16670#[inline]
16671pub unsafe fn ssygst(
16672    itype: &[i32],
16673    uplo: u8,
16674    n: i32,
16675    a: &mut [f32],
16676    lda: i32,
16677    b: &[f32],
16678    ldb: i32,
16679    info: &mut i32,
16680) {
16681    ffi::ssygst_(
16682        itype.as_ptr(),
16683        &(uplo as c_char),
16684        &n,
16685        a.as_mut_ptr(),
16686        &lda,
16687        b.as_ptr(),
16688        &ldb,
16689        info,
16690    )
16691}
16692
16693#[inline]
16694pub unsafe fn dsygst(
16695    itype: &[i32],
16696    uplo: u8,
16697    n: i32,
16698    a: &mut [f64],
16699    lda: i32,
16700    b: &[f64],
16701    ldb: i32,
16702    info: &mut i32,
16703) {
16704    ffi::dsygst_(
16705        itype.as_ptr(),
16706        &(uplo as c_char),
16707        &n,
16708        a.as_mut_ptr(),
16709        &lda,
16710        b.as_ptr(),
16711        &ldb,
16712        info,
16713    )
16714}
16715
16716#[inline]
16717pub unsafe fn chegst(
16718    itype: &[i32],
16719    uplo: u8,
16720    n: i32,
16721    a: &mut [c32],
16722    lda: i32,
16723    b: &[c32],
16724    ldb: i32,
16725    info: &mut i32,
16726) {
16727    ffi::chegst_(
16728        itype.as_ptr(),
16729        &(uplo as c_char),
16730        &n,
16731        a.as_mut_ptr() as *mut _,
16732        &lda,
16733        b.as_ptr() as *const _,
16734        &ldb,
16735        info,
16736    )
16737}
16738
16739#[inline]
16740pub unsafe fn zhegst(
16741    itype: &[i32],
16742    uplo: u8,
16743    n: i32,
16744    a: &mut [c64],
16745    lda: i32,
16746    b: &[c64],
16747    ldb: i32,
16748    info: &mut i32,
16749) {
16750    ffi::zhegst_(
16751        itype.as_ptr(),
16752        &(uplo as c_char),
16753        &n,
16754        a.as_mut_ptr() as *mut _,
16755        &lda,
16756        b.as_ptr() as *const _,
16757        &ldb,
16758        info,
16759    )
16760}
16761
16762#[inline]
16763pub unsafe fn sspgst(itype: &[i32], uplo: u8, n: i32, ap: &mut [f32], bp: &[f32], info: &mut i32) {
16764    ffi::sspgst_(
16765        itype.as_ptr(),
16766        &(uplo as c_char),
16767        &n,
16768        ap.as_mut_ptr(),
16769        bp.as_ptr(),
16770        info,
16771    )
16772}
16773
16774#[inline]
16775pub unsafe fn dspgst(itype: &[i32], uplo: u8, n: i32, ap: &mut [f64], bp: &[f64], info: &mut i32) {
16776    ffi::dspgst_(
16777        itype.as_ptr(),
16778        &(uplo as c_char),
16779        &n,
16780        ap.as_mut_ptr(),
16781        bp.as_ptr(),
16782        info,
16783    )
16784}
16785
16786#[inline]
16787pub unsafe fn chpgst(itype: &[i32], uplo: u8, n: i32, ap: &mut [c32], bp: &[c32], info: &mut i32) {
16788    ffi::chpgst_(
16789        itype.as_ptr(),
16790        &(uplo as c_char),
16791        &n,
16792        ap.as_mut_ptr() as *mut _,
16793        bp.as_ptr() as *const _,
16794        info,
16795    )
16796}
16797
16798#[inline]
16799pub unsafe fn zhpgst(itype: &[i32], uplo: u8, n: i32, ap: &mut [c64], bp: &[c64], info: &mut i32) {
16800    ffi::zhpgst_(
16801        itype.as_ptr(),
16802        &(uplo as c_char),
16803        &n,
16804        ap.as_mut_ptr() as *mut _,
16805        bp.as_ptr() as *const _,
16806        info,
16807    )
16808}
16809
16810#[inline]
16811pub unsafe fn ssbgst(
16812    vect: u8,
16813    uplo: u8,
16814    n: i32,
16815    ka: i32,
16816    kb: i32,
16817    ab: &mut [f32],
16818    ldab: i32,
16819    bb: &[f32],
16820    ldbb: i32,
16821    x: &mut [f32],
16822    ldx: i32,
16823    work: &mut [f32],
16824    info: &mut i32,
16825) {
16826    ffi::ssbgst_(
16827        &(vect as c_char),
16828        &(uplo as c_char),
16829        &n,
16830        &ka,
16831        &kb,
16832        ab.as_mut_ptr(),
16833        &ldab,
16834        bb.as_ptr(),
16835        &ldbb,
16836        x.as_mut_ptr(),
16837        &ldx,
16838        work.as_mut_ptr(),
16839        info,
16840    )
16841}
16842
16843#[inline]
16844pub unsafe fn dsbgst(
16845    vect: u8,
16846    uplo: u8,
16847    n: i32,
16848    ka: i32,
16849    kb: i32,
16850    ab: &mut [f64],
16851    ldab: i32,
16852    bb: &[f64],
16853    ldbb: i32,
16854    x: &mut [f64],
16855    ldx: i32,
16856    work: &mut [f64],
16857    info: &mut i32,
16858) {
16859    ffi::dsbgst_(
16860        &(vect as c_char),
16861        &(uplo as c_char),
16862        &n,
16863        &ka,
16864        &kb,
16865        ab.as_mut_ptr(),
16866        &ldab,
16867        bb.as_ptr(),
16868        &ldbb,
16869        x.as_mut_ptr(),
16870        &ldx,
16871        work.as_mut_ptr(),
16872        info,
16873    )
16874}
16875
16876#[inline]
16877pub unsafe fn chbgst(
16878    vect: u8,
16879    uplo: u8,
16880    n: i32,
16881    ka: i32,
16882    kb: i32,
16883    ab: &mut [c32],
16884    ldab: i32,
16885    bb: &[c32],
16886    ldbb: i32,
16887    x: &mut [c32],
16888    ldx: i32,
16889    work: &mut [c32],
16890    rwork: &mut [f32],
16891    info: &mut i32,
16892) {
16893    ffi::chbgst_(
16894        &(vect as c_char),
16895        &(uplo as c_char),
16896        &n,
16897        &ka,
16898        &kb,
16899        ab.as_mut_ptr() as *mut _,
16900        &ldab,
16901        bb.as_ptr() as *const _,
16902        &ldbb,
16903        x.as_mut_ptr() as *mut _,
16904        &ldx,
16905        work.as_mut_ptr() as *mut _,
16906        rwork.as_mut_ptr(),
16907        info,
16908    )
16909}
16910
16911#[inline]
16912pub unsafe fn zhbgst(
16913    vect: u8,
16914    uplo: u8,
16915    n: i32,
16916    ka: i32,
16917    kb: i32,
16918    ab: &mut [c64],
16919    ldab: i32,
16920    bb: &[c64],
16921    ldbb: i32,
16922    x: &mut [c64],
16923    ldx: i32,
16924    work: &mut [c64],
16925    rwork: &mut [f64],
16926    info: &mut i32,
16927) {
16928    ffi::zhbgst_(
16929        &(vect as c_char),
16930        &(uplo as c_char),
16931        &n,
16932        &ka,
16933        &kb,
16934        ab.as_mut_ptr() as *mut _,
16935        &ldab,
16936        bb.as_ptr() as *const _,
16937        &ldbb,
16938        x.as_mut_ptr() as *mut _,
16939        &ldx,
16940        work.as_mut_ptr() as *mut _,
16941        rwork.as_mut_ptr(),
16942        info,
16943    )
16944}
16945
16946#[inline]
16947pub unsafe fn spbstf(uplo: u8, n: i32, kd: i32, ab: &mut [f32], ldab: i32, info: &mut i32) {
16948    ffi::spbstf_(&(uplo as c_char), &n, &kd, ab.as_mut_ptr(), &ldab, info)
16949}
16950
16951#[inline]
16952pub unsafe fn dpbstf(uplo: u8, n: i32, kd: i32, ab: &mut [f64], ldab: i32, info: &mut i32) {
16953    ffi::dpbstf_(&(uplo as c_char), &n, &kd, ab.as_mut_ptr(), &ldab, info)
16954}
16955
16956#[inline]
16957pub unsafe fn cpbstf(uplo: u8, n: i32, kd: i32, ab: &mut [c32], ldab: i32, info: &mut i32) {
16958    ffi::cpbstf_(
16959        &(uplo as c_char),
16960        &n,
16961        &kd,
16962        ab.as_mut_ptr() as *mut _,
16963        &ldab,
16964        info,
16965    )
16966}
16967
16968#[inline]
16969pub unsafe fn zpbstf(uplo: u8, n: i32, kd: i32, ab: &mut [c64], ldab: i32, info: &mut i32) {
16970    ffi::zpbstf_(
16971        &(uplo as c_char),
16972        &n,
16973        &kd,
16974        ab.as_mut_ptr() as *mut _,
16975        &ldab,
16976        info,
16977    )
16978}
16979
16980#[inline]
16981pub unsafe fn sgehrd(
16982    n: i32,
16983    ilo: i32,
16984    ihi: i32,
16985    a: &mut [f32],
16986    lda: i32,
16987    tau: &mut [f32],
16988    work: &mut [f32],
16989    lwork: i32,
16990    info: &mut i32,
16991) {
16992    ffi::sgehrd_(
16993        &n,
16994        &ilo,
16995        &ihi,
16996        a.as_mut_ptr(),
16997        &lda,
16998        tau.as_mut_ptr(),
16999        work.as_mut_ptr(),
17000        &lwork,
17001        info,
17002    )
17003}
17004
17005#[inline]
17006pub unsafe fn dgehrd(
17007    n: i32,
17008    ilo: i32,
17009    ihi: i32,
17010    a: &mut [f64],
17011    lda: i32,
17012    tau: &mut [f64],
17013    work: &mut [f64],
17014    lwork: i32,
17015    info: &mut i32,
17016) {
17017    ffi::dgehrd_(
17018        &n,
17019        &ilo,
17020        &ihi,
17021        a.as_mut_ptr(),
17022        &lda,
17023        tau.as_mut_ptr(),
17024        work.as_mut_ptr(),
17025        &lwork,
17026        info,
17027    )
17028}
17029
17030#[inline]
17031pub unsafe fn cgehrd(
17032    n: i32,
17033    ilo: i32,
17034    ihi: i32,
17035    a: &mut [c32],
17036    lda: i32,
17037    tau: &mut [c32],
17038    work: &mut [c32],
17039    lwork: i32,
17040    info: &mut i32,
17041) {
17042    ffi::cgehrd_(
17043        &n,
17044        &ilo,
17045        &ihi,
17046        a.as_mut_ptr() as *mut _,
17047        &lda,
17048        tau.as_mut_ptr() as *mut _,
17049        work.as_mut_ptr() as *mut _,
17050        &lwork,
17051        info,
17052    )
17053}
17054
17055#[inline]
17056pub unsafe fn zgehrd(
17057    n: i32,
17058    ilo: i32,
17059    ihi: i32,
17060    a: &mut [c64],
17061    lda: i32,
17062    tau: &mut [c64],
17063    work: &mut [c64],
17064    lwork: i32,
17065    info: &mut i32,
17066) {
17067    ffi::zgehrd_(
17068        &n,
17069        &ilo,
17070        &ihi,
17071        a.as_mut_ptr() as *mut _,
17072        &lda,
17073        tau.as_mut_ptr() as *mut _,
17074        work.as_mut_ptr() as *mut _,
17075        &lwork,
17076        info,
17077    )
17078}
17079
17080#[inline]
17081pub unsafe fn sorghr(
17082    n: i32,
17083    ilo: i32,
17084    ihi: i32,
17085    a: &mut [f32],
17086    lda: i32,
17087    tau: &[f32],
17088    work: &mut [f32],
17089    lwork: i32,
17090    info: &mut i32,
17091) {
17092    ffi::sorghr_(
17093        &n,
17094        &ilo,
17095        &ihi,
17096        a.as_mut_ptr(),
17097        &lda,
17098        tau.as_ptr(),
17099        work.as_mut_ptr(),
17100        &lwork,
17101        info,
17102    )
17103}
17104
17105#[inline]
17106pub unsafe fn dorghr(
17107    n: i32,
17108    ilo: i32,
17109    ihi: i32,
17110    a: &mut [f64],
17111    lda: i32,
17112    tau: &[f64],
17113    work: &mut [f64],
17114    lwork: i32,
17115    info: &mut i32,
17116) {
17117    ffi::dorghr_(
17118        &n,
17119        &ilo,
17120        &ihi,
17121        a.as_mut_ptr(),
17122        &lda,
17123        tau.as_ptr(),
17124        work.as_mut_ptr(),
17125        &lwork,
17126        info,
17127    )
17128}
17129
17130#[inline]
17131pub unsafe fn sormhr(
17132    side: u8,
17133    trans: u8,
17134    m: i32,
17135    n: i32,
17136    ilo: i32,
17137    ihi: i32,
17138    a: &[f32],
17139    lda: i32,
17140    tau: &[f32],
17141    c: &mut [f32],
17142    ldc: i32,
17143    work: &mut [f32],
17144    lwork: i32,
17145    info: &mut i32,
17146) {
17147    ffi::sormhr_(
17148        &(side as c_char),
17149        &(trans as c_char),
17150        &m,
17151        &n,
17152        &ilo,
17153        &ihi,
17154        a.as_ptr(),
17155        &lda,
17156        tau.as_ptr(),
17157        c.as_mut_ptr(),
17158        &ldc,
17159        work.as_mut_ptr(),
17160        &lwork,
17161        info,
17162    )
17163}
17164
17165#[inline]
17166pub unsafe fn dormhr(
17167    side: u8,
17168    trans: u8,
17169    m: i32,
17170    n: i32,
17171    ilo: i32,
17172    ihi: i32,
17173    a: &[f64],
17174    lda: i32,
17175    tau: &[f64],
17176    c: &mut [f64],
17177    ldc: i32,
17178    work: &mut [f64],
17179    lwork: i32,
17180    info: &mut i32,
17181) {
17182    ffi::dormhr_(
17183        &(side as c_char),
17184        &(trans as c_char),
17185        &m,
17186        &n,
17187        &ilo,
17188        &ihi,
17189        a.as_ptr(),
17190        &lda,
17191        tau.as_ptr(),
17192        c.as_mut_ptr(),
17193        &ldc,
17194        work.as_mut_ptr(),
17195        &lwork,
17196        info,
17197    )
17198}
17199
17200#[inline]
17201pub unsafe fn cunghr(
17202    n: i32,
17203    ilo: i32,
17204    ihi: i32,
17205    a: &mut [c32],
17206    lda: i32,
17207    tau: &[c32],
17208    work: &mut [c32],
17209    lwork: i32,
17210    info: &mut i32,
17211) {
17212    ffi::cunghr_(
17213        &n,
17214        &ilo,
17215        &ihi,
17216        a.as_mut_ptr() as *mut _,
17217        &lda,
17218        tau.as_ptr() as *const _,
17219        work.as_mut_ptr() as *mut _,
17220        &lwork,
17221        info,
17222    )
17223}
17224
17225#[inline]
17226pub unsafe fn zunghr(
17227    n: i32,
17228    ilo: i32,
17229    ihi: i32,
17230    a: &mut [c64],
17231    lda: i32,
17232    tau: &[c64],
17233    work: &mut [c64],
17234    lwork: i32,
17235    info: &mut i32,
17236) {
17237    ffi::zunghr_(
17238        &n,
17239        &ilo,
17240        &ihi,
17241        a.as_mut_ptr() as *mut _,
17242        &lda,
17243        tau.as_ptr() as *const _,
17244        work.as_mut_ptr() as *mut _,
17245        &lwork,
17246        info,
17247    )
17248}
17249
17250#[inline]
17251pub unsafe fn cunmhr(
17252    side: u8,
17253    trans: u8,
17254    m: i32,
17255    n: i32,
17256    ilo: i32,
17257    ihi: i32,
17258    a: &[c32],
17259    lda: i32,
17260    tau: &[c32],
17261    c: &mut [c32],
17262    ldc: i32,
17263    work: &mut [c32],
17264    lwork: i32,
17265    info: &mut i32,
17266) {
17267    ffi::cunmhr_(
17268        &(side as c_char),
17269        &(trans as c_char),
17270        &m,
17271        &n,
17272        &ilo,
17273        &ihi,
17274        a.as_ptr() as *const _,
17275        &lda,
17276        tau.as_ptr() as *const _,
17277        c.as_mut_ptr() as *mut _,
17278        &ldc,
17279        work.as_mut_ptr() as *mut _,
17280        &lwork,
17281        info,
17282    )
17283}
17284
17285#[inline]
17286pub unsafe fn zunmhr(
17287    side: u8,
17288    trans: u8,
17289    m: i32,
17290    n: i32,
17291    ilo: i32,
17292    ihi: i32,
17293    a: &[c64],
17294    lda: i32,
17295    tau: &[c64],
17296    c: &mut [c64],
17297    ldc: i32,
17298    work: &mut [c64],
17299    lwork: i32,
17300    info: &mut i32,
17301) {
17302    ffi::zunmhr_(
17303        &(side as c_char),
17304        &(trans as c_char),
17305        &m,
17306        &n,
17307        &ilo,
17308        &ihi,
17309        a.as_ptr() as *const _,
17310        &lda,
17311        tau.as_ptr() as *const _,
17312        c.as_mut_ptr() as *mut _,
17313        &ldc,
17314        work.as_mut_ptr() as *mut _,
17315        &lwork,
17316        info,
17317    )
17318}
17319
17320#[inline]
17321pub unsafe fn sgebal(
17322    job: u8,
17323    n: i32,
17324    a: &mut [f32],
17325    lda: i32,
17326    ilo: &mut i32,
17327    ihi: &mut i32,
17328    scale: &mut [f32],
17329    info: &mut i32,
17330) {
17331    ffi::sgebal_(
17332        &(job as c_char),
17333        &n,
17334        a.as_mut_ptr(),
17335        &lda,
17336        ilo,
17337        ihi,
17338        scale.as_mut_ptr(),
17339        info,
17340    )
17341}
17342
17343#[inline]
17344pub unsafe fn dgebal(
17345    job: u8,
17346    n: i32,
17347    a: &mut [f64],
17348    lda: i32,
17349    ilo: &mut i32,
17350    ihi: &mut i32,
17351    scale: &mut [f64],
17352    info: &mut i32,
17353) {
17354    ffi::dgebal_(
17355        &(job as c_char),
17356        &n,
17357        a.as_mut_ptr(),
17358        &lda,
17359        ilo,
17360        ihi,
17361        scale.as_mut_ptr(),
17362        info,
17363    )
17364}
17365
17366#[inline]
17367pub unsafe fn cgebal(
17368    job: u8,
17369    n: i32,
17370    a: &mut [c32],
17371    lda: i32,
17372    ilo: &mut i32,
17373    ihi: &mut i32,
17374    scale: &mut [f32],
17375    info: &mut i32,
17376) {
17377    ffi::cgebal_(
17378        &(job as c_char),
17379        &n,
17380        a.as_mut_ptr() as *mut _,
17381        &lda,
17382        ilo,
17383        ihi,
17384        scale.as_mut_ptr(),
17385        info,
17386    )
17387}
17388
17389#[inline]
17390pub unsafe fn zgebal(
17391    job: u8,
17392    n: i32,
17393    a: &mut [c64],
17394    lda: i32,
17395    ilo: &mut i32,
17396    ihi: &mut i32,
17397    scale: &mut [f64],
17398    info: &mut i32,
17399) {
17400    ffi::zgebal_(
17401        &(job as c_char),
17402        &n,
17403        a.as_mut_ptr() as *mut _,
17404        &lda,
17405        ilo,
17406        ihi,
17407        scale.as_mut_ptr(),
17408        info,
17409    )
17410}
17411
17412#[inline]
17413pub unsafe fn sgebak(
17414    job: u8,
17415    side: u8,
17416    n: i32,
17417    ilo: i32,
17418    ihi: i32,
17419    scale: &[f32],
17420    m: i32,
17421    v: &mut [f32],
17422    ldv: i32,
17423    info: &mut i32,
17424) {
17425    ffi::sgebak_(
17426        &(job as c_char),
17427        &(side as c_char),
17428        &n,
17429        &ilo,
17430        &ihi,
17431        scale.as_ptr(),
17432        &m,
17433        v.as_mut_ptr(),
17434        &ldv,
17435        info,
17436    )
17437}
17438
17439#[inline]
17440pub unsafe fn dgebak(
17441    job: u8,
17442    side: u8,
17443    n: i32,
17444    ilo: i32,
17445    ihi: i32,
17446    scale: &[f64],
17447    m: i32,
17448    v: &mut [f64],
17449    ldv: i32,
17450    info: &mut i32,
17451) {
17452    ffi::dgebak_(
17453        &(job as c_char),
17454        &(side as c_char),
17455        &n,
17456        &ilo,
17457        &ihi,
17458        scale.as_ptr(),
17459        &m,
17460        v.as_mut_ptr(),
17461        &ldv,
17462        info,
17463    )
17464}
17465
17466#[inline]
17467pub unsafe fn cgebak(
17468    job: u8,
17469    side: u8,
17470    n: i32,
17471    ilo: i32,
17472    ihi: i32,
17473    scale: &[f32],
17474    m: i32,
17475    v: &mut [c32],
17476    ldv: i32,
17477    info: &mut i32,
17478) {
17479    ffi::cgebak_(
17480        &(job as c_char),
17481        &(side as c_char),
17482        &n,
17483        &ilo,
17484        &ihi,
17485        scale.as_ptr(),
17486        &m,
17487        v.as_mut_ptr() as *mut _,
17488        &ldv,
17489        info,
17490    )
17491}
17492
17493#[inline]
17494pub unsafe fn zgebak(
17495    job: u8,
17496    side: u8,
17497    n: i32,
17498    ilo: i32,
17499    ihi: i32,
17500    scale: &[f64],
17501    m: i32,
17502    v: &mut [c64],
17503    ldv: i32,
17504    info: &mut i32,
17505) {
17506    ffi::zgebak_(
17507        &(job as c_char),
17508        &(side as c_char),
17509        &n,
17510        &ilo,
17511        &ihi,
17512        scale.as_ptr(),
17513        &m,
17514        v.as_mut_ptr() as *mut _,
17515        &ldv,
17516        info,
17517    )
17518}
17519
17520#[inline]
17521pub unsafe fn shseqr(
17522    job: u8,
17523    compz: u8,
17524    n: i32,
17525    ilo: i32,
17526    ihi: i32,
17527    h: &mut [f32],
17528    ldh: i32,
17529    wr: &mut [f32],
17530    wi: &mut [f32],
17531    z: &mut [f32],
17532    ldz: i32,
17533    work: &mut [f32],
17534    lwork: i32,
17535    info: &mut i32,
17536) {
17537    ffi::shseqr_(
17538        &(job as c_char),
17539        &(compz as c_char),
17540        &n,
17541        &ilo,
17542        &ihi,
17543        h.as_mut_ptr(),
17544        &ldh,
17545        wr.as_mut_ptr(),
17546        wi.as_mut_ptr(),
17547        z.as_mut_ptr(),
17548        &ldz,
17549        work.as_mut_ptr(),
17550        &lwork,
17551        info,
17552    )
17553}
17554
17555#[inline]
17556pub unsafe fn dhseqr(
17557    job: u8,
17558    compz: u8,
17559    n: i32,
17560    ilo: i32,
17561    ihi: i32,
17562    h: &mut [f64],
17563    ldh: i32,
17564    wr: &mut [f64],
17565    wi: &mut [f64],
17566    z: &mut [f64],
17567    ldz: i32,
17568    work: &mut [f64],
17569    lwork: i32,
17570    info: &mut i32,
17571) {
17572    ffi::dhseqr_(
17573        &(job as c_char),
17574        &(compz as c_char),
17575        &n,
17576        &ilo,
17577        &ihi,
17578        h.as_mut_ptr(),
17579        &ldh,
17580        wr.as_mut_ptr(),
17581        wi.as_mut_ptr(),
17582        z.as_mut_ptr(),
17583        &ldz,
17584        work.as_mut_ptr(),
17585        &lwork,
17586        info,
17587    )
17588}
17589
17590#[inline]
17591pub unsafe fn chseqr(
17592    job: u8,
17593    compz: u8,
17594    n: i32,
17595    ilo: i32,
17596    ihi: i32,
17597    h: &mut [c32],
17598    ldh: i32,
17599    w: &mut [c32],
17600    z: &mut [c32],
17601    ldz: i32,
17602    work: &mut [c32],
17603    lwork: i32,
17604    info: &mut i32,
17605) {
17606    ffi::chseqr_(
17607        &(job as c_char),
17608        &(compz as c_char),
17609        &n,
17610        &ilo,
17611        &ihi,
17612        h.as_mut_ptr() as *mut _,
17613        &ldh,
17614        w.as_mut_ptr() as *mut _,
17615        z.as_mut_ptr() as *mut _,
17616        &ldz,
17617        work.as_mut_ptr() as *mut _,
17618        &lwork,
17619        info,
17620    )
17621}
17622
17623#[inline]
17624pub unsafe fn zhseqr(
17625    job: u8,
17626    compz: u8,
17627    n: i32,
17628    ilo: i32,
17629    ihi: i32,
17630    h: &mut [c64],
17631    ldh: i32,
17632    w: &mut [c64],
17633    z: &mut [c64],
17634    ldz: i32,
17635    work: &mut [c64],
17636    lwork: i32,
17637    info: &mut i32,
17638) {
17639    ffi::zhseqr_(
17640        &(job as c_char),
17641        &(compz as c_char),
17642        &n,
17643        &ilo,
17644        &ihi,
17645        h.as_mut_ptr() as *mut _,
17646        &ldh,
17647        w.as_mut_ptr() as *mut _,
17648        z.as_mut_ptr() as *mut _,
17649        &ldz,
17650        work.as_mut_ptr() as *mut _,
17651        &lwork,
17652        info,
17653    )
17654}
17655
17656#[inline]
17657pub unsafe fn shsein(
17658    job: u8,
17659    eigsrc: u8,
17660    initv: u8,
17661    select: &mut [i32],
17662    n: i32,
17663    h: &[f32],
17664    ldh: i32,
17665    wr: &mut [f32],
17666    wi: &[f32],
17667    vl: &mut f32,
17668    ldvl: i32,
17669    vr: &mut f32,
17670    ldvr: i32,
17671    mm: i32,
17672    m: &mut i32,
17673    work: &mut [f32],
17674    ifaill: &mut [i32],
17675    ifailr: &mut [i32],
17676    info: &mut i32,
17677) {
17678    ffi::shsein_(
17679        &(job as c_char),
17680        &(eigsrc as c_char),
17681        &(initv as c_char),
17682        select.as_mut_ptr(),
17683        &n,
17684        h.as_ptr(),
17685        &ldh,
17686        wr.as_mut_ptr(),
17687        wi.as_ptr(),
17688        vl,
17689        &ldvl,
17690        vr,
17691        &ldvr,
17692        &mm,
17693        m,
17694        work.as_mut_ptr(),
17695        ifaill.as_mut_ptr(),
17696        ifailr.as_mut_ptr(),
17697        info,
17698    )
17699}
17700
17701#[inline]
17702pub unsafe fn dhsein(
17703    job: u8,
17704    eigsrc: u8,
17705    initv: u8,
17706    select: &mut [i32],
17707    n: i32,
17708    h: &[f64],
17709    ldh: i32,
17710    wr: &mut [f64],
17711    wi: &[f64],
17712    vl: &mut f64,
17713    ldvl: i32,
17714    vr: &mut f64,
17715    ldvr: i32,
17716    mm: i32,
17717    m: &mut i32,
17718    work: &mut [f64],
17719    ifaill: &mut [i32],
17720    ifailr: &mut [i32],
17721    info: &mut i32,
17722) {
17723    ffi::dhsein_(
17724        &(job as c_char),
17725        &(eigsrc as c_char),
17726        &(initv as c_char),
17727        select.as_mut_ptr(),
17728        &n,
17729        h.as_ptr(),
17730        &ldh,
17731        wr.as_mut_ptr(),
17732        wi.as_ptr(),
17733        vl,
17734        &ldvl,
17735        vr,
17736        &ldvr,
17737        &mm,
17738        m,
17739        work.as_mut_ptr(),
17740        ifaill.as_mut_ptr(),
17741        ifailr.as_mut_ptr(),
17742        info,
17743    )
17744}
17745
17746#[inline]
17747pub unsafe fn chsein(
17748    job: u8,
17749    eigsrc: u8,
17750    initv: u8,
17751    select: &[i32],
17752    n: i32,
17753    h: &[c32],
17754    ldh: i32,
17755    w: &mut [c32],
17756    vl: &mut c32,
17757    ldvl: i32,
17758    vr: &mut c32,
17759    ldvr: i32,
17760    mm: i32,
17761    m: &mut i32,
17762    work: &mut [c32],
17763    rwork: &mut [f32],
17764    ifaill: &mut [i32],
17765    ifailr: &mut [i32],
17766    info: &mut i32,
17767) {
17768    ffi::chsein_(
17769        &(job as c_char),
17770        &(eigsrc as c_char),
17771        &(initv as c_char),
17772        select.as_ptr(),
17773        &n,
17774        h.as_ptr() as *const _,
17775        &ldh,
17776        w.as_mut_ptr() as *mut _,
17777        vl as *mut _ as *mut _,
17778        &ldvl,
17779        vr as *mut _ as *mut _,
17780        &ldvr,
17781        &mm,
17782        m,
17783        work.as_mut_ptr() as *mut _,
17784        rwork.as_mut_ptr(),
17785        ifaill.as_mut_ptr(),
17786        ifailr.as_mut_ptr(),
17787        info,
17788    )
17789}
17790
17791#[inline]
17792pub unsafe fn zhsein(
17793    job: u8,
17794    eigsrc: u8,
17795    initv: u8,
17796    select: &[i32],
17797    n: i32,
17798    h: &[c64],
17799    ldh: i32,
17800    w: &mut [c64],
17801    vl: &mut c64,
17802    ldvl: i32,
17803    vr: &mut c64,
17804    ldvr: i32,
17805    mm: i32,
17806    m: &mut i32,
17807    work: &mut [c64],
17808    rwork: &mut [f64],
17809    ifaill: &mut [i32],
17810    ifailr: &mut [i32],
17811    info: &mut i32,
17812) {
17813    ffi::zhsein_(
17814        &(job as c_char),
17815        &(eigsrc as c_char),
17816        &(initv as c_char),
17817        select.as_ptr(),
17818        &n,
17819        h.as_ptr() as *const _,
17820        &ldh,
17821        w.as_mut_ptr() as *mut _,
17822        vl as *mut _ as *mut _,
17823        &ldvl,
17824        vr as *mut _ as *mut _,
17825        &ldvr,
17826        &mm,
17827        m,
17828        work.as_mut_ptr() as *mut _,
17829        rwork.as_mut_ptr(),
17830        ifaill.as_mut_ptr(),
17831        ifailr.as_mut_ptr(),
17832        info,
17833    )
17834}
17835
17836#[inline]
17837pub unsafe fn strevc(
17838    side: u8,
17839    howmny: u8,
17840    select: &mut [i32],
17841    n: i32,
17842    t: &[f32],
17843    ldt: i32,
17844    vl: &mut f32,
17845    ldvl: i32,
17846    vr: &mut f32,
17847    ldvr: i32,
17848    mm: i32,
17849    m: &mut i32,
17850    work: &mut [f32],
17851    info: &mut i32,
17852) {
17853    ffi::strevc_(
17854        &(side as c_char),
17855        &(howmny as c_char),
17856        select.as_mut_ptr(),
17857        &n,
17858        t.as_ptr(),
17859        &ldt,
17860        vl,
17861        &ldvl,
17862        vr,
17863        &ldvr,
17864        &mm,
17865        m,
17866        work.as_mut_ptr(),
17867        info,
17868    )
17869}
17870
17871#[inline]
17872pub unsafe fn dtrevc(
17873    side: u8,
17874    howmny: u8,
17875    select: &mut [i32],
17876    n: i32,
17877    t: &[f64],
17878    ldt: i32,
17879    vl: &mut f64,
17880    ldvl: i32,
17881    vr: &mut f64,
17882    ldvr: i32,
17883    mm: i32,
17884    m: &mut i32,
17885    work: &mut [f64],
17886    info: &mut i32,
17887) {
17888    ffi::dtrevc_(
17889        &(side as c_char),
17890        &(howmny as c_char),
17891        select.as_mut_ptr(),
17892        &n,
17893        t.as_ptr(),
17894        &ldt,
17895        vl,
17896        &ldvl,
17897        vr,
17898        &ldvr,
17899        &mm,
17900        m,
17901        work.as_mut_ptr(),
17902        info,
17903    )
17904}
17905
17906#[inline]
17907pub unsafe fn ctrevc(
17908    side: u8,
17909    howmny: u8,
17910    select: &[i32],
17911    n: i32,
17912    t: &mut [c32],
17913    ldt: i32,
17914    vl: &mut c32,
17915    ldvl: i32,
17916    vr: &mut c32,
17917    ldvr: i32,
17918    mm: i32,
17919    m: &mut i32,
17920    work: &mut [c32],
17921    rwork: &mut [f32],
17922    info: &mut i32,
17923) {
17924    ffi::ctrevc_(
17925        &(side as c_char),
17926        &(howmny as c_char),
17927        select.as_ptr(),
17928        &n,
17929        t.as_mut_ptr() as *mut _,
17930        &ldt,
17931        vl as *mut _ as *mut _,
17932        &ldvl,
17933        vr as *mut _ as *mut _,
17934        &ldvr,
17935        &mm,
17936        m,
17937        work.as_mut_ptr() as *mut _,
17938        rwork.as_mut_ptr(),
17939        info,
17940    )
17941}
17942
17943#[inline]
17944pub unsafe fn ztrevc(
17945    side: u8,
17946    howmny: u8,
17947    select: &[i32],
17948    n: i32,
17949    t: &mut [c64],
17950    ldt: i32,
17951    vl: &mut c64,
17952    ldvl: i32,
17953    vr: &mut c64,
17954    ldvr: i32,
17955    mm: i32,
17956    m: &mut i32,
17957    work: &mut [c64],
17958    rwork: &mut [f64],
17959    info: &mut i32,
17960) {
17961    ffi::ztrevc_(
17962        &(side as c_char),
17963        &(howmny as c_char),
17964        select.as_ptr(),
17965        &n,
17966        t.as_mut_ptr() as *mut _,
17967        &ldt,
17968        vl as *mut _ as *mut _,
17969        &ldvl,
17970        vr as *mut _ as *mut _,
17971        &ldvr,
17972        &mm,
17973        m,
17974        work.as_mut_ptr() as *mut _,
17975        rwork.as_mut_ptr(),
17976        info,
17977    )
17978}
17979
17980#[inline]
17981pub unsafe fn strsna(
17982    job: u8,
17983    howmny: u8,
17984    select: &[i32],
17985    n: i32,
17986    t: &[f32],
17987    ldt: i32,
17988    vl: &[f32],
17989    ldvl: i32,
17990    vr: &[f32],
17991    ldvr: i32,
17992    s: &mut [f32],
17993    sep: &mut [f32],
17994    mm: i32,
17995    m: &mut i32,
17996    work: &mut [f32],
17997    ldwork: i32,
17998    iwork: &mut [i32],
17999    info: &mut i32,
18000) {
18001    ffi::strsna_(
18002        &(job as c_char),
18003        &(howmny as c_char),
18004        select.as_ptr(),
18005        &n,
18006        t.as_ptr(),
18007        &ldt,
18008        vl.as_ptr(),
18009        &ldvl,
18010        vr.as_ptr(),
18011        &ldvr,
18012        s.as_mut_ptr(),
18013        sep.as_mut_ptr(),
18014        &mm,
18015        m,
18016        work.as_mut_ptr(),
18017        &ldwork,
18018        iwork.as_mut_ptr(),
18019        info,
18020    )
18021}
18022
18023#[inline]
18024pub unsafe fn dtrsna(
18025    job: u8,
18026    howmny: u8,
18027    select: &[i32],
18028    n: i32,
18029    t: &[f64],
18030    ldt: i32,
18031    vl: &[f64],
18032    ldvl: i32,
18033    vr: &[f64],
18034    ldvr: i32,
18035    s: &mut [f64],
18036    sep: &mut [f64],
18037    mm: i32,
18038    m: &mut i32,
18039    work: &mut [f64],
18040    ldwork: i32,
18041    iwork: &mut [i32],
18042    info: &mut i32,
18043) {
18044    ffi::dtrsna_(
18045        &(job as c_char),
18046        &(howmny as c_char),
18047        select.as_ptr(),
18048        &n,
18049        t.as_ptr(),
18050        &ldt,
18051        vl.as_ptr(),
18052        &ldvl,
18053        vr.as_ptr(),
18054        &ldvr,
18055        s.as_mut_ptr(),
18056        sep.as_mut_ptr(),
18057        &mm,
18058        m,
18059        work.as_mut_ptr(),
18060        &ldwork,
18061        iwork.as_mut_ptr(),
18062        info,
18063    )
18064}
18065
18066#[inline]
18067pub unsafe fn ctrsna(
18068    job: u8,
18069    howmny: u8,
18070    select: &[i32],
18071    n: i32,
18072    t: &[c32],
18073    ldt: i32,
18074    vl: &[c32],
18075    ldvl: i32,
18076    vr: &[c32],
18077    ldvr: i32,
18078    s: &mut [f32],
18079    sep: &mut [f32],
18080    mm: i32,
18081    m: &mut i32,
18082    work: &mut [c32],
18083    ldwork: i32,
18084    rwork: &mut [f32],
18085    info: &mut i32,
18086) {
18087    ffi::ctrsna_(
18088        &(job as c_char),
18089        &(howmny as c_char),
18090        select.as_ptr(),
18091        &n,
18092        t.as_ptr() as *const _,
18093        &ldt,
18094        vl.as_ptr() as *const _,
18095        &ldvl,
18096        vr.as_ptr() as *const _,
18097        &ldvr,
18098        s.as_mut_ptr(),
18099        sep.as_mut_ptr(),
18100        &mm,
18101        m,
18102        work.as_mut_ptr() as *mut _,
18103        &ldwork,
18104        rwork.as_mut_ptr(),
18105        info,
18106    )
18107}
18108
18109#[inline]
18110pub unsafe fn ztrsna(
18111    job: u8,
18112    howmny: u8,
18113    select: &[i32],
18114    n: i32,
18115    t: &[c64],
18116    ldt: i32,
18117    vl: &[c64],
18118    ldvl: i32,
18119    vr: &[c64],
18120    ldvr: i32,
18121    s: &mut [f64],
18122    sep: &mut [f64],
18123    mm: i32,
18124    m: &mut i32,
18125    work: &mut [c64],
18126    ldwork: i32,
18127    rwork: &mut [f64],
18128    info: &mut i32,
18129) {
18130    ffi::ztrsna_(
18131        &(job as c_char),
18132        &(howmny as c_char),
18133        select.as_ptr(),
18134        &n,
18135        t.as_ptr() as *const _,
18136        &ldt,
18137        vl.as_ptr() as *const _,
18138        &ldvl,
18139        vr.as_ptr() as *const _,
18140        &ldvr,
18141        s.as_mut_ptr(),
18142        sep.as_mut_ptr(),
18143        &mm,
18144        m,
18145        work.as_mut_ptr() as *mut _,
18146        &ldwork,
18147        rwork.as_mut_ptr(),
18148        info,
18149    )
18150}
18151
18152#[inline]
18153pub unsafe fn strexc(
18154    compq: u8,
18155    n: i32,
18156    t: &mut [f32],
18157    ldt: i32,
18158    q: &mut [f32],
18159    ldq: i32,
18160    ifst: &[i32],
18161    ilst: &mut [i32],
18162    work: &mut [f32],
18163    info: &mut i32,
18164) {
18165    ffi::strexc_(
18166        &(compq as c_char),
18167        &n,
18168        t.as_mut_ptr(),
18169        &ldt,
18170        q.as_mut_ptr(),
18171        &ldq,
18172        ifst.as_ptr(),
18173        ilst.as_mut_ptr(),
18174        work.as_mut_ptr(),
18175        info,
18176    )
18177}
18178
18179#[inline]
18180pub unsafe fn dtrexc(
18181    compq: u8,
18182    n: i32,
18183    t: &mut [f64],
18184    ldt: i32,
18185    q: &mut [f64],
18186    ldq: i32,
18187    ifst: &[i32],
18188    ilst: &mut [i32],
18189    work: &mut [f64],
18190    info: &mut i32,
18191) {
18192    ffi::dtrexc_(
18193        &(compq as c_char),
18194        &n,
18195        t.as_mut_ptr(),
18196        &ldt,
18197        q.as_mut_ptr(),
18198        &ldq,
18199        ifst.as_ptr(),
18200        ilst.as_mut_ptr(),
18201        work.as_mut_ptr(),
18202        info,
18203    )
18204}
18205
18206#[inline]
18207pub unsafe fn ctrexc(
18208    compq: u8,
18209    n: i32,
18210    t: &mut [c32],
18211    ldt: i32,
18212    q: &mut [c32],
18213    ldq: i32,
18214    ifst: &[i32],
18215    ilst: &[i32],
18216    info: i32,
18217) {
18218    ffi::ctrexc_(
18219        &(compq as c_char),
18220        &n,
18221        t.as_mut_ptr() as *mut _,
18222        &ldt,
18223        q.as_mut_ptr() as *mut _,
18224        &ldq,
18225        ifst.as_ptr(),
18226        ilst.as_ptr(),
18227        &info,
18228    )
18229}
18230
18231#[inline]
18232pub unsafe fn ztrexc(
18233    compq: u8,
18234    n: i32,
18235    t: &mut [c64],
18236    ldt: i32,
18237    q: &mut [c64],
18238    ldq: i32,
18239    ifst: &[i32],
18240    ilst: &[i32],
18241    info: i32,
18242) {
18243    ffi::ztrexc_(
18244        &(compq as c_char),
18245        &n,
18246        t.as_mut_ptr() as *mut _,
18247        &ldt,
18248        q.as_mut_ptr() as *mut _,
18249        &ldq,
18250        ifst.as_ptr(),
18251        ilst.as_ptr(),
18252        &info,
18253    )
18254}
18255
18256#[inline]
18257pub unsafe fn strsen(
18258    job: u8,
18259    compq: u8,
18260    select: &[i32],
18261    n: i32,
18262    t: &mut [f32],
18263    ldt: i32,
18264    q: &mut [f32],
18265    ldq: i32,
18266    wr: &mut [f32],
18267    wi: &mut [f32],
18268    m: &mut i32,
18269    s: &mut [f32],
18270    sep: &mut [f32],
18271    work: &mut [f32],
18272    lwork: i32,
18273    iwork: &mut [i32],
18274    liwork: i32,
18275    info: &mut i32,
18276) {
18277    ffi::strsen_(
18278        &(job as c_char),
18279        &(compq as c_char),
18280        select.as_ptr(),
18281        &n,
18282        t.as_mut_ptr(),
18283        &ldt,
18284        q.as_mut_ptr(),
18285        &ldq,
18286        wr.as_mut_ptr(),
18287        wi.as_mut_ptr(),
18288        m,
18289        s.as_mut_ptr(),
18290        sep.as_mut_ptr(),
18291        work.as_mut_ptr(),
18292        &lwork,
18293        iwork.as_mut_ptr(),
18294        &liwork,
18295        info,
18296    )
18297}
18298
18299#[inline]
18300pub unsafe fn dtrsen(
18301    job: u8,
18302    compq: u8,
18303    select: &[i32],
18304    n: i32,
18305    t: &mut [f64],
18306    ldt: i32,
18307    q: &mut [f64],
18308    ldq: i32,
18309    wr: &mut [f64],
18310    wi: &mut [f64],
18311    m: &mut i32,
18312    s: &mut [f64],
18313    sep: &mut [f64],
18314    work: &mut [f64],
18315    lwork: i32,
18316    iwork: &mut [i32],
18317    liwork: i32,
18318    info: &mut i32,
18319) {
18320    ffi::dtrsen_(
18321        &(job as c_char),
18322        &(compq as c_char),
18323        select.as_ptr(),
18324        &n,
18325        t.as_mut_ptr(),
18326        &ldt,
18327        q.as_mut_ptr(),
18328        &ldq,
18329        wr.as_mut_ptr(),
18330        wi.as_mut_ptr(),
18331        m,
18332        s.as_mut_ptr(),
18333        sep.as_mut_ptr(),
18334        work.as_mut_ptr(),
18335        &lwork,
18336        iwork.as_mut_ptr(),
18337        &liwork,
18338        info,
18339    )
18340}
18341
18342#[inline]
18343pub unsafe fn ctrsen(
18344    job: u8,
18345    compq: u8,
18346    select: &[i32],
18347    n: i32,
18348    t: &mut [c32],
18349    ldt: i32,
18350    q: &mut [c32],
18351    ldq: i32,
18352    w: &mut [c32],
18353    m: &mut i32,
18354    s: &mut [f32],
18355    sep: &mut [f32],
18356    work: &mut [c32],
18357    lwork: i32,
18358    info: &mut i32,
18359) {
18360    ffi::ctrsen_(
18361        &(job as c_char),
18362        &(compq as c_char),
18363        select.as_ptr(),
18364        &n,
18365        t.as_mut_ptr() as *mut _,
18366        &ldt,
18367        q.as_mut_ptr() as *mut _,
18368        &ldq,
18369        w.as_mut_ptr() as *mut _,
18370        m,
18371        s.as_mut_ptr(),
18372        sep.as_mut_ptr(),
18373        work.as_mut_ptr() as *mut _,
18374        &lwork,
18375        info,
18376    )
18377}
18378
18379#[inline]
18380pub unsafe fn ztrsen(
18381    job: u8,
18382    compq: u8,
18383    select: &[i32],
18384    n: i32,
18385    t: &mut [c64],
18386    ldt: i32,
18387    q: &mut [c64],
18388    ldq: i32,
18389    w: &mut [c64],
18390    m: &mut i32,
18391    s: &mut [f64],
18392    sep: &mut [f64],
18393    work: &mut [c64],
18394    lwork: i32,
18395    info: &mut i32,
18396) {
18397    ffi::ztrsen_(
18398        &(job as c_char),
18399        &(compq as c_char),
18400        select.as_ptr(),
18401        &n,
18402        t.as_mut_ptr() as *mut _,
18403        &ldt,
18404        q.as_mut_ptr() as *mut _,
18405        &ldq,
18406        w.as_mut_ptr() as *mut _,
18407        m,
18408        s.as_mut_ptr(),
18409        sep.as_mut_ptr(),
18410        work.as_mut_ptr() as *mut _,
18411        &lwork,
18412        info,
18413    )
18414}
18415
18416#[inline]
18417pub unsafe fn strsyl(
18418    trana: u8,
18419    tranb: u8,
18420    isgn: &[i32],
18421    m: i32,
18422    n: i32,
18423    a: &[f32],
18424    lda: i32,
18425    b: &[f32],
18426    ldb: i32,
18427    c: &mut [f32],
18428    ldc: i32,
18429    scale: &mut [f32],
18430    info: &mut i32,
18431) {
18432    ffi::strsyl_(
18433        &(trana as c_char),
18434        &(tranb as c_char),
18435        isgn.as_ptr(),
18436        &m,
18437        &n,
18438        a.as_ptr(),
18439        &lda,
18440        b.as_ptr(),
18441        &ldb,
18442        c.as_mut_ptr(),
18443        &ldc,
18444        scale.as_mut_ptr(),
18445        info,
18446    )
18447}
18448
18449#[inline]
18450pub unsafe fn dtrsyl(
18451    trana: u8,
18452    tranb: u8,
18453    isgn: &[i32],
18454    m: i32,
18455    n: i32,
18456    a: &[f64],
18457    lda: i32,
18458    b: &[f64],
18459    ldb: i32,
18460    c: &mut [f64],
18461    ldc: i32,
18462    scale: &mut [f64],
18463    info: &mut i32,
18464) {
18465    ffi::dtrsyl_(
18466        &(trana as c_char),
18467        &(tranb as c_char),
18468        isgn.as_ptr(),
18469        &m,
18470        &n,
18471        a.as_ptr(),
18472        &lda,
18473        b.as_ptr(),
18474        &ldb,
18475        c.as_mut_ptr(),
18476        &ldc,
18477        scale.as_mut_ptr(),
18478        info,
18479    )
18480}
18481
18482#[inline]
18483pub unsafe fn ctrsyl(
18484    trana: u8,
18485    tranb: u8,
18486    isgn: &[i32],
18487    m: i32,
18488    n: i32,
18489    a: &[c32],
18490    lda: i32,
18491    b: &[c32],
18492    ldb: i32,
18493    c: &mut [c32],
18494    ldc: i32,
18495    scale: &mut [f32],
18496    info: &mut i32,
18497) {
18498    ffi::ctrsyl_(
18499        &(trana as c_char),
18500        &(tranb as c_char),
18501        isgn.as_ptr(),
18502        &m,
18503        &n,
18504        a.as_ptr() as *const _,
18505        &lda,
18506        b.as_ptr() as *const _,
18507        &ldb,
18508        c.as_mut_ptr() as *mut _,
18509        &ldc,
18510        scale.as_mut_ptr(),
18511        info,
18512    )
18513}
18514
18515#[inline]
18516pub unsafe fn ztrsyl(
18517    trana: u8,
18518    tranb: u8,
18519    isgn: &[i32],
18520    m: i32,
18521    n: i32,
18522    a: &[c64],
18523    lda: i32,
18524    b: &[c64],
18525    ldb: i32,
18526    c: &mut [c64],
18527    ldc: i32,
18528    scale: &mut [f64],
18529    info: &mut i32,
18530) {
18531    ffi::ztrsyl_(
18532        &(trana as c_char),
18533        &(tranb as c_char),
18534        isgn.as_ptr(),
18535        &m,
18536        &n,
18537        a.as_ptr() as *const _,
18538        &lda,
18539        b.as_ptr() as *const _,
18540        &ldb,
18541        c.as_mut_ptr() as *mut _,
18542        &ldc,
18543        scale.as_mut_ptr(),
18544        info,
18545    )
18546}
18547
18548#[inline]
18549pub unsafe fn sgghrd(
18550    compq: u8,
18551    compz: u8,
18552    n: i32,
18553    ilo: i32,
18554    ihi: i32,
18555    a: &mut [f32],
18556    lda: i32,
18557    b: &mut [f32],
18558    ldb: i32,
18559    q: &mut [f32],
18560    ldq: i32,
18561    z: &mut [f32],
18562    ldz: i32,
18563    info: &mut i32,
18564) {
18565    ffi::sgghrd_(
18566        &(compq as c_char),
18567        &(compz as c_char),
18568        &n,
18569        &ilo,
18570        &ihi,
18571        a.as_mut_ptr(),
18572        &lda,
18573        b.as_mut_ptr(),
18574        &ldb,
18575        q.as_mut_ptr(),
18576        &ldq,
18577        z.as_mut_ptr(),
18578        &ldz,
18579        info,
18580    )
18581}
18582
18583#[inline]
18584pub unsafe fn dgghrd(
18585    compq: u8,
18586    compz: u8,
18587    n: i32,
18588    ilo: i32,
18589    ihi: i32,
18590    a: &mut [f64],
18591    lda: i32,
18592    b: &mut [f64],
18593    ldb: i32,
18594    q: &mut [f64],
18595    ldq: i32,
18596    z: &mut [f64],
18597    ldz: i32,
18598    info: &mut i32,
18599) {
18600    ffi::dgghrd_(
18601        &(compq as c_char),
18602        &(compz as c_char),
18603        &n,
18604        &ilo,
18605        &ihi,
18606        a.as_mut_ptr(),
18607        &lda,
18608        b.as_mut_ptr(),
18609        &ldb,
18610        q.as_mut_ptr(),
18611        &ldq,
18612        z.as_mut_ptr(),
18613        &ldz,
18614        info,
18615    )
18616}
18617
18618#[inline]
18619pub unsafe fn cgghrd(
18620    compq: u8,
18621    compz: u8,
18622    n: i32,
18623    ilo: i32,
18624    ihi: i32,
18625    a: &mut [c32],
18626    lda: i32,
18627    b: &mut [c32],
18628    ldb: i32,
18629    q: &mut [c32],
18630    ldq: i32,
18631    z: &mut [c32],
18632    ldz: i32,
18633    info: &mut i32,
18634) {
18635    ffi::cgghrd_(
18636        &(compq as c_char),
18637        &(compz as c_char),
18638        &n,
18639        &ilo,
18640        &ihi,
18641        a.as_mut_ptr() as *mut _,
18642        &lda,
18643        b.as_mut_ptr() as *mut _,
18644        &ldb,
18645        q.as_mut_ptr() as *mut _,
18646        &ldq,
18647        z.as_mut_ptr() as *mut _,
18648        &ldz,
18649        info,
18650    )
18651}
18652
18653#[inline]
18654pub unsafe fn zgghrd(
18655    compq: u8,
18656    compz: u8,
18657    n: i32,
18658    ilo: i32,
18659    ihi: i32,
18660    a: &mut [c64],
18661    lda: i32,
18662    b: &mut [c64],
18663    ldb: i32,
18664    q: &mut [c64],
18665    ldq: i32,
18666    z: &mut [c64],
18667    ldz: i32,
18668    info: &mut i32,
18669) {
18670    ffi::zgghrd_(
18671        &(compq as c_char),
18672        &(compz as c_char),
18673        &n,
18674        &ilo,
18675        &ihi,
18676        a.as_mut_ptr() as *mut _,
18677        &lda,
18678        b.as_mut_ptr() as *mut _,
18679        &ldb,
18680        q.as_mut_ptr() as *mut _,
18681        &ldq,
18682        z.as_mut_ptr() as *mut _,
18683        &ldz,
18684        info,
18685    )
18686}
18687
18688#[inline]
18689pub unsafe fn sgghd3(
18690    compq: u8,
18691    compz: u8,
18692    n: i32,
18693    ilo: i32,
18694    ihi: i32,
18695    a: &mut [f32],
18696    lda: i32,
18697    b: &mut [f32],
18698    ldb: i32,
18699    q: &mut [f32],
18700    ldq: i32,
18701    z: &mut [f32],
18702    ldz: i32,
18703    work: &mut [f32],
18704    lwork: i32,
18705    info: &mut i32,
18706) {
18707    ffi::sgghd3_(
18708        &(compq as c_char),
18709        &(compz as c_char),
18710        &n,
18711        &ilo,
18712        &ihi,
18713        a.as_mut_ptr(),
18714        &lda,
18715        b.as_mut_ptr(),
18716        &ldb,
18717        q.as_mut_ptr(),
18718        &ldq,
18719        z.as_mut_ptr(),
18720        &ldz,
18721        work.as_mut_ptr(),
18722        &lwork,
18723        info,
18724    )
18725}
18726
18727#[inline]
18728pub unsafe fn dgghd3(
18729    compq: u8,
18730    compz: u8,
18731    n: i32,
18732    ilo: i32,
18733    ihi: i32,
18734    a: &mut [f64],
18735    lda: i32,
18736    b: &mut [f64],
18737    ldb: i32,
18738    q: &mut [f64],
18739    ldq: i32,
18740    z: &mut [f64],
18741    ldz: i32,
18742    work: &mut [f64],
18743    lwork: i32,
18744    info: &mut i32,
18745) {
18746    ffi::dgghd3_(
18747        &(compq as c_char),
18748        &(compz as c_char),
18749        &n,
18750        &ilo,
18751        &ihi,
18752        a.as_mut_ptr(),
18753        &lda,
18754        b.as_mut_ptr(),
18755        &ldb,
18756        q.as_mut_ptr(),
18757        &ldq,
18758        z.as_mut_ptr(),
18759        &ldz,
18760        work.as_mut_ptr(),
18761        &lwork,
18762        info,
18763    )
18764}
18765
18766#[inline]
18767pub unsafe fn cgghd3(
18768    compq: u8,
18769    compz: u8,
18770    n: i32,
18771    ilo: i32,
18772    ihi: i32,
18773    a: &mut [c32],
18774    lda: i32,
18775    b: &mut [c32],
18776    ldb: i32,
18777    q: &mut [c32],
18778    ldq: i32,
18779    z: &mut [c32],
18780    ldz: i32,
18781    work: &mut [c32],
18782    lwork: i32,
18783    info: &mut i32,
18784) {
18785    ffi::cgghd3_(
18786        &(compq as c_char),
18787        &(compz as c_char),
18788        &n,
18789        &ilo,
18790        &ihi,
18791        a.as_mut_ptr() as *mut _,
18792        &lda,
18793        b.as_mut_ptr() as *mut _,
18794        &ldb,
18795        q.as_mut_ptr() as *mut _,
18796        &ldq,
18797        z.as_mut_ptr() as *mut _,
18798        &ldz,
18799        work.as_mut_ptr() as *mut _,
18800        &lwork,
18801        info,
18802    )
18803}
18804
18805#[inline]
18806pub unsafe fn zgghd3(
18807    compq: u8,
18808    compz: u8,
18809    n: i32,
18810    ilo: i32,
18811    ihi: i32,
18812    a: &mut [c64],
18813    lda: i32,
18814    b: &mut [c64],
18815    ldb: i32,
18816    q: &mut [c64],
18817    ldq: i32,
18818    z: &mut [c64],
18819    ldz: i32,
18820    work: &mut [c64],
18821    lwork: i32,
18822    info: &mut i32,
18823) {
18824    ffi::zgghd3_(
18825        &(compq as c_char),
18826        &(compz as c_char),
18827        &n,
18828        &ilo,
18829        &ihi,
18830        a.as_mut_ptr() as *mut _,
18831        &lda,
18832        b.as_mut_ptr() as *mut _,
18833        &ldb,
18834        q.as_mut_ptr() as *mut _,
18835        &ldq,
18836        z.as_mut_ptr() as *mut _,
18837        &ldz,
18838        work.as_mut_ptr() as *mut _,
18839        &lwork,
18840        info,
18841    )
18842}
18843
18844#[inline]
18845pub unsafe fn sggbal(
18846    job: u8,
18847    n: i32,
18848    a: &mut [f32],
18849    lda: i32,
18850    b: &mut [f32],
18851    ldb: i32,
18852    ilo: &mut i32,
18853    ihi: &mut i32,
18854    lscale: &mut [f32],
18855    rscale: &mut [f32],
18856    work: &mut [f32],
18857    info: &mut i32,
18858) {
18859    ffi::sggbal_(
18860        &(job as c_char),
18861        &n,
18862        a.as_mut_ptr(),
18863        &lda,
18864        b.as_mut_ptr(),
18865        &ldb,
18866        ilo,
18867        ihi,
18868        lscale.as_mut_ptr(),
18869        rscale.as_mut_ptr(),
18870        work.as_mut_ptr(),
18871        info,
18872    )
18873}
18874
18875#[inline]
18876pub unsafe fn dggbal(
18877    job: u8,
18878    n: i32,
18879    a: &mut [f64],
18880    lda: i32,
18881    b: &mut [f64],
18882    ldb: i32,
18883    ilo: &mut i32,
18884    ihi: &mut i32,
18885    lscale: &mut [f64],
18886    rscale: &mut [f64],
18887    work: &mut [f64],
18888    info: &mut i32,
18889) {
18890    ffi::dggbal_(
18891        &(job as c_char),
18892        &n,
18893        a.as_mut_ptr(),
18894        &lda,
18895        b.as_mut_ptr(),
18896        &ldb,
18897        ilo,
18898        ihi,
18899        lscale.as_mut_ptr(),
18900        rscale.as_mut_ptr(),
18901        work.as_mut_ptr(),
18902        info,
18903    )
18904}
18905
18906#[inline]
18907pub unsafe fn cggbal(
18908    job: u8,
18909    n: i32,
18910    a: &mut [c32],
18911    lda: i32,
18912    b: &mut [c32],
18913    ldb: i32,
18914    ilo: &mut i32,
18915    ihi: &mut i32,
18916    lscale: &mut [f32],
18917    rscale: &mut [f32],
18918    work: &mut [f32],
18919    info: &mut i32,
18920) {
18921    ffi::cggbal_(
18922        &(job as c_char),
18923        &n,
18924        a.as_mut_ptr() as *mut _,
18925        &lda,
18926        b.as_mut_ptr() as *mut _,
18927        &ldb,
18928        ilo,
18929        ihi,
18930        lscale.as_mut_ptr(),
18931        rscale.as_mut_ptr(),
18932        work.as_mut_ptr(),
18933        info,
18934    )
18935}
18936
18937#[inline]
18938pub unsafe fn zggbal(
18939    job: u8,
18940    n: i32,
18941    a: &mut [c64],
18942    lda: i32,
18943    b: &mut [c64],
18944    ldb: i32,
18945    ilo: &mut i32,
18946    ihi: &mut i32,
18947    lscale: &mut [f64],
18948    rscale: &mut [f64],
18949    work: &mut [f64],
18950    info: &mut i32,
18951) {
18952    ffi::zggbal_(
18953        &(job as c_char),
18954        &n,
18955        a.as_mut_ptr() as *mut _,
18956        &lda,
18957        b.as_mut_ptr() as *mut _,
18958        &ldb,
18959        ilo,
18960        ihi,
18961        lscale.as_mut_ptr(),
18962        rscale.as_mut_ptr(),
18963        work.as_mut_ptr(),
18964        info,
18965    )
18966}
18967
18968#[inline]
18969pub unsafe fn sggbak(
18970    job: u8,
18971    side: u8,
18972    n: i32,
18973    ilo: i32,
18974    ihi: i32,
18975    lscale: &[f32],
18976    rscale: &[f32],
18977    m: i32,
18978    v: &mut [f32],
18979    ldv: i32,
18980    info: &mut i32,
18981) {
18982    ffi::sggbak_(
18983        &(job as c_char),
18984        &(side as c_char),
18985        &n,
18986        &ilo,
18987        &ihi,
18988        lscale.as_ptr(),
18989        rscale.as_ptr(),
18990        &m,
18991        v.as_mut_ptr(),
18992        &ldv,
18993        info,
18994    )
18995}
18996
18997#[inline]
18998pub unsafe fn dggbak(
18999    job: u8,
19000    side: u8,
19001    n: i32,
19002    ilo: i32,
19003    ihi: i32,
19004    lscale: &[f64],
19005    rscale: &[f64],
19006    m: i32,
19007    v: &mut [f64],
19008    ldv: i32,
19009    info: &mut i32,
19010) {
19011    ffi::dggbak_(
19012        &(job as c_char),
19013        &(side as c_char),
19014        &n,
19015        &ilo,
19016        &ihi,
19017        lscale.as_ptr(),
19018        rscale.as_ptr(),
19019        &m,
19020        v.as_mut_ptr(),
19021        &ldv,
19022        info,
19023    )
19024}
19025
19026#[inline]
19027pub unsafe fn cggbak(
19028    job: u8,
19029    side: u8,
19030    n: i32,
19031    ilo: i32,
19032    ihi: i32,
19033    lscale: &[f32],
19034    rscale: &[f32],
19035    m: i32,
19036    v: &mut [c32],
19037    ldv: i32,
19038    info: &mut i32,
19039) {
19040    ffi::cggbak_(
19041        &(job as c_char),
19042        &(side as c_char),
19043        &n,
19044        &ilo,
19045        &ihi,
19046        lscale.as_ptr(),
19047        rscale.as_ptr(),
19048        &m,
19049        v.as_mut_ptr() as *mut _,
19050        &ldv,
19051        info,
19052    )
19053}
19054
19055#[inline]
19056pub unsafe fn zggbak(
19057    job: u8,
19058    side: u8,
19059    n: i32,
19060    ilo: i32,
19061    ihi: i32,
19062    lscale: &[f64],
19063    rscale: &[f64],
19064    m: i32,
19065    v: &mut [c64],
19066    ldv: i32,
19067    info: &mut i32,
19068) {
19069    ffi::zggbak_(
19070        &(job as c_char),
19071        &(side as c_char),
19072        &n,
19073        &ilo,
19074        &ihi,
19075        lscale.as_ptr(),
19076        rscale.as_ptr(),
19077        &m,
19078        v.as_mut_ptr() as *mut _,
19079        &ldv,
19080        info,
19081    )
19082}
19083
19084#[inline]
19085pub unsafe fn shgeqz(
19086    job: u8,
19087    compq: u8,
19088    compz: u8,
19089    n: i32,
19090    ilo: i32,
19091    ihi: i32,
19092    h: &mut [f32],
19093    ldh: i32,
19094    t: &mut [f32],
19095    ldt: i32,
19096    alphar: &mut f32,
19097    alphai: &mut f32,
19098    beta: &mut f32,
19099    q: &mut [f32],
19100    ldq: i32,
19101    z: &mut [f32],
19102    ldz: i32,
19103    work: &mut [f32],
19104    lwork: i32,
19105    info: &mut i32,
19106) {
19107    ffi::shgeqz_(
19108        &(job as c_char),
19109        &(compq as c_char),
19110        &(compz as c_char),
19111        &n,
19112        &ilo,
19113        &ihi,
19114        h.as_mut_ptr(),
19115        &ldh,
19116        t.as_mut_ptr(),
19117        &ldt,
19118        alphar,
19119        alphai,
19120        beta,
19121        q.as_mut_ptr(),
19122        &ldq,
19123        z.as_mut_ptr(),
19124        &ldz,
19125        work.as_mut_ptr(),
19126        &lwork,
19127        info,
19128    )
19129}
19130
19131#[inline]
19132pub unsafe fn dhgeqz(
19133    job: u8,
19134    compq: u8,
19135    compz: u8,
19136    n: i32,
19137    ilo: i32,
19138    ihi: i32,
19139    h: &mut [f64],
19140    ldh: i32,
19141    t: &mut [f64],
19142    ldt: i32,
19143    alphar: &mut f64,
19144    alphai: &mut f64,
19145    beta: &mut f64,
19146    q: &mut [f64],
19147    ldq: i32,
19148    z: &mut [f64],
19149    ldz: i32,
19150    work: &mut [f64],
19151    lwork: i32,
19152    info: &mut i32,
19153) {
19154    ffi::dhgeqz_(
19155        &(job as c_char),
19156        &(compq as c_char),
19157        &(compz as c_char),
19158        &n,
19159        &ilo,
19160        &ihi,
19161        h.as_mut_ptr(),
19162        &ldh,
19163        t.as_mut_ptr(),
19164        &ldt,
19165        alphar,
19166        alphai,
19167        beta,
19168        q.as_mut_ptr(),
19169        &ldq,
19170        z.as_mut_ptr(),
19171        &ldz,
19172        work.as_mut_ptr(),
19173        &lwork,
19174        info,
19175    )
19176}
19177
19178#[inline]
19179pub unsafe fn chgeqz(
19180    job: u8,
19181    compq: u8,
19182    compz: u8,
19183    n: i32,
19184    ilo: i32,
19185    ihi: i32,
19186    h: &mut [c32],
19187    ldh: i32,
19188    t: &mut [c32],
19189    ldt: i32,
19190    alpha: &mut c32,
19191    beta: &mut c32,
19192    q: &mut [c32],
19193    ldq: i32,
19194    z: &mut [c32],
19195    ldz: i32,
19196    work: &mut [c32],
19197    lwork: i32,
19198    rwork: &mut [f32],
19199    info: &mut i32,
19200) {
19201    ffi::chgeqz_(
19202        &(job as c_char),
19203        &(compq as c_char),
19204        &(compz as c_char),
19205        &n,
19206        &ilo,
19207        &ihi,
19208        h.as_mut_ptr() as *mut _,
19209        &ldh,
19210        t.as_mut_ptr() as *mut _,
19211        &ldt,
19212        alpha as *mut _ as *mut _,
19213        beta as *mut _ as *mut _,
19214        q.as_mut_ptr() as *mut _,
19215        &ldq,
19216        z.as_mut_ptr() as *mut _,
19217        &ldz,
19218        work.as_mut_ptr() as *mut _,
19219        &lwork,
19220        rwork.as_mut_ptr(),
19221        info,
19222    )
19223}
19224
19225#[inline]
19226pub unsafe fn zhgeqz(
19227    job: u8,
19228    compq: u8,
19229    compz: u8,
19230    n: i32,
19231    ilo: i32,
19232    ihi: i32,
19233    h: &mut [c64],
19234    ldh: i32,
19235    t: &mut [c64],
19236    ldt: i32,
19237    alpha: &mut c64,
19238    beta: &mut c64,
19239    q: &mut [c64],
19240    ldq: i32,
19241    z: &mut [c64],
19242    ldz: i32,
19243    work: &mut [c64],
19244    lwork: i32,
19245    rwork: &mut [f64],
19246    info: &mut i32,
19247) {
19248    ffi::zhgeqz_(
19249        &(job as c_char),
19250        &(compq as c_char),
19251        &(compz as c_char),
19252        &n,
19253        &ilo,
19254        &ihi,
19255        h.as_mut_ptr() as *mut _,
19256        &ldh,
19257        t.as_mut_ptr() as *mut _,
19258        &ldt,
19259        alpha as *mut _ as *mut _,
19260        beta as *mut _ as *mut _,
19261        q.as_mut_ptr() as *mut _,
19262        &ldq,
19263        z.as_mut_ptr() as *mut _,
19264        &ldz,
19265        work.as_mut_ptr() as *mut _,
19266        &lwork,
19267        rwork.as_mut_ptr(),
19268        info,
19269    )
19270}
19271
19272#[inline]
19273pub unsafe fn stgevc(
19274    side: u8,
19275    howmny: u8,
19276    select: &[i32],
19277    n: i32,
19278    s: &[f32],
19279    lds: i32,
19280    p: &[f32],
19281    ldp: i32,
19282    vl: &mut f32,
19283    ldvl: i32,
19284    vr: &mut f32,
19285    ldvr: i32,
19286    mm: i32,
19287    m: &mut i32,
19288    work: &mut [f32],
19289    info: &mut i32,
19290) {
19291    ffi::stgevc_(
19292        &(side as c_char),
19293        &(howmny as c_char),
19294        select.as_ptr(),
19295        &n,
19296        s.as_ptr(),
19297        &lds,
19298        p.as_ptr(),
19299        &ldp,
19300        vl,
19301        &ldvl,
19302        vr,
19303        &ldvr,
19304        &mm,
19305        m,
19306        work.as_mut_ptr(),
19307        info,
19308    )
19309}
19310
19311#[inline]
19312pub unsafe fn dtgevc(
19313    side: u8,
19314    howmny: u8,
19315    select: &[i32],
19316    n: i32,
19317    s: &[f64],
19318    lds: i32,
19319    p: &[f64],
19320    ldp: i32,
19321    vl: &mut f64,
19322    ldvl: i32,
19323    vr: &mut f64,
19324    ldvr: i32,
19325    mm: i32,
19326    m: &mut i32,
19327    work: &mut [f64],
19328    info: &mut i32,
19329) {
19330    ffi::dtgevc_(
19331        &(side as c_char),
19332        &(howmny as c_char),
19333        select.as_ptr(),
19334        &n,
19335        s.as_ptr(),
19336        &lds,
19337        p.as_ptr(),
19338        &ldp,
19339        vl,
19340        &ldvl,
19341        vr,
19342        &ldvr,
19343        &mm,
19344        m,
19345        work.as_mut_ptr(),
19346        info,
19347    )
19348}
19349
19350#[inline]
19351pub unsafe fn ctgevc(
19352    side: u8,
19353    howmny: u8,
19354    select: &[i32],
19355    n: i32,
19356    s: &[c32],
19357    lds: i32,
19358    p: &[c32],
19359    ldp: i32,
19360    vl: &mut c32,
19361    ldvl: i32,
19362    vr: &mut c32,
19363    ldvr: i32,
19364    mm: i32,
19365    m: &mut i32,
19366    work: &mut [c32],
19367    rwork: &mut [f32],
19368    info: &mut i32,
19369) {
19370    ffi::ctgevc_(
19371        &(side as c_char),
19372        &(howmny as c_char),
19373        select.as_ptr(),
19374        &n,
19375        s.as_ptr() as *const _,
19376        &lds,
19377        p.as_ptr() as *const _,
19378        &ldp,
19379        vl as *mut _ as *mut _,
19380        &ldvl,
19381        vr as *mut _ as *mut _,
19382        &ldvr,
19383        &mm,
19384        m,
19385        work.as_mut_ptr() as *mut _,
19386        rwork.as_mut_ptr(),
19387        info,
19388    )
19389}
19390
19391#[inline]
19392pub unsafe fn ztgevc(
19393    side: u8,
19394    howmny: u8,
19395    select: &[i32],
19396    n: i32,
19397    s: &[c64],
19398    lds: i32,
19399    p: &[c64],
19400    ldp: i32,
19401    vl: &mut c64,
19402    ldvl: i32,
19403    vr: &mut c64,
19404    ldvr: i32,
19405    mm: i32,
19406    m: &mut i32,
19407    work: &mut [c64],
19408    rwork: &mut [f64],
19409    info: &mut i32,
19410) {
19411    ffi::ztgevc_(
19412        &(side as c_char),
19413        &(howmny as c_char),
19414        select.as_ptr(),
19415        &n,
19416        s.as_ptr() as *const _,
19417        &lds,
19418        p.as_ptr() as *const _,
19419        &ldp,
19420        vl as *mut _ as *mut _,
19421        &ldvl,
19422        vr as *mut _ as *mut _,
19423        &ldvr,
19424        &mm,
19425        m,
19426        work.as_mut_ptr() as *mut _,
19427        rwork.as_mut_ptr(),
19428        info,
19429    )
19430}
19431
19432#[inline]
19433pub unsafe fn stgexc(
19434    wantq: &[i32],
19435    wantz: &[i32],
19436    n: i32,
19437    a: &mut [f32],
19438    lda: i32,
19439    b: &mut [f32],
19440    ldb: i32,
19441    q: &mut [f32],
19442    ldq: i32,
19443    z: &mut [f32],
19444    ldz: i32,
19445    ifst: &mut [i32],
19446    ilst: &mut [i32],
19447    work: &mut [f32],
19448    lwork: i32,
19449    info: &mut i32,
19450) {
19451    ffi::stgexc_(
19452        wantq.as_ptr(),
19453        wantz.as_ptr(),
19454        &n,
19455        a.as_mut_ptr(),
19456        &lda,
19457        b.as_mut_ptr(),
19458        &ldb,
19459        q.as_mut_ptr(),
19460        &ldq,
19461        z.as_mut_ptr(),
19462        &ldz,
19463        ifst.as_mut_ptr(),
19464        ilst.as_mut_ptr(),
19465        work.as_mut_ptr(),
19466        &lwork,
19467        info,
19468    )
19469}
19470
19471#[inline]
19472pub unsafe fn dtgexc(
19473    wantq: &[i32],
19474    wantz: &[i32],
19475    n: i32,
19476    a: &mut [f64],
19477    lda: i32,
19478    b: &mut [f64],
19479    ldb: i32,
19480    q: &mut [f64],
19481    ldq: i32,
19482    z: &mut [f64],
19483    ldz: i32,
19484    ifst: &mut [i32],
19485    ilst: &mut [i32],
19486    work: &mut [f64],
19487    lwork: i32,
19488    info: &mut i32,
19489) {
19490    ffi::dtgexc_(
19491        wantq.as_ptr(),
19492        wantz.as_ptr(),
19493        &n,
19494        a.as_mut_ptr(),
19495        &lda,
19496        b.as_mut_ptr(),
19497        &ldb,
19498        q.as_mut_ptr(),
19499        &ldq,
19500        z.as_mut_ptr(),
19501        &ldz,
19502        ifst.as_mut_ptr(),
19503        ilst.as_mut_ptr(),
19504        work.as_mut_ptr(),
19505        &lwork,
19506        info,
19507    )
19508}
19509
19510#[inline]
19511pub unsafe fn ctgexc(
19512    wantq: &[i32],
19513    wantz: &[i32],
19514    n: i32,
19515    a: &mut [c32],
19516    lda: i32,
19517    b: &mut [c32],
19518    ldb: i32,
19519    q: &mut [c32],
19520    ldq: i32,
19521    z: &mut [c32],
19522    ldz: i32,
19523    ifst: &[i32],
19524    ilst: &mut [i32],
19525    info: &mut i32,
19526) {
19527    ffi::ctgexc_(
19528        wantq.as_ptr(),
19529        wantz.as_ptr(),
19530        &n,
19531        a.as_mut_ptr() as *mut _,
19532        &lda,
19533        b.as_mut_ptr() as *mut _,
19534        &ldb,
19535        q.as_mut_ptr() as *mut _,
19536        &ldq,
19537        z.as_mut_ptr() as *mut _,
19538        &ldz,
19539        ifst.as_ptr(),
19540        ilst.as_mut_ptr(),
19541        info,
19542    )
19543}
19544
19545#[inline]
19546pub unsafe fn ztgexc(
19547    wantq: &[i32],
19548    wantz: &[i32],
19549    n: i32,
19550    a: &mut [c64],
19551    lda: i32,
19552    b: &mut [c64],
19553    ldb: i32,
19554    q: &mut [c64],
19555    ldq: i32,
19556    z: &mut [c64],
19557    ldz: i32,
19558    ifst: &[i32],
19559    ilst: &mut [i32],
19560    info: &mut i32,
19561) {
19562    ffi::ztgexc_(
19563        wantq.as_ptr(),
19564        wantz.as_ptr(),
19565        &n,
19566        a.as_mut_ptr() as *mut _,
19567        &lda,
19568        b.as_mut_ptr() as *mut _,
19569        &ldb,
19570        q.as_mut_ptr() as *mut _,
19571        &ldq,
19572        z.as_mut_ptr() as *mut _,
19573        &ldz,
19574        ifst.as_ptr(),
19575        ilst.as_mut_ptr(),
19576        info,
19577    )
19578}
19579
19580#[inline]
19581pub unsafe fn stgsen(
19582    ijob: &[i32],
19583    wantq: &[i32],
19584    wantz: &[i32],
19585    select: &[i32],
19586    n: i32,
19587    a: &mut [f32],
19588    lda: i32,
19589    b: &mut [f32],
19590    ldb: i32,
19591    alphar: &mut f32,
19592    alphai: &mut f32,
19593    beta: &mut f32,
19594    q: &mut [f32],
19595    ldq: i32,
19596    z: &mut [f32],
19597    ldz: i32,
19598    m: &mut i32,
19599    pl: &mut [f32],
19600    pr: &mut [f32],
19601    dif: &mut f32,
19602    work: &mut [f32],
19603    lwork: i32,
19604    iwork: &mut [i32],
19605    liwork: i32,
19606    info: &mut i32,
19607) {
19608    ffi::stgsen_(
19609        ijob.as_ptr(),
19610        wantq.as_ptr(),
19611        wantz.as_ptr(),
19612        select.as_ptr(),
19613        &n,
19614        a.as_mut_ptr(),
19615        &lda,
19616        b.as_mut_ptr(),
19617        &ldb,
19618        alphar,
19619        alphai,
19620        beta,
19621        q.as_mut_ptr(),
19622        &ldq,
19623        z.as_mut_ptr(),
19624        &ldz,
19625        m,
19626        pl.as_mut_ptr(),
19627        pr.as_mut_ptr(),
19628        dif,
19629        work.as_mut_ptr(),
19630        &lwork,
19631        iwork.as_mut_ptr(),
19632        &liwork,
19633        info,
19634    )
19635}
19636
19637#[inline]
19638pub unsafe fn dtgsen(
19639    ijob: &[i32],
19640    wantq: &[i32],
19641    wantz: &[i32],
19642    select: &[i32],
19643    n: i32,
19644    a: &mut [f64],
19645    lda: i32,
19646    b: &mut [f64],
19647    ldb: i32,
19648    alphar: &mut f64,
19649    alphai: &mut f64,
19650    beta: &mut f64,
19651    q: &mut [f64],
19652    ldq: i32,
19653    z: &mut [f64],
19654    ldz: i32,
19655    m: &mut i32,
19656    pl: &mut [f64],
19657    pr: &mut [f64],
19658    dif: &mut f64,
19659    work: &mut [f64],
19660    lwork: i32,
19661    iwork: &mut [i32],
19662    liwork: i32,
19663    info: &mut i32,
19664) {
19665    ffi::dtgsen_(
19666        ijob.as_ptr(),
19667        wantq.as_ptr(),
19668        wantz.as_ptr(),
19669        select.as_ptr(),
19670        &n,
19671        a.as_mut_ptr(),
19672        &lda,
19673        b.as_mut_ptr(),
19674        &ldb,
19675        alphar,
19676        alphai,
19677        beta,
19678        q.as_mut_ptr(),
19679        &ldq,
19680        z.as_mut_ptr(),
19681        &ldz,
19682        m,
19683        pl.as_mut_ptr(),
19684        pr.as_mut_ptr(),
19685        dif,
19686        work.as_mut_ptr(),
19687        &lwork,
19688        iwork.as_mut_ptr(),
19689        &liwork,
19690        info,
19691    )
19692}
19693
19694#[inline]
19695pub unsafe fn ctgsen(
19696    ijob: &[i32],
19697    wantq: &[i32],
19698    wantz: &[i32],
19699    select: &[i32],
19700    n: i32,
19701    a: &mut [c32],
19702    lda: i32,
19703    b: &mut [c32],
19704    ldb: i32,
19705    alpha: &mut c32,
19706    beta: &mut c32,
19707    q: &mut [c32],
19708    ldq: i32,
19709    z: &mut [c32],
19710    ldz: i32,
19711    m: &mut i32,
19712    pl: &mut [f32],
19713    pr: &mut [f32],
19714    dif: &mut f32,
19715    work: &mut [c32],
19716    lwork: i32,
19717    iwork: &mut [i32],
19718    liwork: i32,
19719    info: &mut i32,
19720) {
19721    ffi::ctgsen_(
19722        ijob.as_ptr(),
19723        wantq.as_ptr(),
19724        wantz.as_ptr(),
19725        select.as_ptr(),
19726        &n,
19727        a.as_mut_ptr() as *mut _,
19728        &lda,
19729        b.as_mut_ptr() as *mut _,
19730        &ldb,
19731        alpha as *mut _ as *mut _,
19732        beta as *mut _ as *mut _,
19733        q.as_mut_ptr() as *mut _,
19734        &ldq,
19735        z.as_mut_ptr() as *mut _,
19736        &ldz,
19737        m,
19738        pl.as_mut_ptr(),
19739        pr.as_mut_ptr(),
19740        dif,
19741        work.as_mut_ptr() as *mut _,
19742        &lwork,
19743        iwork.as_mut_ptr(),
19744        &liwork,
19745        info,
19746    )
19747}
19748
19749#[inline]
19750pub unsafe fn ztgsen(
19751    ijob: &[i32],
19752    wantq: &[i32],
19753    wantz: &[i32],
19754    select: &[i32],
19755    n: i32,
19756    a: &mut [c64],
19757    lda: i32,
19758    b: &mut [c64],
19759    ldb: i32,
19760    alpha: &mut c64,
19761    beta: &mut c64,
19762    q: &mut [c64],
19763    ldq: i32,
19764    z: &mut [c64],
19765    ldz: i32,
19766    m: &mut i32,
19767    pl: &mut [f64],
19768    pr: &mut [f64],
19769    dif: &mut f64,
19770    work: &mut [c64],
19771    lwork: i32,
19772    iwork: &mut [i32],
19773    liwork: i32,
19774    info: &mut i32,
19775) {
19776    ffi::ztgsen_(
19777        ijob.as_ptr(),
19778        wantq.as_ptr(),
19779        wantz.as_ptr(),
19780        select.as_ptr(),
19781        &n,
19782        a.as_mut_ptr() as *mut _,
19783        &lda,
19784        b.as_mut_ptr() as *mut _,
19785        &ldb,
19786        alpha as *mut _ as *mut _,
19787        beta as *mut _ as *mut _,
19788        q.as_mut_ptr() as *mut _,
19789        &ldq,
19790        z.as_mut_ptr() as *mut _,
19791        &ldz,
19792        m,
19793        pl.as_mut_ptr(),
19794        pr.as_mut_ptr(),
19795        dif,
19796        work.as_mut_ptr() as *mut _,
19797        &lwork,
19798        iwork.as_mut_ptr(),
19799        &liwork,
19800        info,
19801    )
19802}
19803
19804#[inline]
19805pub unsafe fn stgsyl(
19806    trans: u8,
19807    ijob: &[i32],
19808    m: i32,
19809    n: i32,
19810    a: &[f32],
19811    lda: i32,
19812    b: &[f32],
19813    ldb: i32,
19814    c: &mut [f32],
19815    ldc: i32,
19816    d: &[f32],
19817    ldd: i32,
19818    e: &[f32],
19819    lde: i32,
19820    f: &mut [f32],
19821    ldf: i32,
19822    scale: &mut [f32],
19823    dif: &mut f32,
19824    work: &mut [f32],
19825    lwork: i32,
19826    iwork: &mut [i32],
19827    info: &mut i32,
19828) {
19829    ffi::stgsyl_(
19830        &(trans as c_char),
19831        ijob.as_ptr(),
19832        &m,
19833        &n,
19834        a.as_ptr(),
19835        &lda,
19836        b.as_ptr(),
19837        &ldb,
19838        c.as_mut_ptr(),
19839        &ldc,
19840        d.as_ptr(),
19841        &ldd,
19842        e.as_ptr(),
19843        &lde,
19844        f.as_mut_ptr(),
19845        &ldf,
19846        scale.as_mut_ptr(),
19847        dif,
19848        work.as_mut_ptr(),
19849        &lwork,
19850        iwork.as_mut_ptr(),
19851        info,
19852    )
19853}
19854
19855#[inline]
19856pub unsafe fn dtgsyl(
19857    trans: u8,
19858    ijob: &[i32],
19859    m: i32,
19860    n: i32,
19861    a: &[f64],
19862    lda: i32,
19863    b: &[f64],
19864    ldb: i32,
19865    c: &mut [f64],
19866    ldc: i32,
19867    d: &[f64],
19868    ldd: i32,
19869    e: &[f64],
19870    lde: i32,
19871    f: &mut [f64],
19872    ldf: i32,
19873    scale: &mut [f64],
19874    dif: &mut f64,
19875    work: &mut [f64],
19876    lwork: i32,
19877    iwork: &mut [i32],
19878    info: &mut i32,
19879) {
19880    ffi::dtgsyl_(
19881        &(trans as c_char),
19882        ijob.as_ptr(),
19883        &m,
19884        &n,
19885        a.as_ptr(),
19886        &lda,
19887        b.as_ptr(),
19888        &ldb,
19889        c.as_mut_ptr(),
19890        &ldc,
19891        d.as_ptr(),
19892        &ldd,
19893        e.as_ptr(),
19894        &lde,
19895        f.as_mut_ptr(),
19896        &ldf,
19897        scale.as_mut_ptr(),
19898        dif,
19899        work.as_mut_ptr(),
19900        &lwork,
19901        iwork.as_mut_ptr(),
19902        info,
19903    )
19904}
19905
19906#[inline]
19907pub unsafe fn ctgsyl(
19908    trans: u8,
19909    ijob: &[i32],
19910    m: i32,
19911    n: i32,
19912    a: &[c32],
19913    lda: i32,
19914    b: &[c32],
19915    ldb: i32,
19916    c: &mut [c32],
19917    ldc: i32,
19918    d: &[c32],
19919    ldd: i32,
19920    e: &[c32],
19921    lde: i32,
19922    f: &mut [c32],
19923    ldf: i32,
19924    scale: &mut [f32],
19925    dif: &mut f32,
19926    work: &mut [c32],
19927    lwork: i32,
19928    iwork: &mut [i32],
19929    info: &mut i32,
19930) {
19931    ffi::ctgsyl_(
19932        &(trans as c_char),
19933        ijob.as_ptr(),
19934        &m,
19935        &n,
19936        a.as_ptr() as *const _,
19937        &lda,
19938        b.as_ptr() as *const _,
19939        &ldb,
19940        c.as_mut_ptr() as *mut _,
19941        &ldc,
19942        d.as_ptr() as *const _,
19943        &ldd,
19944        e.as_ptr() as *const _,
19945        &lde,
19946        f.as_mut_ptr() as *mut _,
19947        &ldf,
19948        scale.as_mut_ptr(),
19949        dif,
19950        work.as_mut_ptr() as *mut _,
19951        &lwork,
19952        iwork.as_mut_ptr(),
19953        info,
19954    )
19955}
19956
19957#[inline]
19958pub unsafe fn ztgsyl(
19959    trans: u8,
19960    ijob: &[i32],
19961    m: i32,
19962    n: i32,
19963    a: &[c64],
19964    lda: i32,
19965    b: &[c64],
19966    ldb: i32,
19967    c: &mut [c64],
19968    ldc: i32,
19969    d: &[c64],
19970    ldd: i32,
19971    e: &[c64],
19972    lde: i32,
19973    f: &mut [c64],
19974    ldf: i32,
19975    scale: &mut [f64],
19976    dif: &mut f64,
19977    work: &mut [c64],
19978    lwork: i32,
19979    iwork: &mut [i32],
19980    info: &mut i32,
19981) {
19982    ffi::ztgsyl_(
19983        &(trans as c_char),
19984        ijob.as_ptr(),
19985        &m,
19986        &n,
19987        a.as_ptr() as *const _,
19988        &lda,
19989        b.as_ptr() as *const _,
19990        &ldb,
19991        c.as_mut_ptr() as *mut _,
19992        &ldc,
19993        d.as_ptr() as *const _,
19994        &ldd,
19995        e.as_ptr() as *const _,
19996        &lde,
19997        f.as_mut_ptr() as *mut _,
19998        &ldf,
19999        scale.as_mut_ptr(),
20000        dif,
20001        work.as_mut_ptr() as *mut _,
20002        &lwork,
20003        iwork.as_mut_ptr(),
20004        info,
20005    )
20006}
20007
20008#[inline]
20009pub unsafe fn stgsna(
20010    job: u8,
20011    howmny: u8,
20012    select: &[i32],
20013    n: i32,
20014    a: &[f32],
20015    lda: i32,
20016    b: &[f32],
20017    ldb: i32,
20018    vl: &[f32],
20019    ldvl: i32,
20020    vr: &[f32],
20021    ldvr: i32,
20022    s: &mut [f32],
20023    dif: &mut f32,
20024    mm: i32,
20025    m: &mut i32,
20026    work: &mut [f32],
20027    lwork: i32,
20028    iwork: &mut [i32],
20029    info: &mut i32,
20030) {
20031    ffi::stgsna_(
20032        &(job as c_char),
20033        &(howmny as c_char),
20034        select.as_ptr(),
20035        &n,
20036        a.as_ptr(),
20037        &lda,
20038        b.as_ptr(),
20039        &ldb,
20040        vl.as_ptr(),
20041        &ldvl,
20042        vr.as_ptr(),
20043        &ldvr,
20044        s.as_mut_ptr(),
20045        dif,
20046        &mm,
20047        m,
20048        work.as_mut_ptr(),
20049        &lwork,
20050        iwork.as_mut_ptr(),
20051        info,
20052    )
20053}
20054
20055#[inline]
20056pub unsafe fn dtgsna(
20057    job: u8,
20058    howmny: u8,
20059    select: &[i32],
20060    n: i32,
20061    a: &[f64],
20062    lda: i32,
20063    b: &[f64],
20064    ldb: i32,
20065    vl: &[f64],
20066    ldvl: i32,
20067    vr: &[f64],
20068    ldvr: i32,
20069    s: &mut [f64],
20070    dif: &mut f64,
20071    mm: i32,
20072    m: &mut i32,
20073    work: &mut [f64],
20074    lwork: i32,
20075    iwork: &mut [i32],
20076    info: &mut i32,
20077) {
20078    ffi::dtgsna_(
20079        &(job as c_char),
20080        &(howmny as c_char),
20081        select.as_ptr(),
20082        &n,
20083        a.as_ptr(),
20084        &lda,
20085        b.as_ptr(),
20086        &ldb,
20087        vl.as_ptr(),
20088        &ldvl,
20089        vr.as_ptr(),
20090        &ldvr,
20091        s.as_mut_ptr(),
20092        dif,
20093        &mm,
20094        m,
20095        work.as_mut_ptr(),
20096        &lwork,
20097        iwork.as_mut_ptr(),
20098        info,
20099    )
20100}
20101
20102#[inline]
20103pub unsafe fn ctgsna(
20104    job: u8,
20105    howmny: u8,
20106    select: &[i32],
20107    n: i32,
20108    a: &[c32],
20109    lda: i32,
20110    b: &[c32],
20111    ldb: i32,
20112    vl: &[c32],
20113    ldvl: i32,
20114    vr: &[c32],
20115    ldvr: i32,
20116    s: &mut [f32],
20117    dif: &mut f32,
20118    mm: i32,
20119    m: &mut i32,
20120    work: &mut [c32],
20121    lwork: i32,
20122    iwork: &mut [i32],
20123    info: &mut i32,
20124) {
20125    ffi::ctgsna_(
20126        &(job as c_char),
20127        &(howmny as c_char),
20128        select.as_ptr(),
20129        &n,
20130        a.as_ptr() as *const _,
20131        &lda,
20132        b.as_ptr() as *const _,
20133        &ldb,
20134        vl.as_ptr() as *const _,
20135        &ldvl,
20136        vr.as_ptr() as *const _,
20137        &ldvr,
20138        s.as_mut_ptr(),
20139        dif,
20140        &mm,
20141        m,
20142        work.as_mut_ptr() as *mut _,
20143        &lwork,
20144        iwork.as_mut_ptr(),
20145        info,
20146    )
20147}
20148
20149#[inline]
20150pub unsafe fn ztgsna(
20151    job: u8,
20152    howmny: u8,
20153    select: &[i32],
20154    n: i32,
20155    a: &[c64],
20156    lda: i32,
20157    b: &[c64],
20158    ldb: i32,
20159    vl: &[c64],
20160    ldvl: i32,
20161    vr: &[c64],
20162    ldvr: i32,
20163    s: &mut [f64],
20164    dif: &mut f64,
20165    mm: i32,
20166    m: &mut i32,
20167    work: &mut [c64],
20168    lwork: i32,
20169    iwork: &mut [i32],
20170    info: &mut i32,
20171) {
20172    ffi::ztgsna_(
20173        &(job as c_char),
20174        &(howmny as c_char),
20175        select.as_ptr(),
20176        &n,
20177        a.as_ptr() as *const _,
20178        &lda,
20179        b.as_ptr() as *const _,
20180        &ldb,
20181        vl.as_ptr() as *const _,
20182        &ldvl,
20183        vr.as_ptr() as *const _,
20184        &ldvr,
20185        s.as_mut_ptr(),
20186        dif,
20187        &mm,
20188        m,
20189        work.as_mut_ptr() as *mut _,
20190        &lwork,
20191        iwork.as_mut_ptr(),
20192        info,
20193    )
20194}
20195
20196#[inline]
20197pub unsafe fn sggsvp(
20198    jobu: u8,
20199    jobv: u8,
20200    jobq: u8,
20201    m: i32,
20202    p: i32,
20203    n: i32,
20204    a: &mut [f32],
20205    lda: i32,
20206    b: &mut [f32],
20207    ldb: i32,
20208    tola: f32,
20209    tolb: f32,
20210    k: &mut i32,
20211    l: &mut i32,
20212    u: &mut [f32],
20213    ldu: i32,
20214    v: &mut [f32],
20215    ldv: i32,
20216    q: &mut [f32],
20217    ldq: i32,
20218    iwork: &mut [i32],
20219    tau: &mut [f32],
20220    work: &mut [f32],
20221    info: &mut i32,
20222) {
20223    ffi::sggsvp_(
20224        &(jobu as c_char),
20225        &(jobv as c_char),
20226        &(jobq as c_char),
20227        &m,
20228        &p,
20229        &n,
20230        a.as_mut_ptr(),
20231        &lda,
20232        b.as_mut_ptr(),
20233        &ldb,
20234        &tola,
20235        &tolb,
20236        k,
20237        l,
20238        u.as_mut_ptr(),
20239        &ldu,
20240        v.as_mut_ptr(),
20241        &ldv,
20242        q.as_mut_ptr(),
20243        &ldq,
20244        iwork.as_mut_ptr(),
20245        tau.as_mut_ptr(),
20246        work.as_mut_ptr(),
20247        info,
20248    )
20249}
20250
20251#[inline]
20252pub unsafe fn dggsvp(
20253    jobu: u8,
20254    jobv: u8,
20255    jobq: u8,
20256    m: i32,
20257    p: i32,
20258    n: i32,
20259    a: &mut [f64],
20260    lda: i32,
20261    b: &mut [f64],
20262    ldb: i32,
20263    tola: f64,
20264    tolb: f64,
20265    k: &mut i32,
20266    l: &mut i32,
20267    u: &mut [f64],
20268    ldu: i32,
20269    v: &mut [f64],
20270    ldv: i32,
20271    q: &mut [f64],
20272    ldq: i32,
20273    iwork: &mut [i32],
20274    tau: &mut [f64],
20275    work: &mut [f64],
20276    info: &mut i32,
20277) {
20278    ffi::dggsvp_(
20279        &(jobu as c_char),
20280        &(jobv as c_char),
20281        &(jobq as c_char),
20282        &m,
20283        &p,
20284        &n,
20285        a.as_mut_ptr(),
20286        &lda,
20287        b.as_mut_ptr(),
20288        &ldb,
20289        &tola,
20290        &tolb,
20291        k,
20292        l,
20293        u.as_mut_ptr(),
20294        &ldu,
20295        v.as_mut_ptr(),
20296        &ldv,
20297        q.as_mut_ptr(),
20298        &ldq,
20299        iwork.as_mut_ptr(),
20300        tau.as_mut_ptr(),
20301        work.as_mut_ptr(),
20302        info,
20303    )
20304}
20305
20306#[inline]
20307pub unsafe fn cggsvp(
20308    jobu: u8,
20309    jobv: u8,
20310    jobq: u8,
20311    m: i32,
20312    p: i32,
20313    n: i32,
20314    a: &mut [c32],
20315    lda: i32,
20316    b: &mut [c32],
20317    ldb: i32,
20318    tola: f32,
20319    tolb: f32,
20320    k: &mut i32,
20321    l: &mut i32,
20322    u: &mut [c32],
20323    ldu: i32,
20324    v: &mut [c32],
20325    ldv: i32,
20326    q: &mut [c32],
20327    ldq: i32,
20328    iwork: &mut [i32],
20329    rwork: &mut [f32],
20330    tau: &mut [c32],
20331    work: &mut [c32],
20332    info: &mut i32,
20333) {
20334    ffi::cggsvp_(
20335        &(jobu as c_char),
20336        &(jobv as c_char),
20337        &(jobq as c_char),
20338        &m,
20339        &p,
20340        &n,
20341        a.as_mut_ptr() as *mut _,
20342        &lda,
20343        b.as_mut_ptr() as *mut _,
20344        &ldb,
20345        &tola,
20346        &tolb,
20347        k,
20348        l,
20349        u.as_mut_ptr() as *mut _,
20350        &ldu,
20351        v.as_mut_ptr() as *mut _,
20352        &ldv,
20353        q.as_mut_ptr() as *mut _,
20354        &ldq,
20355        iwork.as_mut_ptr(),
20356        rwork.as_mut_ptr(),
20357        tau.as_mut_ptr() as *mut _,
20358        work.as_mut_ptr() as *mut _,
20359        info,
20360    )
20361}
20362
20363#[inline]
20364pub unsafe fn zggsvp(
20365    jobu: u8,
20366    jobv: u8,
20367    jobq: u8,
20368    m: i32,
20369    p: i32,
20370    n: i32,
20371    a: &mut [c64],
20372    lda: i32,
20373    b: &mut [c64],
20374    ldb: i32,
20375    tola: f64,
20376    tolb: f64,
20377    k: &mut i32,
20378    l: &mut i32,
20379    u: &mut [c64],
20380    ldu: i32,
20381    v: &mut [c64],
20382    ldv: i32,
20383    q: &mut [c64],
20384    ldq: i32,
20385    iwork: &mut [i32],
20386    rwork: &mut [f64],
20387    tau: &mut [c64],
20388    work: &mut [c64],
20389    info: &mut i32,
20390) {
20391    ffi::zggsvp_(
20392        &(jobu as c_char),
20393        &(jobv as c_char),
20394        &(jobq as c_char),
20395        &m,
20396        &p,
20397        &n,
20398        a.as_mut_ptr() as *mut _,
20399        &lda,
20400        b.as_mut_ptr() as *mut _,
20401        &ldb,
20402        &tola,
20403        &tolb,
20404        k,
20405        l,
20406        u.as_mut_ptr() as *mut _,
20407        &ldu,
20408        v.as_mut_ptr() as *mut _,
20409        &ldv,
20410        q.as_mut_ptr() as *mut _,
20411        &ldq,
20412        iwork.as_mut_ptr(),
20413        rwork.as_mut_ptr(),
20414        tau.as_mut_ptr() as *mut _,
20415        work.as_mut_ptr() as *mut _,
20416        info,
20417    )
20418}
20419
20420#[inline]
20421pub unsafe fn sggsvp3(
20422    jobu: u8,
20423    jobv: u8,
20424    jobq: u8,
20425    m: i32,
20426    p: i32,
20427    n: i32,
20428    a: &mut [f32],
20429    lda: i32,
20430    b: &mut [f32],
20431    ldb: i32,
20432    tola: f32,
20433    tolb: f32,
20434    k: &mut i32,
20435    l: &mut i32,
20436    u: &mut [f32],
20437    ldu: i32,
20438    v: &mut [f32],
20439    ldv: i32,
20440    q: &mut [f32],
20441    ldq: i32,
20442    iwork: &mut [i32],
20443    tau: &mut [f32],
20444    work: &mut [f32],
20445    lwork: i32,
20446    info: &mut i32,
20447) {
20448    ffi::sggsvp3_(
20449        &(jobu as c_char),
20450        &(jobv as c_char),
20451        &(jobq as c_char),
20452        &m,
20453        &p,
20454        &n,
20455        a.as_mut_ptr(),
20456        &lda,
20457        b.as_mut_ptr(),
20458        &ldb,
20459        &tola,
20460        &tolb,
20461        k,
20462        l,
20463        u.as_mut_ptr(),
20464        &ldu,
20465        v.as_mut_ptr(),
20466        &ldv,
20467        q.as_mut_ptr(),
20468        &ldq,
20469        iwork.as_mut_ptr(),
20470        tau.as_mut_ptr(),
20471        work.as_mut_ptr(),
20472        &lwork,
20473        info,
20474    )
20475}
20476
20477#[inline]
20478pub unsafe fn dggsvp3(
20479    jobu: u8,
20480    jobv: u8,
20481    jobq: u8,
20482    m: i32,
20483    p: i32,
20484    n: i32,
20485    a: &mut [f64],
20486    lda: i32,
20487    b: &mut [f64],
20488    ldb: i32,
20489    tola: f64,
20490    tolb: f64,
20491    k: &mut i32,
20492    l: &mut i32,
20493    u: &mut [f64],
20494    ldu: i32,
20495    v: &mut [f64],
20496    ldv: i32,
20497    q: &mut [f64],
20498    ldq: i32,
20499    iwork: &mut [i32],
20500    tau: &mut [f64],
20501    work: &mut [f64],
20502    lwork: i32,
20503    info: &mut i32,
20504) {
20505    ffi::dggsvp3_(
20506        &(jobu as c_char),
20507        &(jobv as c_char),
20508        &(jobq as c_char),
20509        &m,
20510        &p,
20511        &n,
20512        a.as_mut_ptr(),
20513        &lda,
20514        b.as_mut_ptr(),
20515        &ldb,
20516        &tola,
20517        &tolb,
20518        k,
20519        l,
20520        u.as_mut_ptr(),
20521        &ldu,
20522        v.as_mut_ptr(),
20523        &ldv,
20524        q.as_mut_ptr(),
20525        &ldq,
20526        iwork.as_mut_ptr(),
20527        tau.as_mut_ptr(),
20528        work.as_mut_ptr(),
20529        &lwork,
20530        info,
20531    )
20532}
20533
20534#[inline]
20535pub unsafe fn cggsvp3(
20536    jobu: u8,
20537    jobv: u8,
20538    jobq: u8,
20539    m: i32,
20540    p: i32,
20541    n: i32,
20542    a: &mut [c32],
20543    lda: i32,
20544    b: &mut [c32],
20545    ldb: i32,
20546    tola: f32,
20547    tolb: f32,
20548    k: &mut i32,
20549    l: &mut i32,
20550    u: &mut [c32],
20551    ldu: i32,
20552    v: &mut [c32],
20553    ldv: i32,
20554    q: &mut [c32],
20555    ldq: i32,
20556    iwork: &mut [i32],
20557    rwork: &mut [f32],
20558    tau: &mut [c32],
20559    work: &mut [c32],
20560    lwork: i32,
20561    info: &mut i32,
20562) {
20563    ffi::cggsvp3_(
20564        &(jobu as c_char),
20565        &(jobv as c_char),
20566        &(jobq as c_char),
20567        &m,
20568        &p,
20569        &n,
20570        a.as_mut_ptr() as *mut _,
20571        &lda,
20572        b.as_mut_ptr() as *mut _,
20573        &ldb,
20574        &tola,
20575        &tolb,
20576        k,
20577        l,
20578        u.as_mut_ptr() as *mut _,
20579        &ldu,
20580        v.as_mut_ptr() as *mut _,
20581        &ldv,
20582        q.as_mut_ptr() as *mut _,
20583        &ldq,
20584        iwork.as_mut_ptr(),
20585        rwork.as_mut_ptr(),
20586        tau.as_mut_ptr() as *mut _,
20587        work.as_mut_ptr() as *mut _,
20588        &lwork,
20589        info,
20590    )
20591}
20592
20593#[inline]
20594pub unsafe fn zggsvp3(
20595    jobu: u8,
20596    jobv: u8,
20597    jobq: u8,
20598    m: i32,
20599    p: i32,
20600    n: i32,
20601    a: &mut [c64],
20602    lda: i32,
20603    b: &mut [c64],
20604    ldb: i32,
20605    tola: f64,
20606    tolb: f64,
20607    k: &mut i32,
20608    l: &mut i32,
20609    u: &mut [c64],
20610    ldu: i32,
20611    v: &mut [c64],
20612    ldv: i32,
20613    q: &mut [c64],
20614    ldq: i32,
20615    iwork: &mut [i32],
20616    rwork: &mut [f64],
20617    tau: &mut [c64],
20618    work: &mut [c64],
20619    lwork: i32,
20620    info: &mut i32,
20621) {
20622    ffi::zggsvp3_(
20623        &(jobu as c_char),
20624        &(jobv as c_char),
20625        &(jobq as c_char),
20626        &m,
20627        &p,
20628        &n,
20629        a.as_mut_ptr() as *mut _,
20630        &lda,
20631        b.as_mut_ptr() as *mut _,
20632        &ldb,
20633        &tola,
20634        &tolb,
20635        k,
20636        l,
20637        u.as_mut_ptr() as *mut _,
20638        &ldu,
20639        v.as_mut_ptr() as *mut _,
20640        &ldv,
20641        q.as_mut_ptr() as *mut _,
20642        &ldq,
20643        iwork.as_mut_ptr(),
20644        rwork.as_mut_ptr(),
20645        tau.as_mut_ptr() as *mut _,
20646        work.as_mut_ptr() as *mut _,
20647        &lwork,
20648        info,
20649    )
20650}
20651
20652#[inline]
20653pub unsafe fn stgsja(
20654    jobu: u8,
20655    jobv: u8,
20656    jobq: u8,
20657    m: i32,
20658    p: i32,
20659    n: i32,
20660    k: i32,
20661    l: i32,
20662    a: &mut [f32],
20663    lda: i32,
20664    b: &mut [f32],
20665    ldb: i32,
20666    tola: f32,
20667    tolb: f32,
20668    alpha: &mut f32,
20669    beta: &mut f32,
20670    u: &mut [f32],
20671    ldu: i32,
20672    v: &mut [f32],
20673    ldv: i32,
20674    q: &mut [f32],
20675    ldq: i32,
20676    work: &mut [f32],
20677    ncycle: &mut [i32],
20678    info: &mut i32,
20679) {
20680    ffi::stgsja_(
20681        &(jobu as c_char),
20682        &(jobv as c_char),
20683        &(jobq as c_char),
20684        &m,
20685        &p,
20686        &n,
20687        &k,
20688        &l,
20689        a.as_mut_ptr(),
20690        &lda,
20691        b.as_mut_ptr(),
20692        &ldb,
20693        &tola,
20694        &tolb,
20695        alpha,
20696        beta,
20697        u.as_mut_ptr(),
20698        &ldu,
20699        v.as_mut_ptr(),
20700        &ldv,
20701        q.as_mut_ptr(),
20702        &ldq,
20703        work.as_mut_ptr(),
20704        ncycle.as_mut_ptr(),
20705        info,
20706    )
20707}
20708
20709#[inline]
20710pub unsafe fn dtgsja(
20711    jobu: u8,
20712    jobv: u8,
20713    jobq: u8,
20714    m: i32,
20715    p: i32,
20716    n: i32,
20717    k: i32,
20718    l: i32,
20719    a: &mut [f64],
20720    lda: i32,
20721    b: &mut [f64],
20722    ldb: i32,
20723    tola: f64,
20724    tolb: f64,
20725    alpha: &mut f64,
20726    beta: &mut f64,
20727    u: &mut [f64],
20728    ldu: i32,
20729    v: &mut [f64],
20730    ldv: i32,
20731    q: &mut [f64],
20732    ldq: i32,
20733    work: &mut [f64],
20734    ncycle: &mut [i32],
20735    info: &mut i32,
20736) {
20737    ffi::dtgsja_(
20738        &(jobu as c_char),
20739        &(jobv as c_char),
20740        &(jobq as c_char),
20741        &m,
20742        &p,
20743        &n,
20744        &k,
20745        &l,
20746        a.as_mut_ptr(),
20747        &lda,
20748        b.as_mut_ptr(),
20749        &ldb,
20750        &tola,
20751        &tolb,
20752        alpha,
20753        beta,
20754        u.as_mut_ptr(),
20755        &ldu,
20756        v.as_mut_ptr(),
20757        &ldv,
20758        q.as_mut_ptr(),
20759        &ldq,
20760        work.as_mut_ptr(),
20761        ncycle.as_mut_ptr(),
20762        info,
20763    )
20764}
20765
20766#[inline]
20767pub unsafe fn ctgsja(
20768    jobu: u8,
20769    jobv: u8,
20770    jobq: u8,
20771    m: i32,
20772    p: i32,
20773    n: i32,
20774    k: i32,
20775    l: i32,
20776    a: &mut [c32],
20777    lda: i32,
20778    b: &mut [c32],
20779    ldb: i32,
20780    tola: f32,
20781    tolb: f32,
20782    alpha: &mut f32,
20783    beta: &mut f32,
20784    u: &mut [c32],
20785    ldu: i32,
20786    v: &mut [c32],
20787    ldv: i32,
20788    q: &mut [c32],
20789    ldq: i32,
20790    work: &mut [c32],
20791    ncycle: &mut [i32],
20792    info: &mut i32,
20793) {
20794    ffi::ctgsja_(
20795        &(jobu as c_char),
20796        &(jobv as c_char),
20797        &(jobq as c_char),
20798        &m,
20799        &p,
20800        &n,
20801        &k,
20802        &l,
20803        a.as_mut_ptr() as *mut _,
20804        &lda,
20805        b.as_mut_ptr() as *mut _,
20806        &ldb,
20807        &tola,
20808        &tolb,
20809        alpha,
20810        beta,
20811        u.as_mut_ptr() as *mut _,
20812        &ldu,
20813        v.as_mut_ptr() as *mut _,
20814        &ldv,
20815        q.as_mut_ptr() as *mut _,
20816        &ldq,
20817        work.as_mut_ptr() as *mut _,
20818        ncycle.as_mut_ptr(),
20819        info,
20820    )
20821}
20822
20823#[inline]
20824pub unsafe fn ztgsja(
20825    jobu: u8,
20826    jobv: u8,
20827    jobq: u8,
20828    m: i32,
20829    p: i32,
20830    n: i32,
20831    k: i32,
20832    l: i32,
20833    a: &mut [c64],
20834    lda: i32,
20835    b: &mut [c64],
20836    ldb: i32,
20837    tola: f64,
20838    tolb: f64,
20839    alpha: &mut f64,
20840    beta: &mut f64,
20841    u: &mut [c64],
20842    ldu: i32,
20843    v: &mut [c64],
20844    ldv: i32,
20845    q: &mut [c64],
20846    ldq: i32,
20847    work: &mut [c64],
20848    ncycle: &mut [i32],
20849    info: &mut i32,
20850) {
20851    ffi::ztgsja_(
20852        &(jobu as c_char),
20853        &(jobv as c_char),
20854        &(jobq as c_char),
20855        &m,
20856        &p,
20857        &n,
20858        &k,
20859        &l,
20860        a.as_mut_ptr() as *mut _,
20861        &lda,
20862        b.as_mut_ptr() as *mut _,
20863        &ldb,
20864        &tola,
20865        &tolb,
20866        alpha,
20867        beta,
20868        u.as_mut_ptr() as *mut _,
20869        &ldu,
20870        v.as_mut_ptr() as *mut _,
20871        &ldv,
20872        q.as_mut_ptr() as *mut _,
20873        &ldq,
20874        work.as_mut_ptr() as *mut _,
20875        ncycle.as_mut_ptr(),
20876        info,
20877    )
20878}
20879
20880#[inline]
20881pub unsafe fn sgels(
20882    trans: u8,
20883    m: i32,
20884    n: i32,
20885    nrhs: i32,
20886    a: &mut [f32],
20887    lda: i32,
20888    b: &mut [f32],
20889    ldb: i32,
20890    work: &mut [f32],
20891    lwork: i32,
20892    info: &mut i32,
20893) {
20894    ffi::sgels_(
20895        &(trans as c_char),
20896        &m,
20897        &n,
20898        &nrhs,
20899        a.as_mut_ptr(),
20900        &lda,
20901        b.as_mut_ptr(),
20902        &ldb,
20903        work.as_mut_ptr(),
20904        &lwork,
20905        info,
20906    )
20907}
20908
20909#[inline]
20910pub unsafe fn dgels(
20911    trans: u8,
20912    m: i32,
20913    n: i32,
20914    nrhs: i32,
20915    a: &mut [f64],
20916    lda: i32,
20917    b: &mut [f64],
20918    ldb: i32,
20919    work: &mut [f64],
20920    lwork: i32,
20921    info: &mut i32,
20922) {
20923    ffi::dgels_(
20924        &(trans as c_char),
20925        &m,
20926        &n,
20927        &nrhs,
20928        a.as_mut_ptr(),
20929        &lda,
20930        b.as_mut_ptr(),
20931        &ldb,
20932        work.as_mut_ptr(),
20933        &lwork,
20934        info,
20935    )
20936}
20937
20938#[inline]
20939pub unsafe fn cgels(
20940    trans: u8,
20941    m: i32,
20942    n: i32,
20943    nrhs: i32,
20944    a: &mut [c32],
20945    lda: i32,
20946    b: &mut [c32],
20947    ldb: i32,
20948    work: &mut [c32],
20949    lwork: i32,
20950    info: &mut i32,
20951) {
20952    ffi::cgels_(
20953        &(trans as c_char),
20954        &m,
20955        &n,
20956        &nrhs,
20957        a.as_mut_ptr() as *mut _,
20958        &lda,
20959        b.as_mut_ptr() as *mut _,
20960        &ldb,
20961        work.as_mut_ptr() as *mut _,
20962        &lwork,
20963        info,
20964    )
20965}
20966
20967#[inline]
20968pub unsafe fn zgels(
20969    trans: u8,
20970    m: i32,
20971    n: i32,
20972    nrhs: i32,
20973    a: &mut [c64],
20974    lda: i32,
20975    b: &mut [c64],
20976    ldb: i32,
20977    work: &mut [c64],
20978    lwork: i32,
20979    info: &mut i32,
20980) {
20981    ffi::zgels_(
20982        &(trans as c_char),
20983        &m,
20984        &n,
20985        &nrhs,
20986        a.as_mut_ptr() as *mut _,
20987        &lda,
20988        b.as_mut_ptr() as *mut _,
20989        &ldb,
20990        work.as_mut_ptr() as *mut _,
20991        &lwork,
20992        info,
20993    )
20994}
20995
20996#[inline]
20997pub unsafe fn sgelsy(
20998    m: i32,
20999    n: i32,
21000    nrhs: i32,
21001    a: &mut [f32],
21002    lda: i32,
21003    b: &mut [f32],
21004    ldb: i32,
21005    jpvt: &mut [i32],
21006    rcond: f32,
21007    rank: &mut i32,
21008    work: &mut [f32],
21009    lwork: i32,
21010    info: &mut i32,
21011) {
21012    ffi::sgelsy_(
21013        &m,
21014        &n,
21015        &nrhs,
21016        a.as_mut_ptr(),
21017        &lda,
21018        b.as_mut_ptr(),
21019        &ldb,
21020        jpvt.as_mut_ptr(),
21021        &rcond,
21022        rank,
21023        work.as_mut_ptr(),
21024        &lwork,
21025        info,
21026    )
21027}
21028
21029#[inline]
21030pub unsafe fn dgelsy(
21031    m: i32,
21032    n: i32,
21033    nrhs: i32,
21034    a: &mut [f64],
21035    lda: i32,
21036    b: &mut [f64],
21037    ldb: i32,
21038    jpvt: &mut [i32],
21039    rcond: f64,
21040    rank: &mut i32,
21041    work: &mut [f64],
21042    lwork: i32,
21043    info: &mut i32,
21044) {
21045    ffi::dgelsy_(
21046        &m,
21047        &n,
21048        &nrhs,
21049        a.as_mut_ptr(),
21050        &lda,
21051        b.as_mut_ptr(),
21052        &ldb,
21053        jpvt.as_mut_ptr(),
21054        &rcond,
21055        rank,
21056        work.as_mut_ptr(),
21057        &lwork,
21058        info,
21059    )
21060}
21061
21062#[inline]
21063pub unsafe fn cgelsy(
21064    m: i32,
21065    n: i32,
21066    nrhs: i32,
21067    a: &mut [c32],
21068    lda: i32,
21069    b: &mut [c32],
21070    ldb: i32,
21071    jpvt: &mut [i32],
21072    rcond: f32,
21073    rank: &mut i32,
21074    work: &mut [c32],
21075    lwork: i32,
21076    rwork: &mut [f32],
21077    info: &mut i32,
21078) {
21079    ffi::cgelsy_(
21080        &m,
21081        &n,
21082        &nrhs,
21083        a.as_mut_ptr() as *mut _,
21084        &lda,
21085        b.as_mut_ptr() as *mut _,
21086        &ldb,
21087        jpvt.as_mut_ptr(),
21088        &rcond,
21089        rank,
21090        work.as_mut_ptr() as *mut _,
21091        &lwork,
21092        rwork.as_mut_ptr(),
21093        info,
21094    )
21095}
21096
21097#[inline]
21098pub unsafe fn zgelsy(
21099    m: i32,
21100    n: i32,
21101    nrhs: i32,
21102    a: &mut [c64],
21103    lda: i32,
21104    b: &mut [c64],
21105    ldb: i32,
21106    jpvt: &mut [i32],
21107    rcond: f64,
21108    rank: &mut i32,
21109    work: &mut [c64],
21110    lwork: i32,
21111    rwork: &mut [f64],
21112    info: &mut i32,
21113) {
21114    ffi::zgelsy_(
21115        &m,
21116        &n,
21117        &nrhs,
21118        a.as_mut_ptr() as *mut _,
21119        &lda,
21120        b.as_mut_ptr() as *mut _,
21121        &ldb,
21122        jpvt.as_mut_ptr(),
21123        &rcond,
21124        rank,
21125        work.as_mut_ptr() as *mut _,
21126        &lwork,
21127        rwork.as_mut_ptr(),
21128        info,
21129    )
21130}
21131
21132#[inline]
21133pub unsafe fn sgelss(
21134    m: i32,
21135    n: i32,
21136    nrhs: i32,
21137    a: &mut [f32],
21138    lda: i32,
21139    b: &mut [f32],
21140    ldb: i32,
21141    s: &mut [f32],
21142    rcond: f32,
21143    rank: &mut i32,
21144    work: &mut [f32],
21145    lwork: i32,
21146    info: &mut i32,
21147) {
21148    ffi::sgelss_(
21149        &m,
21150        &n,
21151        &nrhs,
21152        a.as_mut_ptr(),
21153        &lda,
21154        b.as_mut_ptr(),
21155        &ldb,
21156        s.as_mut_ptr(),
21157        &rcond,
21158        rank,
21159        work.as_mut_ptr(),
21160        &lwork,
21161        info,
21162    )
21163}
21164
21165#[inline]
21166pub unsafe fn dgelss(
21167    m: i32,
21168    n: i32,
21169    nrhs: i32,
21170    a: &mut [f64],
21171    lda: i32,
21172    b: &mut [f64],
21173    ldb: i32,
21174    s: &mut [f64],
21175    rcond: f64,
21176    rank: &mut i32,
21177    work: &mut [f64],
21178    lwork: i32,
21179    info: &mut i32,
21180) {
21181    ffi::dgelss_(
21182        &m,
21183        &n,
21184        &nrhs,
21185        a.as_mut_ptr(),
21186        &lda,
21187        b.as_mut_ptr(),
21188        &ldb,
21189        s.as_mut_ptr(),
21190        &rcond,
21191        rank,
21192        work.as_mut_ptr(),
21193        &lwork,
21194        info,
21195    )
21196}
21197
21198#[inline]
21199pub unsafe fn cgelss(
21200    m: i32,
21201    n: i32,
21202    nrhs: i32,
21203    a: &mut [c32],
21204    lda: i32,
21205    b: &mut [c32],
21206    ldb: i32,
21207    s: &mut [f32],
21208    rcond: f32,
21209    rank: &mut i32,
21210    work: &mut [c32],
21211    lwork: i32,
21212    rwork: &mut [f32],
21213    info: &mut i32,
21214) {
21215    ffi::cgelss_(
21216        &m,
21217        &n,
21218        &nrhs,
21219        a.as_mut_ptr() as *mut _,
21220        &lda,
21221        b.as_mut_ptr() as *mut _,
21222        &ldb,
21223        s.as_mut_ptr(),
21224        &rcond,
21225        rank,
21226        work.as_mut_ptr() as *mut _,
21227        &lwork,
21228        rwork.as_mut_ptr(),
21229        info,
21230    )
21231}
21232
21233#[inline]
21234pub unsafe fn zgelss(
21235    m: i32,
21236    n: i32,
21237    nrhs: i32,
21238    a: &mut [c64],
21239    lda: i32,
21240    b: &mut [c64],
21241    ldb: i32,
21242    s: &mut [f64],
21243    rcond: f64,
21244    rank: &mut i32,
21245    work: &mut [c64],
21246    lwork: i32,
21247    rwork: &mut [f64],
21248    info: &mut i32,
21249) {
21250    ffi::zgelss_(
21251        &m,
21252        &n,
21253        &nrhs,
21254        a.as_mut_ptr() as *mut _,
21255        &lda,
21256        b.as_mut_ptr() as *mut _,
21257        &ldb,
21258        s.as_mut_ptr(),
21259        &rcond,
21260        rank,
21261        work.as_mut_ptr() as *mut _,
21262        &lwork,
21263        rwork.as_mut_ptr(),
21264        info,
21265    )
21266}
21267
21268#[inline]
21269pub unsafe fn sgelsd(
21270    m: i32,
21271    n: i32,
21272    nrhs: i32,
21273    a: &[f32],
21274    lda: i32,
21275    b: &mut [f32],
21276    ldb: i32,
21277    s: &mut [f32],
21278    rcond: f32,
21279    rank: &mut i32,
21280    work: &mut [f32],
21281    lwork: i32,
21282    iwork: &mut [i32],
21283    info: &mut i32,
21284) {
21285    ffi::sgelsd_(
21286        &m,
21287        &n,
21288        &nrhs,
21289        a.as_ptr(),
21290        &lda,
21291        b.as_mut_ptr(),
21292        &ldb,
21293        s.as_mut_ptr(),
21294        &rcond,
21295        rank,
21296        work.as_mut_ptr(),
21297        &lwork,
21298        iwork.as_mut_ptr(),
21299        info,
21300    )
21301}
21302
21303#[inline]
21304pub unsafe fn dgelsd(
21305    m: i32,
21306    n: i32,
21307    nrhs: i32,
21308    a: &[f64],
21309    lda: i32,
21310    b: &mut [f64],
21311    ldb: i32,
21312    s: &mut [f64],
21313    rcond: f64,
21314    rank: &mut i32,
21315    work: &mut [f64],
21316    lwork: i32,
21317    iwork: &mut [i32],
21318    info: &mut i32,
21319) {
21320    ffi::dgelsd_(
21321        &m,
21322        &n,
21323        &nrhs,
21324        a.as_ptr(),
21325        &lda,
21326        b.as_mut_ptr(),
21327        &ldb,
21328        s.as_mut_ptr(),
21329        &rcond,
21330        rank,
21331        work.as_mut_ptr(),
21332        &lwork,
21333        iwork.as_mut_ptr(),
21334        info,
21335    )
21336}
21337
21338#[inline]
21339pub unsafe fn cgelsd(
21340    m: i32,
21341    n: i32,
21342    nrhs: i32,
21343    a: &[c32],
21344    lda: i32,
21345    b: &mut [c32],
21346    ldb: i32,
21347    s: &mut [f32],
21348    rcond: f32,
21349    rank: &mut i32,
21350    work: &mut [c32],
21351    lwork: i32,
21352    rwork: &mut [f32],
21353    iwork: &mut [i32],
21354    info: &mut i32,
21355) {
21356    ffi::cgelsd_(
21357        &m,
21358        &n,
21359        &nrhs,
21360        a.as_ptr() as *const _,
21361        &lda,
21362        b.as_mut_ptr() as *mut _,
21363        &ldb,
21364        s.as_mut_ptr(),
21365        &rcond,
21366        rank,
21367        work.as_mut_ptr() as *mut _,
21368        &lwork,
21369        rwork.as_mut_ptr(),
21370        iwork.as_mut_ptr(),
21371        info,
21372    )
21373}
21374
21375#[inline]
21376pub unsafe fn zgelsd(
21377    m: i32,
21378    n: i32,
21379    nrhs: i32,
21380    a: &[c64],
21381    lda: i32,
21382    b: &mut [c64],
21383    ldb: i32,
21384    s: &mut [f64],
21385    rcond: f64,
21386    rank: &mut i32,
21387    work: &mut [c64],
21388    lwork: i32,
21389    rwork: &mut [f64],
21390    iwork: &mut [i32],
21391    info: &mut i32,
21392) {
21393    ffi::zgelsd_(
21394        &m,
21395        &n,
21396        &nrhs,
21397        a.as_ptr() as *const _,
21398        &lda,
21399        b.as_mut_ptr() as *mut _,
21400        &ldb,
21401        s.as_mut_ptr(),
21402        &rcond,
21403        rank,
21404        work.as_mut_ptr() as *mut _,
21405        &lwork,
21406        rwork.as_mut_ptr(),
21407        iwork.as_mut_ptr(),
21408        info,
21409    )
21410}
21411
21412#[inline]
21413pub unsafe fn sgglse(
21414    m: i32,
21415    n: i32,
21416    p: i32,
21417    a: &mut [f32],
21418    lda: i32,
21419    b: &mut [f32],
21420    ldb: i32,
21421    c: &mut [f32],
21422    d: &mut [f32],
21423    x: &mut [f32],
21424    work: &mut [f32],
21425    lwork: i32,
21426    info: &mut i32,
21427) {
21428    ffi::sgglse_(
21429        &m,
21430        &n,
21431        &p,
21432        a.as_mut_ptr(),
21433        &lda,
21434        b.as_mut_ptr(),
21435        &ldb,
21436        c.as_mut_ptr(),
21437        d.as_mut_ptr(),
21438        x.as_mut_ptr(),
21439        work.as_mut_ptr(),
21440        &lwork,
21441        info,
21442    )
21443}
21444
21445#[inline]
21446pub unsafe fn dgglse(
21447    m: i32,
21448    n: i32,
21449    p: i32,
21450    a: &mut [f64],
21451    lda: i32,
21452    b: &mut [f64],
21453    ldb: i32,
21454    c: &mut [f64],
21455    d: &mut [f64],
21456    x: &mut [f64],
21457    work: &mut [f64],
21458    lwork: i32,
21459    info: &mut i32,
21460) {
21461    ffi::dgglse_(
21462        &m,
21463        &n,
21464        &p,
21465        a.as_mut_ptr(),
21466        &lda,
21467        b.as_mut_ptr(),
21468        &ldb,
21469        c.as_mut_ptr(),
21470        d.as_mut_ptr(),
21471        x.as_mut_ptr(),
21472        work.as_mut_ptr(),
21473        &lwork,
21474        info,
21475    )
21476}
21477
21478#[inline]
21479pub unsafe fn cgglse(
21480    m: i32,
21481    n: i32,
21482    p: i32,
21483    a: &mut [c32],
21484    lda: i32,
21485    b: &mut [c32],
21486    ldb: i32,
21487    c: &mut [c32],
21488    d: &mut [c32],
21489    x: &mut [c32],
21490    work: &mut [c32],
21491    lwork: i32,
21492    info: &mut i32,
21493) {
21494    ffi::cgglse_(
21495        &m,
21496        &n,
21497        &p,
21498        a.as_mut_ptr() as *mut _,
21499        &lda,
21500        b.as_mut_ptr() as *mut _,
21501        &ldb,
21502        c.as_mut_ptr() as *mut _,
21503        d.as_mut_ptr() as *mut _,
21504        x.as_mut_ptr() as *mut _,
21505        work.as_mut_ptr() as *mut _,
21506        &lwork,
21507        info,
21508    )
21509}
21510
21511#[inline]
21512pub unsafe fn zgglse(
21513    m: i32,
21514    n: i32,
21515    p: i32,
21516    a: &mut [c64],
21517    lda: i32,
21518    b: &mut [c64],
21519    ldb: i32,
21520    c: &mut [c64],
21521    d: &mut [c64],
21522    x: &mut [c64],
21523    work: &mut [c64],
21524    lwork: i32,
21525    info: &mut i32,
21526) {
21527    ffi::zgglse_(
21528        &m,
21529        &n,
21530        &p,
21531        a.as_mut_ptr() as *mut _,
21532        &lda,
21533        b.as_mut_ptr() as *mut _,
21534        &ldb,
21535        c.as_mut_ptr() as *mut _,
21536        d.as_mut_ptr() as *mut _,
21537        x.as_mut_ptr() as *mut _,
21538        work.as_mut_ptr() as *mut _,
21539        &lwork,
21540        info,
21541    )
21542}
21543
21544#[inline]
21545pub unsafe fn sggglm(
21546    n: i32,
21547    m: i32,
21548    p: i32,
21549    a: &mut [f32],
21550    lda: i32,
21551    b: &mut [f32],
21552    ldb: i32,
21553    d: &mut [f32],
21554    x: &mut [f32],
21555    y: &mut [f32],
21556    work: &mut [f32],
21557    lwork: i32,
21558    info: &mut i32,
21559) {
21560    ffi::sggglm_(
21561        &n,
21562        &m,
21563        &p,
21564        a.as_mut_ptr(),
21565        &lda,
21566        b.as_mut_ptr(),
21567        &ldb,
21568        d.as_mut_ptr(),
21569        x.as_mut_ptr(),
21570        y.as_mut_ptr(),
21571        work.as_mut_ptr(),
21572        &lwork,
21573        info,
21574    )
21575}
21576
21577#[inline]
21578pub unsafe fn dggglm(
21579    n: i32,
21580    m: i32,
21581    p: i32,
21582    a: &mut [f64],
21583    lda: i32,
21584    b: &mut [f64],
21585    ldb: i32,
21586    d: &mut [f64],
21587    x: &mut [f64],
21588    y: &mut [f64],
21589    work: &mut [f64],
21590    lwork: i32,
21591    info: &mut i32,
21592) {
21593    ffi::dggglm_(
21594        &n,
21595        &m,
21596        &p,
21597        a.as_mut_ptr(),
21598        &lda,
21599        b.as_mut_ptr(),
21600        &ldb,
21601        d.as_mut_ptr(),
21602        x.as_mut_ptr(),
21603        y.as_mut_ptr(),
21604        work.as_mut_ptr(),
21605        &lwork,
21606        info,
21607    )
21608}
21609
21610#[inline]
21611pub unsafe fn cggglm(
21612    n: i32,
21613    m: i32,
21614    p: i32,
21615    a: &mut [c32],
21616    lda: i32,
21617    b: &mut [c32],
21618    ldb: i32,
21619    d: &mut [c32],
21620    x: &mut [c32],
21621    y: &mut [c32],
21622    work: &mut [c32],
21623    lwork: i32,
21624    info: &mut i32,
21625) {
21626    ffi::cggglm_(
21627        &n,
21628        &m,
21629        &p,
21630        a.as_mut_ptr() as *mut _,
21631        &lda,
21632        b.as_mut_ptr() as *mut _,
21633        &ldb,
21634        d.as_mut_ptr() as *mut _,
21635        x.as_mut_ptr() as *mut _,
21636        y.as_mut_ptr() as *mut _,
21637        work.as_mut_ptr() as *mut _,
21638        &lwork,
21639        info,
21640    )
21641}
21642
21643#[inline]
21644pub unsafe fn zggglm(
21645    n: i32,
21646    m: i32,
21647    p: i32,
21648    a: &mut [c64],
21649    lda: i32,
21650    b: &mut [c64],
21651    ldb: i32,
21652    d: &mut [c64],
21653    x: &mut [c64],
21654    y: &mut [c64],
21655    work: &mut [c64],
21656    lwork: i32,
21657    info: &mut i32,
21658) {
21659    ffi::zggglm_(
21660        &n,
21661        &m,
21662        &p,
21663        a.as_mut_ptr() as *mut _,
21664        &lda,
21665        b.as_mut_ptr() as *mut _,
21666        &ldb,
21667        d.as_mut_ptr() as *mut _,
21668        x.as_mut_ptr() as *mut _,
21669        y.as_mut_ptr() as *mut _,
21670        work.as_mut_ptr() as *mut _,
21671        &lwork,
21672        info,
21673    )
21674}
21675
21676#[inline]
21677pub unsafe fn ssyev(
21678    jobz: u8,
21679    uplo: u8,
21680    n: i32,
21681    a: &mut [f32],
21682    lda: i32,
21683    w: &mut [f32],
21684    work: &mut [f32],
21685    lwork: i32,
21686    info: &mut i32,
21687) {
21688    ffi::ssyev_(
21689        &(jobz as c_char),
21690        &(uplo as c_char),
21691        &n,
21692        a.as_mut_ptr(),
21693        &lda,
21694        w.as_mut_ptr(),
21695        work.as_mut_ptr(),
21696        &lwork,
21697        info,
21698    )
21699}
21700
21701#[inline]
21702pub unsafe fn dsyev(
21703    jobz: u8,
21704    uplo: u8,
21705    n: i32,
21706    a: &mut [f64],
21707    lda: i32,
21708    w: &mut [f64],
21709    work: &mut [f64],
21710    lwork: i32,
21711    info: &mut i32,
21712) {
21713    ffi::dsyev_(
21714        &(jobz as c_char),
21715        &(uplo as c_char),
21716        &n,
21717        a.as_mut_ptr(),
21718        &lda,
21719        w.as_mut_ptr(),
21720        work.as_mut_ptr(),
21721        &lwork,
21722        info,
21723    )
21724}
21725
21726#[inline]
21727pub unsafe fn cheev(
21728    jobz: u8,
21729    uplo: u8,
21730    n: i32,
21731    a: &mut [c32],
21732    lda: i32,
21733    w: &mut [f32],
21734    work: &mut [c32],
21735    lwork: i32,
21736    rwork: &mut [f32],
21737    info: &mut i32,
21738) {
21739    ffi::cheev_(
21740        &(jobz as c_char),
21741        &(uplo as c_char),
21742        &n,
21743        a.as_mut_ptr() as *mut _,
21744        &lda,
21745        w.as_mut_ptr(),
21746        work.as_mut_ptr() as *mut _,
21747        &lwork,
21748        rwork.as_mut_ptr(),
21749        info,
21750    )
21751}
21752
21753#[inline]
21754pub unsafe fn zheev(
21755    jobz: u8,
21756    uplo: u8,
21757    n: i32,
21758    a: &mut [c64],
21759    lda: i32,
21760    w: &mut [f64],
21761    work: &mut [c64],
21762    lwork: i32,
21763    rwork: &mut [f64],
21764    info: &mut i32,
21765) {
21766    ffi::zheev_(
21767        &(jobz as c_char),
21768        &(uplo as c_char),
21769        &n,
21770        a.as_mut_ptr() as *mut _,
21771        &lda,
21772        w.as_mut_ptr(),
21773        work.as_mut_ptr() as *mut _,
21774        &lwork,
21775        rwork.as_mut_ptr(),
21776        info,
21777    )
21778}
21779
21780#[inline]
21781pub unsafe fn ssyevd(
21782    jobz: u8,
21783    uplo: u8,
21784    n: i32,
21785    a: &mut [f32],
21786    lda: i32,
21787    w: &mut [f32],
21788    work: &mut [f32],
21789    lwork: i32,
21790    iwork: &mut [i32],
21791    liwork: i32,
21792    info: &mut i32,
21793) {
21794    ffi::ssyevd_(
21795        &(jobz as c_char),
21796        &(uplo as c_char),
21797        &n,
21798        a.as_mut_ptr(),
21799        &lda,
21800        w.as_mut_ptr(),
21801        work.as_mut_ptr(),
21802        &lwork,
21803        iwork.as_mut_ptr(),
21804        &liwork,
21805        info,
21806    )
21807}
21808
21809#[inline]
21810pub unsafe fn dsyevd(
21811    jobz: u8,
21812    uplo: u8,
21813    n: i32,
21814    a: &mut [f64],
21815    lda: i32,
21816    w: &mut [f64],
21817    work: &mut [f64],
21818    lwork: i32,
21819    iwork: &mut [i32],
21820    liwork: i32,
21821    info: &mut i32,
21822) {
21823    ffi::dsyevd_(
21824        &(jobz as c_char),
21825        &(uplo as c_char),
21826        &n,
21827        a.as_mut_ptr(),
21828        &lda,
21829        w.as_mut_ptr(),
21830        work.as_mut_ptr(),
21831        &lwork,
21832        iwork.as_mut_ptr(),
21833        &liwork,
21834        info,
21835    )
21836}
21837
21838#[inline]
21839pub unsafe fn cheevd(
21840    jobz: u8,
21841    uplo: u8,
21842    n: i32,
21843    a: &mut [c32],
21844    lda: i32,
21845    w: &mut [f32],
21846    work: &mut [c32],
21847    lwork: i32,
21848    rwork: &mut [f32],
21849    lrwork: i32,
21850    iwork: &mut [i32],
21851    liwork: i32,
21852    info: &mut i32,
21853) {
21854    ffi::cheevd_(
21855        &(jobz as c_char),
21856        &(uplo as c_char),
21857        &n,
21858        a.as_mut_ptr() as *mut _,
21859        &lda,
21860        w.as_mut_ptr(),
21861        work.as_mut_ptr() as *mut _,
21862        &lwork,
21863        rwork.as_mut_ptr(),
21864        &lrwork,
21865        iwork.as_mut_ptr(),
21866        &liwork,
21867        info,
21868    )
21869}
21870
21871#[inline]
21872pub unsafe fn zheevd(
21873    jobz: u8,
21874    uplo: u8,
21875    n: i32,
21876    a: &mut [c64],
21877    lda: i32,
21878    w: &mut [f64],
21879    work: &mut [c64],
21880    lwork: i32,
21881    rwork: &mut [f64],
21882    lrwork: i32,
21883    iwork: &mut [i32],
21884    liwork: i32,
21885    info: &mut i32,
21886) {
21887    ffi::zheevd_(
21888        &(jobz as c_char),
21889        &(uplo as c_char),
21890        &n,
21891        a.as_mut_ptr() as *mut _,
21892        &lda,
21893        w.as_mut_ptr(),
21894        work.as_mut_ptr() as *mut _,
21895        &lwork,
21896        rwork.as_mut_ptr(),
21897        &lrwork,
21898        iwork.as_mut_ptr(),
21899        &liwork,
21900        info,
21901    )
21902}
21903
21904#[inline]
21905pub unsafe fn ssyevx(
21906    jobz: u8,
21907    range: u8,
21908    uplo: u8,
21909    n: i32,
21910    a: &mut [f32],
21911    lda: i32,
21912    vl: f32,
21913    vu: f32,
21914    il: i32,
21915    iu: i32,
21916    abstol: f32,
21917    m: &mut i32,
21918    w: &mut [f32],
21919    z: &mut [f32],
21920    ldz: i32,
21921    work: &mut [f32],
21922    lwork: i32,
21923    iwork: &mut [i32],
21924    ifail: &mut [i32],
21925    info: &mut i32,
21926) {
21927    ffi::ssyevx_(
21928        &(jobz as c_char),
21929        &(range as c_char),
21930        &(uplo as c_char),
21931        &n,
21932        a.as_mut_ptr(),
21933        &lda,
21934        &vl,
21935        &vu,
21936        &il,
21937        &iu,
21938        &abstol,
21939        m,
21940        w.as_mut_ptr(),
21941        z.as_mut_ptr(),
21942        &ldz,
21943        work.as_mut_ptr(),
21944        &lwork,
21945        iwork.as_mut_ptr(),
21946        ifail.as_mut_ptr(),
21947        info,
21948    )
21949}
21950
21951#[inline]
21952pub unsafe fn dsyevx(
21953    jobz: u8,
21954    range: u8,
21955    uplo: u8,
21956    n: i32,
21957    a: &mut [f64],
21958    lda: i32,
21959    vl: f64,
21960    vu: f64,
21961    il: i32,
21962    iu: i32,
21963    abstol: f64,
21964    m: &mut i32,
21965    w: &mut [f64],
21966    z: &mut [f64],
21967    ldz: i32,
21968    work: &mut [f64],
21969    lwork: i32,
21970    iwork: &mut [i32],
21971    ifail: &mut [i32],
21972    info: &mut i32,
21973) {
21974    ffi::dsyevx_(
21975        &(jobz as c_char),
21976        &(range as c_char),
21977        &(uplo as c_char),
21978        &n,
21979        a.as_mut_ptr(),
21980        &lda,
21981        &vl,
21982        &vu,
21983        &il,
21984        &iu,
21985        &abstol,
21986        m,
21987        w.as_mut_ptr(),
21988        z.as_mut_ptr(),
21989        &ldz,
21990        work.as_mut_ptr(),
21991        &lwork,
21992        iwork.as_mut_ptr(),
21993        ifail.as_mut_ptr(),
21994        info,
21995    )
21996}
21997
21998#[inline]
21999pub unsafe fn cheevx(
22000    jobz: u8,
22001    range: u8,
22002    uplo: u8,
22003    n: i32,
22004    a: &mut [c32],
22005    lda: i32,
22006    vl: f32,
22007    vu: f32,
22008    il: i32,
22009    iu: i32,
22010    abstol: f32,
22011    m: &mut i32,
22012    w: &mut [f32],
22013    z: &mut [c32],
22014    ldz: i32,
22015    work: &mut [c32],
22016    lwork: i32,
22017    rwork: &mut [f32],
22018    iwork: &mut [i32],
22019    ifail: &mut [i32],
22020    info: &mut i32,
22021) {
22022    ffi::cheevx_(
22023        &(jobz as c_char),
22024        &(range as c_char),
22025        &(uplo as c_char),
22026        &n,
22027        a.as_mut_ptr() as *mut _,
22028        &lda,
22029        &vl,
22030        &vu,
22031        &il,
22032        &iu,
22033        &abstol,
22034        m,
22035        w.as_mut_ptr(),
22036        z.as_mut_ptr() as *mut _,
22037        &ldz,
22038        work.as_mut_ptr() as *mut _,
22039        &lwork,
22040        rwork.as_mut_ptr(),
22041        iwork.as_mut_ptr(),
22042        ifail.as_mut_ptr(),
22043        info,
22044    )
22045}
22046
22047#[inline]
22048pub unsafe fn zheevx(
22049    jobz: u8,
22050    range: u8,
22051    uplo: u8,
22052    n: i32,
22053    a: &mut [c64],
22054    lda: i32,
22055    vl: f64,
22056    vu: f64,
22057    il: i32,
22058    iu: i32,
22059    abstol: f64,
22060    m: &mut i32,
22061    w: &mut [f64],
22062    z: &mut [c64],
22063    ldz: i32,
22064    work: &mut [c64],
22065    lwork: i32,
22066    rwork: &mut [f64],
22067    iwork: &mut [i32],
22068    ifail: &mut [i32],
22069    info: &mut i32,
22070) {
22071    ffi::zheevx_(
22072        &(jobz as c_char),
22073        &(range as c_char),
22074        &(uplo as c_char),
22075        &n,
22076        a.as_mut_ptr() as *mut _,
22077        &lda,
22078        &vl,
22079        &vu,
22080        &il,
22081        &iu,
22082        &abstol,
22083        m,
22084        w.as_mut_ptr(),
22085        z.as_mut_ptr() as *mut _,
22086        &ldz,
22087        work.as_mut_ptr() as *mut _,
22088        &lwork,
22089        rwork.as_mut_ptr(),
22090        iwork.as_mut_ptr(),
22091        ifail.as_mut_ptr(),
22092        info,
22093    )
22094}
22095
22096#[inline]
22097pub unsafe fn ssyevr(
22098    jobz: u8,
22099    range: u8,
22100    uplo: u8,
22101    n: i32,
22102    a: &mut [f32],
22103    lda: i32,
22104    vl: f32,
22105    vu: f32,
22106    il: i32,
22107    iu: i32,
22108    abstol: f32,
22109    m: &mut i32,
22110    w: &mut [f32],
22111    z: &mut [f32],
22112    ldz: i32,
22113    isuppz: &mut [i32],
22114    work: &mut [f32],
22115    lwork: i32,
22116    iwork: &mut [i32],
22117    liwork: i32,
22118    info: &mut i32,
22119) {
22120    ffi::ssyevr_(
22121        &(jobz as c_char),
22122        &(range as c_char),
22123        &(uplo as c_char),
22124        &n,
22125        a.as_mut_ptr(),
22126        &lda,
22127        &vl,
22128        &vu,
22129        &il,
22130        &iu,
22131        &abstol,
22132        m,
22133        w.as_mut_ptr(),
22134        z.as_mut_ptr(),
22135        &ldz,
22136        isuppz.as_mut_ptr(),
22137        work.as_mut_ptr(),
22138        &lwork,
22139        iwork.as_mut_ptr(),
22140        &liwork,
22141        info,
22142    )
22143}
22144
22145#[inline]
22146pub unsafe fn dsyevr(
22147    jobz: u8,
22148    range: u8,
22149    uplo: u8,
22150    n: i32,
22151    a: &mut [f64],
22152    lda: i32,
22153    vl: f64,
22154    vu: f64,
22155    il: i32,
22156    iu: i32,
22157    abstol: f64,
22158    m: &mut i32,
22159    w: &mut [f64],
22160    z: &mut [f64],
22161    ldz: i32,
22162    isuppz: &mut [i32],
22163    work: &mut [f64],
22164    lwork: i32,
22165    iwork: &mut [i32],
22166    liwork: i32,
22167    info: &mut i32,
22168) {
22169    ffi::dsyevr_(
22170        &(jobz as c_char),
22171        &(range as c_char),
22172        &(uplo as c_char),
22173        &n,
22174        a.as_mut_ptr(),
22175        &lda,
22176        &vl,
22177        &vu,
22178        &il,
22179        &iu,
22180        &abstol,
22181        m,
22182        w.as_mut_ptr(),
22183        z.as_mut_ptr(),
22184        &ldz,
22185        isuppz.as_mut_ptr(),
22186        work.as_mut_ptr(),
22187        &lwork,
22188        iwork.as_mut_ptr(),
22189        &liwork,
22190        info,
22191    )
22192}
22193
22194#[inline]
22195pub unsafe fn cheevr(
22196    jobz: u8,
22197    range: u8,
22198    uplo: u8,
22199    n: i32,
22200    a: &mut [c32],
22201    lda: i32,
22202    vl: f32,
22203    vu: f32,
22204    il: i32,
22205    iu: i32,
22206    abstol: f32,
22207    m: &mut i32,
22208    w: &mut [f32],
22209    z: &mut [c32],
22210    ldz: i32,
22211    isuppz: &mut [i32],
22212    work: &mut [c32],
22213    lwork: i32,
22214    rwork: &mut [f32],
22215    lrwork: i32,
22216    iwork: &mut [i32],
22217    liwork: i32,
22218    info: &mut i32,
22219) {
22220    ffi::cheevr_(
22221        &(jobz as c_char),
22222        &(range as c_char),
22223        &(uplo as c_char),
22224        &n,
22225        a.as_mut_ptr() as *mut _,
22226        &lda,
22227        &vl,
22228        &vu,
22229        &il,
22230        &iu,
22231        &abstol,
22232        m,
22233        w.as_mut_ptr(),
22234        z.as_mut_ptr() as *mut _,
22235        &ldz,
22236        isuppz.as_mut_ptr(),
22237        work.as_mut_ptr() as *mut _,
22238        &lwork,
22239        rwork.as_mut_ptr(),
22240        &lrwork,
22241        iwork.as_mut_ptr(),
22242        &liwork,
22243        info,
22244    )
22245}
22246
22247#[inline]
22248pub unsafe fn zheevr(
22249    jobz: u8,
22250    range: u8,
22251    uplo: u8,
22252    n: i32,
22253    a: &mut [c64],
22254    lda: i32,
22255    vl: f64,
22256    vu: f64,
22257    il: i32,
22258    iu: i32,
22259    abstol: f64,
22260    m: &mut i32,
22261    w: &mut [f64],
22262    z: &mut [c64],
22263    ldz: i32,
22264    isuppz: &mut [i32],
22265    work: &mut [c64],
22266    lwork: i32,
22267    rwork: &mut [f64],
22268    lrwork: i32,
22269    iwork: &mut [i32],
22270    liwork: i32,
22271    info: &mut i32,
22272) {
22273    ffi::zheevr_(
22274        &(jobz as c_char),
22275        &(range as c_char),
22276        &(uplo as c_char),
22277        &n,
22278        a.as_mut_ptr() as *mut _,
22279        &lda,
22280        &vl,
22281        &vu,
22282        &il,
22283        &iu,
22284        &abstol,
22285        m,
22286        w.as_mut_ptr(),
22287        z.as_mut_ptr() as *mut _,
22288        &ldz,
22289        isuppz.as_mut_ptr(),
22290        work.as_mut_ptr() as *mut _,
22291        &lwork,
22292        rwork.as_mut_ptr(),
22293        &lrwork,
22294        iwork.as_mut_ptr(),
22295        &liwork,
22296        info,
22297    )
22298}
22299
22300#[inline]
22301pub unsafe fn sspev(
22302    jobz: u8,
22303    uplo: u8,
22304    n: i32,
22305    ap: &mut [f32],
22306    w: &mut [f32],
22307    z: &mut [f32],
22308    ldz: i32,
22309    work: &mut [f32],
22310    info: &mut i32,
22311) {
22312    ffi::sspev_(
22313        &(jobz as c_char),
22314        &(uplo as c_char),
22315        &n,
22316        ap.as_mut_ptr(),
22317        w.as_mut_ptr(),
22318        z.as_mut_ptr(),
22319        &ldz,
22320        work.as_mut_ptr(),
22321        info,
22322    )
22323}
22324
22325#[inline]
22326pub unsafe fn dspev(
22327    jobz: u8,
22328    uplo: u8,
22329    n: i32,
22330    ap: &mut [f64],
22331    w: &mut [f64],
22332    z: &mut [f64],
22333    ldz: i32,
22334    work: &mut [f64],
22335    info: &mut i32,
22336) {
22337    ffi::dspev_(
22338        &(jobz as c_char),
22339        &(uplo as c_char),
22340        &n,
22341        ap.as_mut_ptr(),
22342        w.as_mut_ptr(),
22343        z.as_mut_ptr(),
22344        &ldz,
22345        work.as_mut_ptr(),
22346        info,
22347    )
22348}
22349
22350#[inline]
22351pub unsafe fn chpev(
22352    jobz: u8,
22353    uplo: u8,
22354    n: i32,
22355    ap: &mut [c32],
22356    w: &mut [f32],
22357    z: &mut [c32],
22358    ldz: i32,
22359    work: &mut [c32],
22360    rwork: &mut [f32],
22361    info: &mut i32,
22362) {
22363    ffi::chpev_(
22364        &(jobz as c_char),
22365        &(uplo as c_char),
22366        &n,
22367        ap.as_mut_ptr() as *mut _,
22368        w.as_mut_ptr(),
22369        z.as_mut_ptr() as *mut _,
22370        &ldz,
22371        work.as_mut_ptr() as *mut _,
22372        rwork.as_mut_ptr(),
22373        info,
22374    )
22375}
22376
22377#[inline]
22378pub unsafe fn zhpev(
22379    jobz: u8,
22380    uplo: u8,
22381    n: i32,
22382    ap: &mut [c64],
22383    w: &mut [f64],
22384    z: &mut [c64],
22385    ldz: i32,
22386    work: &mut [c64],
22387    rwork: &mut [f64],
22388    info: &mut i32,
22389) {
22390    ffi::zhpev_(
22391        &(jobz as c_char),
22392        &(uplo as c_char),
22393        &n,
22394        ap.as_mut_ptr() as *mut _,
22395        w.as_mut_ptr(),
22396        z.as_mut_ptr() as *mut _,
22397        &ldz,
22398        work.as_mut_ptr() as *mut _,
22399        rwork.as_mut_ptr(),
22400        info,
22401    )
22402}
22403
22404#[inline]
22405pub unsafe fn sspevd(
22406    jobz: u8,
22407    uplo: u8,
22408    n: i32,
22409    ap: &mut [f32],
22410    w: &mut [f32],
22411    z: &mut [f32],
22412    ldz: i32,
22413    work: &mut [f32],
22414    lwork: i32,
22415    iwork: &mut [i32],
22416    liwork: i32,
22417    info: &mut i32,
22418) {
22419    ffi::sspevd_(
22420        &(jobz as c_char),
22421        &(uplo as c_char),
22422        &n,
22423        ap.as_mut_ptr(),
22424        w.as_mut_ptr(),
22425        z.as_mut_ptr(),
22426        &ldz,
22427        work.as_mut_ptr(),
22428        &lwork,
22429        iwork.as_mut_ptr(),
22430        &liwork,
22431        info,
22432    )
22433}
22434
22435#[inline]
22436pub unsafe fn dspevd(
22437    jobz: u8,
22438    uplo: u8,
22439    n: i32,
22440    ap: &mut [f64],
22441    w: &mut [f64],
22442    z: &mut [f64],
22443    ldz: i32,
22444    work: &mut [f64],
22445    lwork: i32,
22446    iwork: &mut [i32],
22447    liwork: i32,
22448    info: &mut i32,
22449) {
22450    ffi::dspevd_(
22451        &(jobz as c_char),
22452        &(uplo as c_char),
22453        &n,
22454        ap.as_mut_ptr(),
22455        w.as_mut_ptr(),
22456        z.as_mut_ptr(),
22457        &ldz,
22458        work.as_mut_ptr(),
22459        &lwork,
22460        iwork.as_mut_ptr(),
22461        &liwork,
22462        info,
22463    )
22464}
22465
22466#[inline]
22467pub unsafe fn chpevd(
22468    jobz: u8,
22469    uplo: u8,
22470    n: i32,
22471    ap: &mut [c32],
22472    w: &mut [f32],
22473    z: &mut [c32],
22474    ldz: i32,
22475    work: &mut [c32],
22476    lwork: i32,
22477    rwork: &mut [f32],
22478    lrwork: i32,
22479    iwork: &mut [i32],
22480    liwork: i32,
22481    info: &mut i32,
22482) {
22483    ffi::chpevd_(
22484        &(jobz as c_char),
22485        &(uplo as c_char),
22486        &n,
22487        ap.as_mut_ptr() as *mut _,
22488        w.as_mut_ptr(),
22489        z.as_mut_ptr() as *mut _,
22490        &ldz,
22491        work.as_mut_ptr() as *mut _,
22492        &lwork,
22493        rwork.as_mut_ptr(),
22494        &lrwork,
22495        iwork.as_mut_ptr(),
22496        &liwork,
22497        info,
22498    )
22499}
22500
22501#[inline]
22502pub unsafe fn zhpevd(
22503    jobz: u8,
22504    uplo: u8,
22505    n: i32,
22506    ap: &mut [c64],
22507    w: &mut [f64],
22508    z: &mut [c64],
22509    ldz: i32,
22510    work: &mut [c64],
22511    lwork: i32,
22512    rwork: &mut [f64],
22513    lrwork: i32,
22514    iwork: &mut [i32],
22515    liwork: i32,
22516    info: &mut i32,
22517) {
22518    ffi::zhpevd_(
22519        &(jobz as c_char),
22520        &(uplo as c_char),
22521        &n,
22522        ap.as_mut_ptr() as *mut _,
22523        w.as_mut_ptr(),
22524        z.as_mut_ptr() as *mut _,
22525        &ldz,
22526        work.as_mut_ptr() as *mut _,
22527        &lwork,
22528        rwork.as_mut_ptr(),
22529        &lrwork,
22530        iwork.as_mut_ptr(),
22531        &liwork,
22532        info,
22533    )
22534}
22535
22536#[inline]
22537pub unsafe fn sspevx(
22538    jobz: u8,
22539    range: u8,
22540    uplo: u8,
22541    n: i32,
22542    ap: &mut [f32],
22543    vl: f32,
22544    vu: f32,
22545    il: i32,
22546    iu: i32,
22547    abstol: f32,
22548    m: &mut i32,
22549    w: &mut [f32],
22550    z: &mut [f32],
22551    ldz: i32,
22552    work: &mut [f32],
22553    iwork: &mut [i32],
22554    ifail: &mut [i32],
22555    info: &mut i32,
22556) {
22557    ffi::sspevx_(
22558        &(jobz as c_char),
22559        &(range as c_char),
22560        &(uplo as c_char),
22561        &n,
22562        ap.as_mut_ptr(),
22563        &vl,
22564        &vu,
22565        &il,
22566        &iu,
22567        &abstol,
22568        m,
22569        w.as_mut_ptr(),
22570        z.as_mut_ptr(),
22571        &ldz,
22572        work.as_mut_ptr(),
22573        iwork.as_mut_ptr(),
22574        ifail.as_mut_ptr(),
22575        info,
22576    )
22577}
22578
22579#[inline]
22580pub unsafe fn dspevx(
22581    jobz: u8,
22582    range: u8,
22583    uplo: u8,
22584    n: i32,
22585    ap: &mut [f64],
22586    vl: f64,
22587    vu: f64,
22588    il: i32,
22589    iu: i32,
22590    abstol: f64,
22591    m: &mut i32,
22592    w: &mut [f64],
22593    z: &mut [f64],
22594    ldz: i32,
22595    work: &mut [f64],
22596    iwork: &mut [i32],
22597    ifail: &mut [i32],
22598    info: &mut i32,
22599) {
22600    ffi::dspevx_(
22601        &(jobz as c_char),
22602        &(range as c_char),
22603        &(uplo as c_char),
22604        &n,
22605        ap.as_mut_ptr(),
22606        &vl,
22607        &vu,
22608        &il,
22609        &iu,
22610        &abstol,
22611        m,
22612        w.as_mut_ptr(),
22613        z.as_mut_ptr(),
22614        &ldz,
22615        work.as_mut_ptr(),
22616        iwork.as_mut_ptr(),
22617        ifail.as_mut_ptr(),
22618        info,
22619    )
22620}
22621
22622#[inline]
22623pub unsafe fn chpevx(
22624    jobz: u8,
22625    range: u8,
22626    uplo: u8,
22627    n: i32,
22628    ap: &mut [c32],
22629    vl: f32,
22630    vu: f32,
22631    il: i32,
22632    iu: i32,
22633    abstol: f32,
22634    m: &mut i32,
22635    w: &mut [f32],
22636    z: &mut [c32],
22637    ldz: i32,
22638    work: &mut [c32],
22639    rwork: &mut [f32],
22640    iwork: &mut [i32],
22641    ifail: &mut [i32],
22642    info: &mut i32,
22643) {
22644    ffi::chpevx_(
22645        &(jobz as c_char),
22646        &(range as c_char),
22647        &(uplo as c_char),
22648        &n,
22649        ap.as_mut_ptr() as *mut _,
22650        &vl,
22651        &vu,
22652        &il,
22653        &iu,
22654        &abstol,
22655        m,
22656        w.as_mut_ptr(),
22657        z.as_mut_ptr() as *mut _,
22658        &ldz,
22659        work.as_mut_ptr() as *mut _,
22660        rwork.as_mut_ptr(),
22661        iwork.as_mut_ptr(),
22662        ifail.as_mut_ptr(),
22663        info,
22664    )
22665}
22666
22667#[inline]
22668pub unsafe fn zhpevx(
22669    jobz: u8,
22670    range: u8,
22671    uplo: u8,
22672    n: i32,
22673    ap: &mut [c64],
22674    vl: f64,
22675    vu: f64,
22676    il: i32,
22677    iu: i32,
22678    abstol: f64,
22679    m: &mut i32,
22680    w: &mut [f64],
22681    z: &mut [c64],
22682    ldz: i32,
22683    work: &mut [c64],
22684    rwork: &mut [f64],
22685    iwork: &mut [i32],
22686    ifail: &mut [i32],
22687    info: &mut i32,
22688) {
22689    ffi::zhpevx_(
22690        &(jobz as c_char),
22691        &(range as c_char),
22692        &(uplo as c_char),
22693        &n,
22694        ap.as_mut_ptr() as *mut _,
22695        &vl,
22696        &vu,
22697        &il,
22698        &iu,
22699        &abstol,
22700        m,
22701        w.as_mut_ptr(),
22702        z.as_mut_ptr() as *mut _,
22703        &ldz,
22704        work.as_mut_ptr() as *mut _,
22705        rwork.as_mut_ptr(),
22706        iwork.as_mut_ptr(),
22707        ifail.as_mut_ptr(),
22708        info,
22709    )
22710}
22711
22712#[inline]
22713pub unsafe fn ssbev(
22714    jobz: u8,
22715    uplo: u8,
22716    n: i32,
22717    kd: i32,
22718    ab: &mut [f32],
22719    ldab: i32,
22720    w: &mut [f32],
22721    z: &mut [f32],
22722    ldz: i32,
22723    work: &mut [f32],
22724    info: &mut i32,
22725) {
22726    ffi::ssbev_(
22727        &(jobz as c_char),
22728        &(uplo as c_char),
22729        &n,
22730        &kd,
22731        ab.as_mut_ptr(),
22732        &ldab,
22733        w.as_mut_ptr(),
22734        z.as_mut_ptr(),
22735        &ldz,
22736        work.as_mut_ptr(),
22737        info,
22738    )
22739}
22740
22741#[inline]
22742pub unsafe fn dsbev(
22743    jobz: u8,
22744    uplo: u8,
22745    n: i32,
22746    kd: i32,
22747    ab: &mut [f64],
22748    ldab: i32,
22749    w: &mut [f64],
22750    z: &mut [f64],
22751    ldz: i32,
22752    work: &mut [f64],
22753    info: &mut i32,
22754) {
22755    ffi::dsbev_(
22756        &(jobz as c_char),
22757        &(uplo as c_char),
22758        &n,
22759        &kd,
22760        ab.as_mut_ptr(),
22761        &ldab,
22762        w.as_mut_ptr(),
22763        z.as_mut_ptr(),
22764        &ldz,
22765        work.as_mut_ptr(),
22766        info,
22767    )
22768}
22769
22770#[inline]
22771pub unsafe fn chbev(
22772    jobz: u8,
22773    uplo: u8,
22774    n: i32,
22775    kd: i32,
22776    ab: &mut [c32],
22777    ldab: i32,
22778    w: &mut [f32],
22779    z: &mut [c32],
22780    ldz: i32,
22781    work: &mut [c32],
22782    rwork: &mut [f32],
22783    info: &mut i32,
22784) {
22785    ffi::chbev_(
22786        &(jobz as c_char),
22787        &(uplo as c_char),
22788        &n,
22789        &kd,
22790        ab.as_mut_ptr() as *mut _,
22791        &ldab,
22792        w.as_mut_ptr(),
22793        z.as_mut_ptr() as *mut _,
22794        &ldz,
22795        work.as_mut_ptr() as *mut _,
22796        rwork.as_mut_ptr(),
22797        info,
22798    )
22799}
22800
22801#[inline]
22802pub unsafe fn zhbev(
22803    jobz: u8,
22804    uplo: u8,
22805    n: i32,
22806    kd: i32,
22807    ab: &mut [c64],
22808    ldab: i32,
22809    w: &mut [f64],
22810    z: &mut [c64],
22811    ldz: i32,
22812    work: &mut [c64],
22813    rwork: &mut [f64],
22814    info: &mut i32,
22815) {
22816    ffi::zhbev_(
22817        &(jobz as c_char),
22818        &(uplo as c_char),
22819        &n,
22820        &kd,
22821        ab.as_mut_ptr() as *mut _,
22822        &ldab,
22823        w.as_mut_ptr(),
22824        z.as_mut_ptr() as *mut _,
22825        &ldz,
22826        work.as_mut_ptr() as *mut _,
22827        rwork.as_mut_ptr(),
22828        info,
22829    )
22830}
22831
22832#[inline]
22833pub unsafe fn ssbevd(
22834    jobz: u8,
22835    uplo: u8,
22836    n: i32,
22837    kd: i32,
22838    ab: &mut [f32],
22839    ldab: i32,
22840    w: &mut [f32],
22841    z: &mut [f32],
22842    ldz: i32,
22843    work: &mut [f32],
22844    lwork: i32,
22845    iwork: &mut [i32],
22846    liwork: i32,
22847    info: &mut i32,
22848) {
22849    ffi::ssbevd_(
22850        &(jobz as c_char),
22851        &(uplo as c_char),
22852        &n,
22853        &kd,
22854        ab.as_mut_ptr(),
22855        &ldab,
22856        w.as_mut_ptr(),
22857        z.as_mut_ptr(),
22858        &ldz,
22859        work.as_mut_ptr(),
22860        &lwork,
22861        iwork.as_mut_ptr(),
22862        &liwork,
22863        info,
22864    )
22865}
22866
22867#[inline]
22868pub unsafe fn dsbevd(
22869    jobz: u8,
22870    uplo: u8,
22871    n: i32,
22872    kd: i32,
22873    ab: &mut [f64],
22874    ldab: i32,
22875    w: &mut [f64],
22876    z: &mut [f64],
22877    ldz: i32,
22878    work: &mut [f64],
22879    lwork: i32,
22880    iwork: &mut [i32],
22881    liwork: i32,
22882    info: &mut i32,
22883) {
22884    ffi::dsbevd_(
22885        &(jobz as c_char),
22886        &(uplo as c_char),
22887        &n,
22888        &kd,
22889        ab.as_mut_ptr(),
22890        &ldab,
22891        w.as_mut_ptr(),
22892        z.as_mut_ptr(),
22893        &ldz,
22894        work.as_mut_ptr(),
22895        &lwork,
22896        iwork.as_mut_ptr(),
22897        &liwork,
22898        info,
22899    )
22900}
22901
22902#[inline]
22903pub unsafe fn chbevd(
22904    jobz: u8,
22905    uplo: u8,
22906    n: i32,
22907    kd: i32,
22908    ab: &mut [c32],
22909    ldab: i32,
22910    w: &mut [f32],
22911    z: &mut [c32],
22912    ldz: i32,
22913    work: &mut [c32],
22914    lwork: i32,
22915    rwork: &mut [f32],
22916    lrwork: i32,
22917    iwork: &mut [i32],
22918    liwork: i32,
22919    info: &mut i32,
22920) {
22921    ffi::chbevd_(
22922        &(jobz as c_char),
22923        &(uplo as c_char),
22924        &n,
22925        &kd,
22926        ab.as_mut_ptr() as *mut _,
22927        &ldab,
22928        w.as_mut_ptr(),
22929        z.as_mut_ptr() as *mut _,
22930        &ldz,
22931        work.as_mut_ptr() as *mut _,
22932        &lwork,
22933        rwork.as_mut_ptr(),
22934        &lrwork,
22935        iwork.as_mut_ptr(),
22936        &liwork,
22937        info,
22938    )
22939}
22940
22941#[inline]
22942pub unsafe fn zhbevd(
22943    jobz: u8,
22944    uplo: u8,
22945    n: i32,
22946    kd: i32,
22947    ab: &mut [c64],
22948    ldab: i32,
22949    w: &mut [f64],
22950    z: &mut [c64],
22951    ldz: i32,
22952    work: &mut [c64],
22953    lwork: i32,
22954    rwork: &mut [f64],
22955    lrwork: i32,
22956    iwork: &mut [i32],
22957    liwork: i32,
22958    info: &mut i32,
22959) {
22960    ffi::zhbevd_(
22961        &(jobz as c_char),
22962        &(uplo as c_char),
22963        &n,
22964        &kd,
22965        ab.as_mut_ptr() as *mut _,
22966        &ldab,
22967        w.as_mut_ptr(),
22968        z.as_mut_ptr() as *mut _,
22969        &ldz,
22970        work.as_mut_ptr() as *mut _,
22971        &lwork,
22972        rwork.as_mut_ptr(),
22973        &lrwork,
22974        iwork.as_mut_ptr(),
22975        &liwork,
22976        info,
22977    )
22978}
22979
22980#[inline]
22981pub unsafe fn ssbevx(
22982    jobz: u8,
22983    range: u8,
22984    uplo: u8,
22985    n: i32,
22986    kd: i32,
22987    ab: &mut [f32],
22988    ldab: i32,
22989    q: &mut [f32],
22990    ldq: i32,
22991    vl: f32,
22992    vu: f32,
22993    il: i32,
22994    iu: i32,
22995    abstol: f32,
22996    m: &mut i32,
22997    w: &mut [f32],
22998    z: &mut [f32],
22999    ldz: i32,
23000    work: &mut [f32],
23001    iwork: &mut [i32],
23002    ifail: &mut [i32],
23003    info: &mut i32,
23004) {
23005    ffi::ssbevx_(
23006        &(jobz as c_char),
23007        &(range as c_char),
23008        &(uplo as c_char),
23009        &n,
23010        &kd,
23011        ab.as_mut_ptr(),
23012        &ldab,
23013        q.as_mut_ptr(),
23014        &ldq,
23015        &vl,
23016        &vu,
23017        &il,
23018        &iu,
23019        &abstol,
23020        m,
23021        w.as_mut_ptr(),
23022        z.as_mut_ptr(),
23023        &ldz,
23024        work.as_mut_ptr(),
23025        iwork.as_mut_ptr(),
23026        ifail.as_mut_ptr(),
23027        info,
23028    )
23029}
23030
23031#[inline]
23032pub unsafe fn dsbevx(
23033    jobz: u8,
23034    range: u8,
23035    uplo: u8,
23036    n: i32,
23037    kd: i32,
23038    ab: &mut [f64],
23039    ldab: i32,
23040    q: &mut [f64],
23041    ldq: i32,
23042    vl: f64,
23043    vu: f64,
23044    il: i32,
23045    iu: i32,
23046    abstol: f64,
23047    m: &mut i32,
23048    w: &mut [f64],
23049    z: &mut [f64],
23050    ldz: i32,
23051    work: &mut [f64],
23052    iwork: &mut [i32],
23053    ifail: &mut [i32],
23054    info: &mut i32,
23055) {
23056    ffi::dsbevx_(
23057        &(jobz as c_char),
23058        &(range as c_char),
23059        &(uplo as c_char),
23060        &n,
23061        &kd,
23062        ab.as_mut_ptr(),
23063        &ldab,
23064        q.as_mut_ptr(),
23065        &ldq,
23066        &vl,
23067        &vu,
23068        &il,
23069        &iu,
23070        &abstol,
23071        m,
23072        w.as_mut_ptr(),
23073        z.as_mut_ptr(),
23074        &ldz,
23075        work.as_mut_ptr(),
23076        iwork.as_mut_ptr(),
23077        ifail.as_mut_ptr(),
23078        info,
23079    )
23080}
23081
23082#[inline]
23083pub unsafe fn chbevx(
23084    jobz: u8,
23085    range: u8,
23086    uplo: u8,
23087    n: i32,
23088    kd: i32,
23089    ab: &mut [c32],
23090    ldab: i32,
23091    q: &mut [c32],
23092    ldq: i32,
23093    vl: f32,
23094    vu: f32,
23095    il: i32,
23096    iu: i32,
23097    abstol: f32,
23098    m: &mut i32,
23099    w: &mut [f32],
23100    z: &mut [c32],
23101    ldz: i32,
23102    work: &mut [c32],
23103    rwork: &mut [f32],
23104    iwork: &mut [i32],
23105    ifail: &mut [i32],
23106    info: &mut i32,
23107) {
23108    ffi::chbevx_(
23109        &(jobz as c_char),
23110        &(range as c_char),
23111        &(uplo as c_char),
23112        &n,
23113        &kd,
23114        ab.as_mut_ptr() as *mut _,
23115        &ldab,
23116        q.as_mut_ptr() as *mut _,
23117        &ldq,
23118        &vl,
23119        &vu,
23120        &il,
23121        &iu,
23122        &abstol,
23123        m,
23124        w.as_mut_ptr(),
23125        z.as_mut_ptr() as *mut _,
23126        &ldz,
23127        work.as_mut_ptr() as *mut _,
23128        rwork.as_mut_ptr(),
23129        iwork.as_mut_ptr(),
23130        ifail.as_mut_ptr(),
23131        info,
23132    )
23133}
23134
23135#[inline]
23136pub unsafe fn zhbevx(
23137    jobz: u8,
23138    range: u8,
23139    uplo: u8,
23140    n: i32,
23141    kd: i32,
23142    ab: &mut [c64],
23143    ldab: i32,
23144    q: &mut [c64],
23145    ldq: i32,
23146    vl: f64,
23147    vu: f64,
23148    il: i32,
23149    iu: i32,
23150    abstol: f64,
23151    m: &mut i32,
23152    w: &mut [f64],
23153    z: &mut [c64],
23154    ldz: i32,
23155    work: &mut [c64],
23156    rwork: &mut [f64],
23157    iwork: &mut [i32],
23158    ifail: &mut [i32],
23159    info: &mut i32,
23160) {
23161    ffi::zhbevx_(
23162        &(jobz as c_char),
23163        &(range as c_char),
23164        &(uplo as c_char),
23165        &n,
23166        &kd,
23167        ab.as_mut_ptr() as *mut _,
23168        &ldab,
23169        q.as_mut_ptr() as *mut _,
23170        &ldq,
23171        &vl,
23172        &vu,
23173        &il,
23174        &iu,
23175        &abstol,
23176        m,
23177        w.as_mut_ptr(),
23178        z.as_mut_ptr() as *mut _,
23179        &ldz,
23180        work.as_mut_ptr() as *mut _,
23181        rwork.as_mut_ptr(),
23182        iwork.as_mut_ptr(),
23183        ifail.as_mut_ptr(),
23184        info,
23185    )
23186}
23187
23188#[inline]
23189pub unsafe fn sstev(
23190    jobz: u8,
23191    n: i32,
23192    d: &mut [f32],
23193    e: &mut [f32],
23194    z: &mut [f32],
23195    ldz: i32,
23196    work: &mut [f32],
23197    info: &mut i32,
23198) {
23199    ffi::sstev_(
23200        &(jobz as c_char),
23201        &n,
23202        d.as_mut_ptr(),
23203        e.as_mut_ptr(),
23204        z.as_mut_ptr(),
23205        &ldz,
23206        work.as_mut_ptr(),
23207        info,
23208    )
23209}
23210
23211#[inline]
23212pub unsafe fn dstev(
23213    jobz: u8,
23214    n: i32,
23215    d: &mut [f64],
23216    e: &mut [f64],
23217    z: &mut [f64],
23218    ldz: i32,
23219    work: &mut [f64],
23220    info: &mut i32,
23221) {
23222    ffi::dstev_(
23223        &(jobz as c_char),
23224        &n,
23225        d.as_mut_ptr(),
23226        e.as_mut_ptr(),
23227        z.as_mut_ptr(),
23228        &ldz,
23229        work.as_mut_ptr(),
23230        info,
23231    )
23232}
23233
23234#[inline]
23235pub unsafe fn sstevd(
23236    jobz: u8,
23237    n: i32,
23238    d: &mut [f32],
23239    e: &mut [f32],
23240    z: &mut [f32],
23241    ldz: i32,
23242    work: &mut [f32],
23243    lwork: i32,
23244    iwork: &mut [i32],
23245    liwork: i32,
23246    info: &mut i32,
23247) {
23248    ffi::sstevd_(
23249        &(jobz as c_char),
23250        &n,
23251        d.as_mut_ptr(),
23252        e.as_mut_ptr(),
23253        z.as_mut_ptr(),
23254        &ldz,
23255        work.as_mut_ptr(),
23256        &lwork,
23257        iwork.as_mut_ptr(),
23258        &liwork,
23259        info,
23260    )
23261}
23262
23263#[inline]
23264pub unsafe fn dstevd(
23265    jobz: u8,
23266    n: i32,
23267    d: &mut [f64],
23268    e: &mut [f64],
23269    z: &mut [f64],
23270    ldz: i32,
23271    work: &mut [f64],
23272    lwork: i32,
23273    iwork: &mut [i32],
23274    liwork: i32,
23275    info: &mut i32,
23276) {
23277    ffi::dstevd_(
23278        &(jobz as c_char),
23279        &n,
23280        d.as_mut_ptr(),
23281        e.as_mut_ptr(),
23282        z.as_mut_ptr(),
23283        &ldz,
23284        work.as_mut_ptr(),
23285        &lwork,
23286        iwork.as_mut_ptr(),
23287        &liwork,
23288        info,
23289    )
23290}
23291
23292#[inline]
23293pub unsafe fn sstevx(
23294    jobz: u8,
23295    range: u8,
23296    n: i32,
23297    d: &mut [f32],
23298    e: &mut [f32],
23299    vl: f32,
23300    vu: f32,
23301    il: i32,
23302    iu: i32,
23303    abstol: f32,
23304    m: &mut i32,
23305    w: &mut [f32],
23306    z: &mut [f32],
23307    ldz: i32,
23308    work: &mut [f32],
23309    iwork: &mut [i32],
23310    ifail: &mut [i32],
23311    info: &mut i32,
23312) {
23313    ffi::sstevx_(
23314        &(jobz as c_char),
23315        &(range as c_char),
23316        &n,
23317        d.as_mut_ptr(),
23318        e.as_mut_ptr(),
23319        &vl,
23320        &vu,
23321        &il,
23322        &iu,
23323        &abstol,
23324        m,
23325        w.as_mut_ptr(),
23326        z.as_mut_ptr(),
23327        &ldz,
23328        work.as_mut_ptr(),
23329        iwork.as_mut_ptr(),
23330        ifail.as_mut_ptr(),
23331        info,
23332    )
23333}
23334
23335#[inline]
23336pub unsafe fn dstevx(
23337    jobz: u8,
23338    range: u8,
23339    n: i32,
23340    d: &mut [f64],
23341    e: &mut [f64],
23342    vl: f64,
23343    vu: f64,
23344    il: i32,
23345    iu: i32,
23346    abstol: f64,
23347    m: &mut i32,
23348    w: &mut [f64],
23349    z: &mut [f64],
23350    ldz: i32,
23351    work: &mut [f64],
23352    iwork: &mut [i32],
23353    ifail: &mut [i32],
23354    info: &mut i32,
23355) {
23356    ffi::dstevx_(
23357        &(jobz as c_char),
23358        &(range as c_char),
23359        &n,
23360        d.as_mut_ptr(),
23361        e.as_mut_ptr(),
23362        &vl,
23363        &vu,
23364        &il,
23365        &iu,
23366        &abstol,
23367        m,
23368        w.as_mut_ptr(),
23369        z.as_mut_ptr(),
23370        &ldz,
23371        work.as_mut_ptr(),
23372        iwork.as_mut_ptr(),
23373        ifail.as_mut_ptr(),
23374        info,
23375    )
23376}
23377
23378#[inline]
23379pub unsafe fn sstevr(
23380    jobz: u8,
23381    range: u8,
23382    n: i32,
23383    d: &mut [f32],
23384    e: &mut [f32],
23385    vl: f32,
23386    vu: f32,
23387    il: i32,
23388    iu: i32,
23389    abstol: f32,
23390    m: &mut i32,
23391    w: &mut [f32],
23392    z: &mut [f32],
23393    ldz: i32,
23394    isuppz: &mut [i32],
23395    work: &mut [f32],
23396    lwork: i32,
23397    iwork: &mut [i32],
23398    liwork: i32,
23399    info: &mut i32,
23400) {
23401    ffi::sstevr_(
23402        &(jobz as c_char),
23403        &(range as c_char),
23404        &n,
23405        d.as_mut_ptr(),
23406        e.as_mut_ptr(),
23407        &vl,
23408        &vu,
23409        &il,
23410        &iu,
23411        &abstol,
23412        m,
23413        w.as_mut_ptr(),
23414        z.as_mut_ptr(),
23415        &ldz,
23416        isuppz.as_mut_ptr(),
23417        work.as_mut_ptr(),
23418        &lwork,
23419        iwork.as_mut_ptr(),
23420        &liwork,
23421        info,
23422    )
23423}
23424
23425#[inline]
23426pub unsafe fn dstevr(
23427    jobz: u8,
23428    range: u8,
23429    n: i32,
23430    d: &mut [f64],
23431    e: &mut [f64],
23432    vl: f64,
23433    vu: f64,
23434    il: i32,
23435    iu: i32,
23436    abstol: f64,
23437    m: &mut i32,
23438    w: &mut [f64],
23439    z: &mut [f64],
23440    ldz: i32,
23441    isuppz: &mut [i32],
23442    work: &mut [f64],
23443    lwork: i32,
23444    iwork: &mut [i32],
23445    liwork: i32,
23446    info: &mut i32,
23447) {
23448    ffi::dstevr_(
23449        &(jobz as c_char),
23450        &(range as c_char),
23451        &n,
23452        d.as_mut_ptr(),
23453        e.as_mut_ptr(),
23454        &vl,
23455        &vu,
23456        &il,
23457        &iu,
23458        &abstol,
23459        m,
23460        w.as_mut_ptr(),
23461        z.as_mut_ptr(),
23462        &ldz,
23463        isuppz.as_mut_ptr(),
23464        work.as_mut_ptr(),
23465        &lwork,
23466        iwork.as_mut_ptr(),
23467        &liwork,
23468        info,
23469    )
23470}
23471
23472#[inline]
23473pub unsafe fn sgees(
23474    jobvs: u8,
23475    sort: u8,
23476    select: Select2F32,
23477    n: i32,
23478    a: &mut [f32],
23479    lda: i32,
23480    sdim: &mut i32,
23481    wr: &mut [f32],
23482    wi: &mut [f32],
23483    vs: &mut [f32],
23484    ldvs: i32,
23485    work: &mut [f32],
23486    lwork: i32,
23487    bwork: &mut [i32],
23488    info: &mut i32,
23489) {
23490    ffi::sgees_(
23491        &(jobvs as c_char),
23492        &(sort as c_char),
23493        transmute(select),
23494        &n,
23495        a.as_mut_ptr(),
23496        &lda,
23497        sdim,
23498        wr.as_mut_ptr(),
23499        wi.as_mut_ptr(),
23500        vs.as_mut_ptr(),
23501        &ldvs,
23502        work.as_mut_ptr(),
23503        &lwork,
23504        bwork.as_mut_ptr(),
23505        info,
23506    )
23507}
23508
23509#[inline]
23510pub unsafe fn dgees(
23511    jobvs: u8,
23512    sort: u8,
23513    select: Select2F64,
23514    n: i32,
23515    a: &mut [f64],
23516    lda: i32,
23517    sdim: &mut i32,
23518    wr: &mut [f64],
23519    wi: &mut [f64],
23520    vs: &mut [f64],
23521    ldvs: i32,
23522    work: &mut [f64],
23523    lwork: i32,
23524    bwork: &mut [i32],
23525    info: &mut i32,
23526) {
23527    ffi::dgees_(
23528        &(jobvs as c_char),
23529        &(sort as c_char),
23530        transmute(select),
23531        &n,
23532        a.as_mut_ptr(),
23533        &lda,
23534        sdim,
23535        wr.as_mut_ptr(),
23536        wi.as_mut_ptr(),
23537        vs.as_mut_ptr(),
23538        &ldvs,
23539        work.as_mut_ptr(),
23540        &lwork,
23541        bwork.as_mut_ptr(),
23542        info,
23543    )
23544}
23545
23546#[inline]
23547pub unsafe fn cgees(
23548    jobvs: u8,
23549    sort: u8,
23550    select: Select1C32,
23551    n: i32,
23552    a: &mut [c32],
23553    lda: i32,
23554    sdim: &mut i32,
23555    w: &mut [c32],
23556    vs: &mut [c32],
23557    ldvs: i32,
23558    work: &mut [c32],
23559    lwork: i32,
23560    rwork: &mut [f32],
23561    bwork: &mut [i32],
23562    info: &mut i32,
23563) {
23564    ffi::cgees_(
23565        &(jobvs as c_char),
23566        &(sort as c_char),
23567        transmute(select),
23568        &n,
23569        a.as_mut_ptr() as *mut _,
23570        &lda,
23571        sdim,
23572        w.as_mut_ptr() as *mut _,
23573        vs.as_mut_ptr() as *mut _,
23574        &ldvs,
23575        work.as_mut_ptr() as *mut _,
23576        &lwork,
23577        rwork.as_mut_ptr(),
23578        bwork.as_mut_ptr(),
23579        info,
23580    )
23581}
23582
23583#[inline]
23584pub unsafe fn zgees(
23585    jobvs: u8,
23586    sort: u8,
23587    select: Select1C64,
23588    n: i32,
23589    a: &mut [c64],
23590    lda: i32,
23591    sdim: &mut i32,
23592    w: &mut [c64],
23593    vs: &mut [c64],
23594    ldvs: i32,
23595    work: &mut [c64],
23596    lwork: i32,
23597    rwork: &mut [f64],
23598    bwork: &mut [i32],
23599    info: &mut i32,
23600) {
23601    ffi::zgees_(
23602        &(jobvs as c_char),
23603        &(sort as c_char),
23604        transmute(select),
23605        &n,
23606        a.as_mut_ptr() as *mut _,
23607        &lda,
23608        sdim,
23609        w.as_mut_ptr() as *mut _,
23610        vs.as_mut_ptr() as *mut _,
23611        &ldvs,
23612        work.as_mut_ptr() as *mut _,
23613        &lwork,
23614        rwork.as_mut_ptr(),
23615        bwork.as_mut_ptr(),
23616        info,
23617    )
23618}
23619
23620#[inline]
23621pub unsafe fn sgeesx(
23622    jobvs: u8,
23623    sort: u8,
23624    select: Select2F32,
23625    sense: u8,
23626    n: i32,
23627    a: &mut [f32],
23628    lda: i32,
23629    sdim: &mut i32,
23630    wr: &mut [f32],
23631    wi: &mut [f32],
23632    vs: &mut [f32],
23633    ldvs: i32,
23634    rconde: &mut [f32],
23635    rcondv: &mut [f32],
23636    work: &mut [f32],
23637    lwork: i32,
23638    iwork: &mut [i32],
23639    liwork: i32,
23640    bwork: &mut [i32],
23641    info: &mut i32,
23642) {
23643    ffi::sgeesx_(
23644        &(jobvs as c_char),
23645        &(sort as c_char),
23646        transmute(select),
23647        &(sense as c_char),
23648        &n,
23649        a.as_mut_ptr(),
23650        &lda,
23651        sdim,
23652        wr.as_mut_ptr(),
23653        wi.as_mut_ptr(),
23654        vs.as_mut_ptr(),
23655        &ldvs,
23656        rconde.as_mut_ptr(),
23657        rcondv.as_mut_ptr(),
23658        work.as_mut_ptr(),
23659        &lwork,
23660        iwork.as_mut_ptr(),
23661        &liwork,
23662        bwork.as_mut_ptr(),
23663        info,
23664    )
23665}
23666
23667#[inline]
23668pub unsafe fn dgeesx(
23669    jobvs: u8,
23670    sort: u8,
23671    select: Select2F64,
23672    sense: u8,
23673    n: i32,
23674    a: &mut [f64],
23675    lda: i32,
23676    sdim: &mut i32,
23677    wr: &mut [f64],
23678    wi: &mut [f64],
23679    vs: &mut [f64],
23680    ldvs: i32,
23681    rconde: &mut [f64],
23682    rcondv: &mut [f64],
23683    work: &mut [f64],
23684    lwork: i32,
23685    iwork: &mut [i32],
23686    liwork: i32,
23687    bwork: &mut [i32],
23688    info: &mut i32,
23689) {
23690    ffi::dgeesx_(
23691        &(jobvs as c_char),
23692        &(sort as c_char),
23693        transmute(select),
23694        &(sense as c_char),
23695        &n,
23696        a.as_mut_ptr(),
23697        &lda,
23698        sdim,
23699        wr.as_mut_ptr(),
23700        wi.as_mut_ptr(),
23701        vs.as_mut_ptr(),
23702        &ldvs,
23703        rconde.as_mut_ptr(),
23704        rcondv.as_mut_ptr(),
23705        work.as_mut_ptr(),
23706        &lwork,
23707        iwork.as_mut_ptr(),
23708        &liwork,
23709        bwork.as_mut_ptr(),
23710        info,
23711    )
23712}
23713
23714#[inline]
23715pub unsafe fn cgeesx(
23716    jobvs: u8,
23717    sort: u8,
23718    select: Select1C32,
23719    sense: u8,
23720    n: i32,
23721    a: &mut [c32],
23722    lda: i32,
23723    sdim: &mut i32,
23724    w: &mut [c32],
23725    vs: &mut [c32],
23726    ldvs: i32,
23727    rconde: &mut [f32],
23728    rcondv: &mut [f32],
23729    work: &mut [c32],
23730    lwork: i32,
23731    rwork: &mut [f32],
23732    bwork: &mut [i32],
23733    info: &mut i32,
23734) {
23735    ffi::cgeesx_(
23736        &(jobvs as c_char),
23737        &(sort as c_char),
23738        transmute(select),
23739        &(sense as c_char),
23740        &n,
23741        a.as_mut_ptr() as *mut _,
23742        &lda,
23743        sdim,
23744        w.as_mut_ptr() as *mut _,
23745        vs.as_mut_ptr() as *mut _,
23746        &ldvs,
23747        rconde.as_mut_ptr(),
23748        rcondv.as_mut_ptr(),
23749        work.as_mut_ptr() as *mut _,
23750        &lwork,
23751        rwork.as_mut_ptr(),
23752        bwork.as_mut_ptr(),
23753        info,
23754    )
23755}
23756
23757#[inline]
23758pub unsafe fn zgeesx(
23759    jobvs: u8,
23760    sort: u8,
23761    select: Select1C64,
23762    sense: u8,
23763    n: i32,
23764    a: &mut [c64],
23765    lda: i32,
23766    sdim: &mut i32,
23767    w: &mut [c64],
23768    vs: &mut [c64],
23769    ldvs: i32,
23770    rconde: &mut [f64],
23771    rcondv: &mut [f64],
23772    work: &mut [c64],
23773    lwork: i32,
23774    rwork: &mut [f64],
23775    bwork: &mut [i32],
23776    info: &mut i32,
23777) {
23778    ffi::zgeesx_(
23779        &(jobvs as c_char),
23780        &(sort as c_char),
23781        transmute(select),
23782        &(sense as c_char),
23783        &n,
23784        a.as_mut_ptr() as *mut _,
23785        &lda,
23786        sdim,
23787        w.as_mut_ptr() as *mut _,
23788        vs.as_mut_ptr() as *mut _,
23789        &ldvs,
23790        rconde.as_mut_ptr(),
23791        rcondv.as_mut_ptr(),
23792        work.as_mut_ptr() as *mut _,
23793        &lwork,
23794        rwork.as_mut_ptr(),
23795        bwork.as_mut_ptr(),
23796        info,
23797    )
23798}
23799
23800#[inline]
23801pub unsafe fn sgeev(
23802    jobvl: u8,
23803    jobvr: u8,
23804    n: i32,
23805    a: &mut [f32],
23806    lda: i32,
23807    wr: &mut [f32],
23808    wi: &mut [f32],
23809    vl: &mut [f32],
23810    ldvl: i32,
23811    vr: &mut [f32],
23812    ldvr: i32,
23813    work: &mut [f32],
23814    lwork: i32,
23815    info: &mut i32,
23816) {
23817    ffi::sgeev_(
23818        &(jobvl as c_char),
23819        &(jobvr as c_char),
23820        &n,
23821        a.as_mut_ptr(),
23822        &lda,
23823        wr.as_mut_ptr(),
23824        wi.as_mut_ptr(),
23825        vl.as_mut_ptr(),
23826        &ldvl,
23827        vr.as_mut_ptr(),
23828        &ldvr,
23829        work.as_mut_ptr(),
23830        &lwork,
23831        info,
23832    )
23833}
23834
23835#[inline]
23836pub unsafe fn dgeev(
23837    jobvl: u8,
23838    jobvr: u8,
23839    n: i32,
23840    a: &mut [f64],
23841    lda: i32,
23842    wr: &mut [f64],
23843    wi: &mut [f64],
23844    vl: &mut [f64],
23845    ldvl: i32,
23846    vr: &mut [f64],
23847    ldvr: i32,
23848    work: &mut [f64],
23849    lwork: i32,
23850    info: &mut i32,
23851) {
23852    ffi::dgeev_(
23853        &(jobvl as c_char),
23854        &(jobvr as c_char),
23855        &n,
23856        a.as_mut_ptr(),
23857        &lda,
23858        wr.as_mut_ptr(),
23859        wi.as_mut_ptr(),
23860        vl.as_mut_ptr(),
23861        &ldvl,
23862        vr.as_mut_ptr(),
23863        &ldvr,
23864        work.as_mut_ptr(),
23865        &lwork,
23866        info,
23867    )
23868}
23869
23870#[inline]
23871pub unsafe fn cgeev(
23872    jobvl: u8,
23873    jobvr: u8,
23874    n: i32,
23875    a: &mut [c32],
23876    lda: i32,
23877    w: &mut [c32],
23878    vl: &mut [c32],
23879    ldvl: i32,
23880    vr: &mut [c32],
23881    ldvr: i32,
23882    work: &mut [c32],
23883    lwork: i32,
23884    rwork: &mut [f32],
23885    info: &mut i32,
23886) {
23887    ffi::cgeev_(
23888        &(jobvl as c_char),
23889        &(jobvr as c_char),
23890        &n,
23891        a.as_mut_ptr() as *mut _,
23892        &lda,
23893        w.as_mut_ptr() as *mut _,
23894        vl.as_mut_ptr() as *mut _,
23895        &ldvl,
23896        vr.as_mut_ptr() as *mut _,
23897        &ldvr,
23898        work.as_mut_ptr() as *mut _,
23899        &lwork,
23900        rwork.as_mut_ptr(),
23901        info,
23902    )
23903}
23904
23905#[inline]
23906pub unsafe fn zgeev(
23907    jobvl: u8,
23908    jobvr: u8,
23909    n: i32,
23910    a: &mut [c64],
23911    lda: i32,
23912    w: &mut [c64],
23913    vl: &mut [c64],
23914    ldvl: i32,
23915    vr: &mut [c64],
23916    ldvr: i32,
23917    work: &mut [c64],
23918    lwork: i32,
23919    rwork: &mut [f64],
23920    info: &mut i32,
23921) {
23922    ffi::zgeev_(
23923        &(jobvl as c_char),
23924        &(jobvr as c_char),
23925        &n,
23926        a.as_mut_ptr() as *mut _,
23927        &lda,
23928        w.as_mut_ptr() as *mut _,
23929        vl.as_mut_ptr() as *mut _,
23930        &ldvl,
23931        vr.as_mut_ptr() as *mut _,
23932        &ldvr,
23933        work.as_mut_ptr() as *mut _,
23934        &lwork,
23935        rwork.as_mut_ptr(),
23936        info,
23937    )
23938}
23939
23940#[inline]
23941pub unsafe fn sgeevx(
23942    balanc: u8,
23943    jobvl: u8,
23944    jobvr: u8,
23945    sense: u8,
23946    n: i32,
23947    a: &mut [f32],
23948    lda: i32,
23949    wr: &mut [f32],
23950    wi: &mut [f32],
23951    vl: &mut [f32],
23952    ldvl: i32,
23953    vr: &mut [f32],
23954    ldvr: i32,
23955    ilo: &mut i32,
23956    ihi: &mut i32,
23957    scale: &mut [f32],
23958    abnrm: &mut f32,
23959    rconde: &mut [f32],
23960    rcondv: &mut [f32],
23961    work: &mut [f32],
23962    lwork: i32,
23963    iwork: &mut [i32],
23964    info: &mut i32,
23965) {
23966    ffi::sgeevx_(
23967        &(balanc as c_char),
23968        &(jobvl as c_char),
23969        &(jobvr as c_char),
23970        &(sense as c_char),
23971        &n,
23972        a.as_mut_ptr(),
23973        &lda,
23974        wr.as_mut_ptr(),
23975        wi.as_mut_ptr(),
23976        vl.as_mut_ptr(),
23977        &ldvl,
23978        vr.as_mut_ptr(),
23979        &ldvr,
23980        ilo,
23981        ihi,
23982        scale.as_mut_ptr(),
23983        abnrm,
23984        rconde.as_mut_ptr(),
23985        rcondv.as_mut_ptr(),
23986        work.as_mut_ptr(),
23987        &lwork,
23988        iwork.as_mut_ptr(),
23989        info,
23990    )
23991}
23992
23993#[inline]
23994pub unsafe fn dgeevx(
23995    balanc: u8,
23996    jobvl: u8,
23997    jobvr: u8,
23998    sense: u8,
23999    n: i32,
24000    a: &mut [f64],
24001    lda: i32,
24002    wr: &mut [f64],
24003    wi: &mut [f64],
24004    vl: &mut [f64],
24005    ldvl: i32,
24006    vr: &mut [f64],
24007    ldvr: i32,
24008    ilo: &mut i32,
24009    ihi: &mut i32,
24010    scale: &mut [f64],
24011    abnrm: &mut f64,
24012    rconde: &mut [f64],
24013    rcondv: &mut [f64],
24014    work: &mut [f64],
24015    lwork: i32,
24016    iwork: &mut [i32],
24017    info: &mut i32,
24018) {
24019    ffi::dgeevx_(
24020        &(balanc as c_char),
24021        &(jobvl as c_char),
24022        &(jobvr as c_char),
24023        &(sense as c_char),
24024        &n,
24025        a.as_mut_ptr(),
24026        &lda,
24027        wr.as_mut_ptr(),
24028        wi.as_mut_ptr(),
24029        vl.as_mut_ptr(),
24030        &ldvl,
24031        vr.as_mut_ptr(),
24032        &ldvr,
24033        ilo,
24034        ihi,
24035        scale.as_mut_ptr(),
24036        abnrm,
24037        rconde.as_mut_ptr(),
24038        rcondv.as_mut_ptr(),
24039        work.as_mut_ptr(),
24040        &lwork,
24041        iwork.as_mut_ptr(),
24042        info,
24043    )
24044}
24045
24046#[inline]
24047pub unsafe fn cgeevx(
24048    balanc: u8,
24049    jobvl: u8,
24050    jobvr: u8,
24051    sense: u8,
24052    n: i32,
24053    a: &mut [c32],
24054    lda: i32,
24055    w: &mut [c32],
24056    vl: &mut [c32],
24057    ldvl: i32,
24058    vr: &mut [c32],
24059    ldvr: i32,
24060    ilo: &mut i32,
24061    ihi: &mut i32,
24062    scale: &mut [f32],
24063    abnrm: &mut f32,
24064    rconde: &mut [f32],
24065    rcondv: &mut [f32],
24066    work: &mut [c32],
24067    lwork: i32,
24068    rwork: &mut [f32],
24069    info: &mut i32,
24070) {
24071    ffi::cgeevx_(
24072        &(balanc as c_char),
24073        &(jobvl as c_char),
24074        &(jobvr as c_char),
24075        &(sense as c_char),
24076        &n,
24077        a.as_mut_ptr() as *mut _,
24078        &lda,
24079        w.as_mut_ptr() as *mut _,
24080        vl.as_mut_ptr() as *mut _,
24081        &ldvl,
24082        vr.as_mut_ptr() as *mut _,
24083        &ldvr,
24084        ilo,
24085        ihi,
24086        scale.as_mut_ptr(),
24087        abnrm,
24088        rconde.as_mut_ptr(),
24089        rcondv.as_mut_ptr(),
24090        work.as_mut_ptr() as *mut _,
24091        &lwork,
24092        rwork.as_mut_ptr(),
24093        info,
24094    )
24095}
24096
24097#[inline]
24098pub unsafe fn zgeevx(
24099    balanc: u8,
24100    jobvl: u8,
24101    jobvr: u8,
24102    sense: u8,
24103    n: i32,
24104    a: &mut [c64],
24105    lda: i32,
24106    w: &mut [c64],
24107    vl: &mut [c64],
24108    ldvl: i32,
24109    vr: &mut [c64],
24110    ldvr: i32,
24111    ilo: &mut i32,
24112    ihi: &mut i32,
24113    scale: &mut [f64],
24114    abnrm: &mut f64,
24115    rconde: &mut [f64],
24116    rcondv: &mut [f64],
24117    work: &mut [c64],
24118    lwork: i32,
24119    rwork: &mut [f64],
24120    info: &mut i32,
24121) {
24122    ffi::zgeevx_(
24123        &(balanc as c_char),
24124        &(jobvl as c_char),
24125        &(jobvr as c_char),
24126        &(sense as c_char),
24127        &n,
24128        a.as_mut_ptr() as *mut _,
24129        &lda,
24130        w.as_mut_ptr() as *mut _,
24131        vl.as_mut_ptr() as *mut _,
24132        &ldvl,
24133        vr.as_mut_ptr() as *mut _,
24134        &ldvr,
24135        ilo,
24136        ihi,
24137        scale.as_mut_ptr(),
24138        abnrm,
24139        rconde.as_mut_ptr(),
24140        rcondv.as_mut_ptr(),
24141        work.as_mut_ptr() as *mut _,
24142        &lwork,
24143        rwork.as_mut_ptr(),
24144        info,
24145    )
24146}
24147
24148#[inline]
24149pub unsafe fn sgesvd(
24150    jobu: u8,
24151    jobvt: u8,
24152    m: i32,
24153    n: i32,
24154    a: &mut [f32],
24155    lda: i32,
24156    s: &mut [f32],
24157    u: &mut [f32],
24158    ldu: i32,
24159    vt: &mut [f32],
24160    ldvt: i32,
24161    work: &mut [f32],
24162    lwork: i32,
24163    info: &mut i32,
24164) {
24165    ffi::sgesvd_(
24166        &(jobu as c_char),
24167        &(jobvt as c_char),
24168        &m,
24169        &n,
24170        a.as_mut_ptr(),
24171        &lda,
24172        s.as_mut_ptr(),
24173        u.as_mut_ptr(),
24174        &ldu,
24175        vt.as_mut_ptr(),
24176        &ldvt,
24177        work.as_mut_ptr(),
24178        &lwork,
24179        info,
24180    )
24181}
24182
24183#[inline]
24184pub unsafe fn dgesvd(
24185    jobu: u8,
24186    jobvt: u8,
24187    m: i32,
24188    n: i32,
24189    a: &mut [f64],
24190    lda: i32,
24191    s: &mut [f64],
24192    u: &mut [f64],
24193    ldu: i32,
24194    vt: &mut [f64],
24195    ldvt: i32,
24196    work: &mut [f64],
24197    lwork: i32,
24198    info: &mut i32,
24199) {
24200    ffi::dgesvd_(
24201        &(jobu as c_char),
24202        &(jobvt as c_char),
24203        &m,
24204        &n,
24205        a.as_mut_ptr(),
24206        &lda,
24207        s.as_mut_ptr(),
24208        u.as_mut_ptr(),
24209        &ldu,
24210        vt.as_mut_ptr(),
24211        &ldvt,
24212        work.as_mut_ptr(),
24213        &lwork,
24214        info,
24215    )
24216}
24217
24218#[inline]
24219pub unsafe fn cgesvd(
24220    jobu: u8,
24221    jobvt: u8,
24222    m: i32,
24223    n: i32,
24224    a: &mut [c32],
24225    lda: i32,
24226    s: &mut [f32],
24227    u: &mut [c32],
24228    ldu: i32,
24229    vt: &mut [c32],
24230    ldvt: i32,
24231    work: &mut [c32],
24232    lwork: i32,
24233    rwork: &mut [f32],
24234    info: &mut i32,
24235) {
24236    ffi::cgesvd_(
24237        &(jobu as c_char),
24238        &(jobvt as c_char),
24239        &m,
24240        &n,
24241        a.as_mut_ptr() as *mut _,
24242        &lda,
24243        s.as_mut_ptr(),
24244        u.as_mut_ptr() as *mut _,
24245        &ldu,
24246        vt.as_mut_ptr() as *mut _,
24247        &ldvt,
24248        work.as_mut_ptr() as *mut _,
24249        &lwork,
24250        rwork.as_mut_ptr(),
24251        info,
24252    )
24253}
24254
24255#[inline]
24256pub unsafe fn zgesvd(
24257    jobu: u8,
24258    jobvt: u8,
24259    m: i32,
24260    n: i32,
24261    a: &mut [c64],
24262    lda: i32,
24263    s: &mut [f64],
24264    u: &mut [c64],
24265    ldu: i32,
24266    vt: &mut [c64],
24267    ldvt: i32,
24268    work: &mut [c64],
24269    lwork: i32,
24270    rwork: &mut [f64],
24271    info: &mut i32,
24272) {
24273    ffi::zgesvd_(
24274        &(jobu as c_char),
24275        &(jobvt as c_char),
24276        &m,
24277        &n,
24278        a.as_mut_ptr() as *mut _,
24279        &lda,
24280        s.as_mut_ptr(),
24281        u.as_mut_ptr() as *mut _,
24282        &ldu,
24283        vt.as_mut_ptr() as *mut _,
24284        &ldvt,
24285        work.as_mut_ptr() as *mut _,
24286        &lwork,
24287        rwork.as_mut_ptr(),
24288        info,
24289    )
24290}
24291
24292#[inline]
24293pub unsafe fn sgesvdx(
24294    jobu: u8,
24295    jobvt: u8,
24296    range: u8,
24297    m: i32,
24298    n: i32,
24299    a: &mut [f32],
24300    lda: i32,
24301    vl: f32,
24302    vu: f32,
24303    il: i32,
24304    iu: i32,
24305    ns: &mut [i32],
24306    s: &mut [f32],
24307    u: &mut [f32],
24308    ldu: i32,
24309    vt: &mut [f32],
24310    ldvt: i32,
24311    work: &mut [f32],
24312    lwork: i32,
24313    iwork: &mut [i32],
24314    info: &mut i32,
24315) {
24316    ffi::sgesvdx_(
24317        &(jobu as c_char),
24318        &(jobvt as c_char),
24319        &(range as c_char),
24320        &m,
24321        &n,
24322        a.as_mut_ptr(),
24323        &lda,
24324        &vl,
24325        &vu,
24326        &il,
24327        &iu,
24328        ns.as_mut_ptr(),
24329        s.as_mut_ptr(),
24330        u.as_mut_ptr(),
24331        &ldu,
24332        vt.as_mut_ptr(),
24333        &ldvt,
24334        work.as_mut_ptr(),
24335        &lwork,
24336        iwork.as_mut_ptr(),
24337        info,
24338    )
24339}
24340
24341#[inline]
24342pub unsafe fn dgesvdx(
24343    jobu: u8,
24344    jobvt: u8,
24345    range: u8,
24346    m: i32,
24347    n: i32,
24348    a: &mut [f64],
24349    lda: i32,
24350    vl: f64,
24351    vu: f64,
24352    il: i32,
24353    iu: i32,
24354    ns: &mut [i32],
24355    s: &mut [f64],
24356    u: &mut [f64],
24357    ldu: i32,
24358    vt: &mut [f64],
24359    ldvt: i32,
24360    work: &mut [f64],
24361    lwork: i32,
24362    iwork: &mut [i32],
24363    info: &mut i32,
24364) {
24365    ffi::dgesvdx_(
24366        &(jobu as c_char),
24367        &(jobvt as c_char),
24368        &(range as c_char),
24369        &m,
24370        &n,
24371        a.as_mut_ptr(),
24372        &lda,
24373        &vl,
24374        &vu,
24375        &il,
24376        &iu,
24377        ns.as_mut_ptr(),
24378        s.as_mut_ptr(),
24379        u.as_mut_ptr(),
24380        &ldu,
24381        vt.as_mut_ptr(),
24382        &ldvt,
24383        work.as_mut_ptr(),
24384        &lwork,
24385        iwork.as_mut_ptr(),
24386        info,
24387    )
24388}
24389
24390#[inline]
24391pub unsafe fn cgesvdx(
24392    jobu: u8,
24393    jobvt: u8,
24394    range: u8,
24395    m: i32,
24396    n: i32,
24397    a: &mut [c32],
24398    lda: i32,
24399    vl: f32,
24400    vu: f32,
24401    il: i32,
24402    iu: i32,
24403    ns: &mut [i32],
24404    s: &mut [f32],
24405    u: &mut [c32],
24406    ldu: i32,
24407    vt: &mut [c32],
24408    ldvt: i32,
24409    work: &mut [c32],
24410    lwork: i32,
24411    rwork: &mut [f32],
24412    iwork: &mut [i32],
24413    info: &mut i32,
24414) {
24415    ffi::cgesvdx_(
24416        &(jobu as c_char),
24417        &(jobvt as c_char),
24418        &(range as c_char),
24419        &m,
24420        &n,
24421        a.as_mut_ptr() as *mut _,
24422        &lda,
24423        &vl,
24424        &vu,
24425        &il,
24426        &iu,
24427        ns.as_mut_ptr(),
24428        s.as_mut_ptr(),
24429        u.as_mut_ptr() as *mut _,
24430        &ldu,
24431        vt.as_mut_ptr() as *mut _,
24432        &ldvt,
24433        work.as_mut_ptr() as *mut _,
24434        &lwork,
24435        rwork.as_mut_ptr(),
24436        iwork.as_mut_ptr(),
24437        info,
24438    )
24439}
24440
24441#[inline]
24442pub unsafe fn zgesvdx(
24443    jobu: u8,
24444    jobvt: u8,
24445    range: u8,
24446    m: i32,
24447    n: i32,
24448    a: &mut [c64],
24449    lda: i32,
24450    vl: f64,
24451    vu: f64,
24452    il: i32,
24453    iu: i32,
24454    ns: &mut [i32],
24455    s: &mut [f64],
24456    u: &mut [c64],
24457    ldu: i32,
24458    vt: &mut [c64],
24459    ldvt: i32,
24460    work: &mut [c64],
24461    lwork: i32,
24462    rwork: &mut [f64],
24463    iwork: &mut [i32],
24464    info: &mut i32,
24465) {
24466    ffi::zgesvdx_(
24467        &(jobu as c_char),
24468        &(jobvt as c_char),
24469        &(range as c_char),
24470        &m,
24471        &n,
24472        a.as_mut_ptr() as *mut _,
24473        &lda,
24474        &vl,
24475        &vu,
24476        &il,
24477        &iu,
24478        ns.as_mut_ptr(),
24479        s.as_mut_ptr(),
24480        u.as_mut_ptr() as *mut _,
24481        &ldu,
24482        vt.as_mut_ptr() as *mut _,
24483        &ldvt,
24484        work.as_mut_ptr() as *mut _,
24485        &lwork,
24486        rwork.as_mut_ptr(),
24487        iwork.as_mut_ptr(),
24488        info,
24489    )
24490}
24491
24492#[inline]
24493pub unsafe fn sgesdd(
24494    jobz: u8,
24495    m: i32,
24496    n: i32,
24497    a: &mut [f32],
24498    lda: i32,
24499    s: &mut [f32],
24500    u: &mut [f32],
24501    ldu: i32,
24502    vt: &mut [f32],
24503    ldvt: i32,
24504    work: &mut [f32],
24505    lwork: i32,
24506    iwork: &mut [i32],
24507    info: &mut i32,
24508) {
24509    ffi::sgesdd_(
24510        &(jobz as c_char),
24511        &m,
24512        &n,
24513        a.as_mut_ptr(),
24514        &lda,
24515        s.as_mut_ptr(),
24516        u.as_mut_ptr(),
24517        &ldu,
24518        vt.as_mut_ptr(),
24519        &ldvt,
24520        work.as_mut_ptr(),
24521        &lwork,
24522        iwork.as_mut_ptr(),
24523        info,
24524    )
24525}
24526
24527#[inline]
24528pub unsafe fn dgesdd(
24529    jobz: u8,
24530    m: i32,
24531    n: i32,
24532    a: &mut [f64],
24533    lda: i32,
24534    s: &mut [f64],
24535    u: &mut [f64],
24536    ldu: i32,
24537    vt: &mut [f64],
24538    ldvt: i32,
24539    work: &mut [f64],
24540    lwork: i32,
24541    iwork: &mut [i32],
24542    info: &mut i32,
24543) {
24544    ffi::dgesdd_(
24545        &(jobz as c_char),
24546        &m,
24547        &n,
24548        a.as_mut_ptr(),
24549        &lda,
24550        s.as_mut_ptr(),
24551        u.as_mut_ptr(),
24552        &ldu,
24553        vt.as_mut_ptr(),
24554        &ldvt,
24555        work.as_mut_ptr(),
24556        &lwork,
24557        iwork.as_mut_ptr(),
24558        info,
24559    )
24560}
24561
24562#[inline]
24563pub unsafe fn cgesdd(
24564    jobz: u8,
24565    m: i32,
24566    n: i32,
24567    a: &mut [c32],
24568    lda: i32,
24569    s: &mut [f32],
24570    u: &mut [c32],
24571    ldu: i32,
24572    vt: &mut [c32],
24573    ldvt: i32,
24574    work: &mut [c32],
24575    lwork: i32,
24576    rwork: &mut [f32],
24577    iwork: &mut [i32],
24578    info: &mut i32,
24579) {
24580    ffi::cgesdd_(
24581        &(jobz as c_char),
24582        &m,
24583        &n,
24584        a.as_mut_ptr() as *mut _,
24585        &lda,
24586        s.as_mut_ptr(),
24587        u.as_mut_ptr() as *mut _,
24588        &ldu,
24589        vt.as_mut_ptr() as *mut _,
24590        &ldvt,
24591        work.as_mut_ptr() as *mut _,
24592        &lwork,
24593        rwork.as_mut_ptr(),
24594        iwork.as_mut_ptr(),
24595        info,
24596    )
24597}
24598
24599#[inline]
24600pub unsafe fn zgesdd(
24601    jobz: u8,
24602    m: i32,
24603    n: i32,
24604    a: &mut [c64],
24605    lda: i32,
24606    s: &mut [f64],
24607    u: &mut [c64],
24608    ldu: i32,
24609    vt: &mut [c64],
24610    ldvt: i32,
24611    work: &mut [c64],
24612    lwork: i32,
24613    rwork: &mut [f64],
24614    iwork: &mut [i32],
24615    info: &mut i32,
24616) {
24617    ffi::zgesdd_(
24618        &(jobz as c_char),
24619        &m,
24620        &n,
24621        a.as_mut_ptr() as *mut _,
24622        &lda,
24623        s.as_mut_ptr(),
24624        u.as_mut_ptr() as *mut _,
24625        &ldu,
24626        vt.as_mut_ptr() as *mut _,
24627        &ldvt,
24628        work.as_mut_ptr() as *mut _,
24629        &lwork,
24630        rwork.as_mut_ptr(),
24631        iwork.as_mut_ptr(),
24632        info,
24633    )
24634}
24635
24636#[inline]
24637pub unsafe fn dgejsv(
24638    joba: u8,
24639    jobu: u8,
24640    jobv: u8,
24641    jobr: u8,
24642    jobt: u8,
24643    jobp: u8,
24644    m: i32,
24645    n: i32,
24646    a: &mut [f64],
24647    lda: i32,
24648    sva: &mut [f64],
24649    u: &mut [f64],
24650    ldu: i32,
24651    v: &mut [f64],
24652    ldv: i32,
24653    work: &mut [f64],
24654    lwork: i32,
24655    iwork: &mut [i32],
24656    info: &mut i32,
24657) {
24658    ffi::dgejsv_(
24659        &(joba as c_char),
24660        &(jobu as c_char),
24661        &(jobv as c_char),
24662        &(jobr as c_char),
24663        &(jobt as c_char),
24664        &(jobp as c_char),
24665        &m,
24666        &n,
24667        a.as_mut_ptr(),
24668        &lda,
24669        sva.as_mut_ptr(),
24670        u.as_mut_ptr(),
24671        &ldu,
24672        v.as_mut_ptr(),
24673        &ldv,
24674        work.as_mut_ptr(),
24675        &lwork,
24676        iwork.as_mut_ptr(),
24677        info,
24678    )
24679}
24680
24681#[inline]
24682pub unsafe fn sgejsv(
24683    joba: u8,
24684    jobu: u8,
24685    jobv: u8,
24686    jobr: u8,
24687    jobt: u8,
24688    jobp: u8,
24689    m: i32,
24690    n: i32,
24691    a: &mut [f32],
24692    lda: i32,
24693    sva: &mut [f32],
24694    u: &mut [f32],
24695    ldu: i32,
24696    v: &mut [f32],
24697    ldv: i32,
24698    work: &mut [f32],
24699    lwork: i32,
24700    iwork: &mut [i32],
24701    info: &mut i32,
24702) {
24703    ffi::sgejsv_(
24704        &(joba as c_char),
24705        &(jobu as c_char),
24706        &(jobv as c_char),
24707        &(jobr as c_char),
24708        &(jobt as c_char),
24709        &(jobp as c_char),
24710        &m,
24711        &n,
24712        a.as_mut_ptr(),
24713        &lda,
24714        sva.as_mut_ptr(),
24715        u.as_mut_ptr(),
24716        &ldu,
24717        v.as_mut_ptr(),
24718        &ldv,
24719        work.as_mut_ptr(),
24720        &lwork,
24721        iwork.as_mut_ptr(),
24722        info,
24723    )
24724}
24725
24726#[inline]
24727pub unsafe fn cgejsv(
24728    joba: u8,
24729    jobu: u8,
24730    jobv: u8,
24731    jobr: u8,
24732    jobt: u8,
24733    jobp: u8,
24734    m: i32,
24735    n: i32,
24736    a: &mut [c32],
24737    lda: i32,
24738    sva: &mut [f32],
24739    u: &mut [c32],
24740    ldu: i32,
24741    v: &mut [c32],
24742    ldv: i32,
24743    cwork: &mut [c32],
24744    lwork: i32,
24745    work: &mut [f32],
24746    lrwork: i32,
24747    iwork: &mut [i32],
24748    info: &mut i32,
24749) {
24750    ffi::cgejsv_(
24751        &(joba as c_char),
24752        &(jobu as c_char),
24753        &(jobv as c_char),
24754        &(jobr as c_char),
24755        &(jobt as c_char),
24756        &(jobp as c_char),
24757        &m,
24758        &n,
24759        a.as_mut_ptr() as *mut _,
24760        &lda,
24761        sva.as_mut_ptr(),
24762        u.as_mut_ptr() as *mut _,
24763        &ldu,
24764        v.as_mut_ptr() as *mut _,
24765        &ldv,
24766        cwork.as_mut_ptr() as *mut _,
24767        &lwork,
24768        work.as_mut_ptr(),
24769        &lrwork,
24770        iwork.as_mut_ptr(),
24771        info,
24772    )
24773}
24774
24775#[inline]
24776pub unsafe fn zgejsv(
24777    joba: u8,
24778    jobu: u8,
24779    jobv: u8,
24780    jobr: u8,
24781    jobt: u8,
24782    jobp: u8,
24783    m: i32,
24784    n: i32,
24785    a: &mut [c64],
24786    lda: i32,
24787    sva: &mut [f64],
24788    u: &mut [c64],
24789    ldu: i32,
24790    v: &mut [c64],
24791    ldv: i32,
24792    cwork: &mut [c64],
24793    lwork: i32,
24794    work: &mut [f64],
24795    lrwork: i32,
24796    iwork: &mut [i32],
24797    info: &mut i32,
24798) {
24799    ffi::zgejsv_(
24800        &(joba as c_char),
24801        &(jobu as c_char),
24802        &(jobv as c_char),
24803        &(jobr as c_char),
24804        &(jobt as c_char),
24805        &(jobp as c_char),
24806        &m,
24807        &n,
24808        a.as_mut_ptr() as *mut _,
24809        &lda,
24810        sva.as_mut_ptr(),
24811        u.as_mut_ptr() as *mut _,
24812        &ldu,
24813        v.as_mut_ptr() as *mut _,
24814        &ldv,
24815        cwork.as_mut_ptr() as *mut _,
24816        &lwork,
24817        work.as_mut_ptr(),
24818        &lrwork,
24819        iwork.as_mut_ptr(),
24820        info,
24821    )
24822}
24823
24824#[inline]
24825pub unsafe fn dgesvj(
24826    joba: u8,
24827    jobu: u8,
24828    jobv: u8,
24829    m: i32,
24830    n: i32,
24831    a: &mut [f64],
24832    lda: i32,
24833    sva: &mut [f64],
24834    mv: &[i32],
24835    v: &mut [f64],
24836    ldv: i32,
24837    work: &mut [f64],
24838    lwork: i32,
24839    info: &mut i32,
24840) {
24841    ffi::dgesvj_(
24842        &(joba as c_char),
24843        &(jobu as c_char),
24844        &(jobv as c_char),
24845        &m,
24846        &n,
24847        a.as_mut_ptr(),
24848        &lda,
24849        sva.as_mut_ptr(),
24850        mv.as_ptr(),
24851        v.as_mut_ptr(),
24852        &ldv,
24853        work.as_mut_ptr(),
24854        &lwork,
24855        info,
24856    )
24857}
24858
24859#[inline]
24860pub unsafe fn sgesvj(
24861    joba: u8,
24862    jobu: u8,
24863    jobv: u8,
24864    m: i32,
24865    n: i32,
24866    a: &mut [f32],
24867    lda: i32,
24868    sva: &mut [f32],
24869    mv: &[i32],
24870    v: &mut [f32],
24871    ldv: i32,
24872    work: &mut [f32],
24873    lwork: i32,
24874    info: &mut i32,
24875) {
24876    ffi::sgesvj_(
24877        &(joba as c_char),
24878        &(jobu as c_char),
24879        &(jobv as c_char),
24880        &m,
24881        &n,
24882        a.as_mut_ptr(),
24883        &lda,
24884        sva.as_mut_ptr(),
24885        mv.as_ptr(),
24886        v.as_mut_ptr(),
24887        &ldv,
24888        work.as_mut_ptr(),
24889        &lwork,
24890        info,
24891    )
24892}
24893
24894#[inline]
24895pub unsafe fn cgesvj(
24896    joba: u8,
24897    jobu: u8,
24898    jobv: u8,
24899    m: i32,
24900    n: i32,
24901    a: &mut [c32],
24902    lda: i32,
24903    sva: &mut [f32],
24904    mv: &[i32],
24905    v: &mut [c32],
24906    ldv: i32,
24907    cwork: &mut [c32],
24908    lwork: i32,
24909    rwork: &mut [f32],
24910    lrwork: i32,
24911    info: &mut i32,
24912) {
24913    ffi::cgesvj_(
24914        &(joba as c_char),
24915        &(jobu as c_char),
24916        &(jobv as c_char),
24917        &m,
24918        &n,
24919        a.as_mut_ptr() as *mut _,
24920        &lda,
24921        sva.as_mut_ptr(),
24922        mv.as_ptr(),
24923        v.as_mut_ptr() as *mut _,
24924        &ldv,
24925        cwork.as_mut_ptr() as *mut _,
24926        &lwork,
24927        rwork.as_mut_ptr(),
24928        &lrwork,
24929        info,
24930    )
24931}
24932
24933#[inline]
24934pub unsafe fn zgesvj(
24935    joba: u8,
24936    jobu: u8,
24937    jobv: u8,
24938    m: i32,
24939    n: i32,
24940    a: &mut [c64],
24941    lda: i32,
24942    sva: &mut [f64],
24943    mv: &[i32],
24944    v: &mut [c64],
24945    ldv: i32,
24946    cwork: &mut [c64],
24947    lwork: i32,
24948    rwork: &mut [f64],
24949    lrwork: i32,
24950    info: &mut i32,
24951) {
24952    ffi::zgesvj_(
24953        &(joba as c_char),
24954        &(jobu as c_char),
24955        &(jobv as c_char),
24956        &m,
24957        &n,
24958        a.as_mut_ptr() as *mut _,
24959        &lda,
24960        sva.as_mut_ptr(),
24961        mv.as_ptr(),
24962        v.as_mut_ptr() as *mut _,
24963        &ldv,
24964        cwork.as_mut_ptr() as *mut _,
24965        &lwork,
24966        rwork.as_mut_ptr(),
24967        &lrwork,
24968        info,
24969    )
24970}
24971
24972#[inline]
24973pub unsafe fn sggsvd(
24974    jobu: u8,
24975    jobv: u8,
24976    jobq: u8,
24977    m: i32,
24978    n: i32,
24979    p: i32,
24980    k: &mut i32,
24981    l: &mut i32,
24982    a: &mut [f32],
24983    lda: i32,
24984    b: &mut [f32],
24985    ldb: i32,
24986    alpha: &mut f32,
24987    beta: &mut f32,
24988    u: &mut [f32],
24989    ldu: i32,
24990    v: &mut [f32],
24991    ldv: i32,
24992    q: &mut [f32],
24993    ldq: i32,
24994    work: &mut [f32],
24995    iwork: &mut [i32],
24996    info: &mut i32,
24997) {
24998    ffi::sggsvd_(
24999        &(jobu as c_char),
25000        &(jobv as c_char),
25001        &(jobq as c_char),
25002        &m,
25003        &n,
25004        &p,
25005        k,
25006        l,
25007        a.as_mut_ptr(),
25008        &lda,
25009        b.as_mut_ptr(),
25010        &ldb,
25011        alpha,
25012        beta,
25013        u.as_mut_ptr(),
25014        &ldu,
25015        v.as_mut_ptr(),
25016        &ldv,
25017        q.as_mut_ptr(),
25018        &ldq,
25019        work.as_mut_ptr(),
25020        iwork.as_mut_ptr(),
25021        info,
25022    )
25023}
25024
25025#[inline]
25026pub unsafe fn dggsvd(
25027    jobu: u8,
25028    jobv: u8,
25029    jobq: u8,
25030    m: i32,
25031    n: i32,
25032    p: i32,
25033    k: &mut i32,
25034    l: &mut i32,
25035    a: &mut [f64],
25036    lda: i32,
25037    b: &mut [f64],
25038    ldb: i32,
25039    alpha: &mut f64,
25040    beta: &mut f64,
25041    u: &mut [f64],
25042    ldu: i32,
25043    v: &mut [f64],
25044    ldv: i32,
25045    q: &mut [f64],
25046    ldq: i32,
25047    work: &mut [f64],
25048    iwork: &mut [i32],
25049    info: &mut i32,
25050) {
25051    ffi::dggsvd_(
25052        &(jobu as c_char),
25053        &(jobv as c_char),
25054        &(jobq as c_char),
25055        &m,
25056        &n,
25057        &p,
25058        k,
25059        l,
25060        a.as_mut_ptr(),
25061        &lda,
25062        b.as_mut_ptr(),
25063        &ldb,
25064        alpha,
25065        beta,
25066        u.as_mut_ptr(),
25067        &ldu,
25068        v.as_mut_ptr(),
25069        &ldv,
25070        q.as_mut_ptr(),
25071        &ldq,
25072        work.as_mut_ptr(),
25073        iwork.as_mut_ptr(),
25074        info,
25075    )
25076}
25077
25078#[inline]
25079pub unsafe fn cggsvd(
25080    jobu: u8,
25081    jobv: u8,
25082    jobq: u8,
25083    m: i32,
25084    n: i32,
25085    p: i32,
25086    k: &mut i32,
25087    l: &mut i32,
25088    a: &mut [c32],
25089    lda: i32,
25090    b: &mut [c32],
25091    ldb: i32,
25092    alpha: &mut f32,
25093    beta: &mut f32,
25094    u: &mut [c32],
25095    ldu: i32,
25096    v: &mut [c32],
25097    ldv: i32,
25098    q: &mut [c32],
25099    ldq: i32,
25100    work: &mut [c32],
25101    rwork: &mut [f32],
25102    iwork: &mut [i32],
25103    info: &mut i32,
25104) {
25105    ffi::cggsvd_(
25106        &(jobu as c_char),
25107        &(jobv as c_char),
25108        &(jobq as c_char),
25109        &m,
25110        &n,
25111        &p,
25112        k,
25113        l,
25114        a.as_mut_ptr() as *mut _,
25115        &lda,
25116        b.as_mut_ptr() as *mut _,
25117        &ldb,
25118        alpha,
25119        beta,
25120        u.as_mut_ptr() as *mut _,
25121        &ldu,
25122        v.as_mut_ptr() as *mut _,
25123        &ldv,
25124        q.as_mut_ptr() as *mut _,
25125        &ldq,
25126        work.as_mut_ptr() as *mut _,
25127        rwork.as_mut_ptr(),
25128        iwork.as_mut_ptr(),
25129        info,
25130    )
25131}
25132
25133#[inline]
25134pub unsafe fn zggsvd(
25135    jobu: u8,
25136    jobv: u8,
25137    jobq: u8,
25138    m: i32,
25139    n: i32,
25140    p: i32,
25141    k: &mut i32,
25142    l: &mut i32,
25143    a: &mut [c64],
25144    lda: i32,
25145    b: &mut [c64],
25146    ldb: i32,
25147    alpha: &mut f64,
25148    beta: &mut f64,
25149    u: &mut [c64],
25150    ldu: i32,
25151    v: &mut [c64],
25152    ldv: i32,
25153    q: &mut [c64],
25154    ldq: i32,
25155    work: &mut [c64],
25156    rwork: &mut [f64],
25157    iwork: &mut [i32],
25158    info: &mut i32,
25159) {
25160    ffi::zggsvd_(
25161        &(jobu as c_char),
25162        &(jobv as c_char),
25163        &(jobq as c_char),
25164        &m,
25165        &n,
25166        &p,
25167        k,
25168        l,
25169        a.as_mut_ptr() as *mut _,
25170        &lda,
25171        b.as_mut_ptr() as *mut _,
25172        &ldb,
25173        alpha,
25174        beta,
25175        u.as_mut_ptr() as *mut _,
25176        &ldu,
25177        v.as_mut_ptr() as *mut _,
25178        &ldv,
25179        q.as_mut_ptr() as *mut _,
25180        &ldq,
25181        work.as_mut_ptr() as *mut _,
25182        rwork.as_mut_ptr(),
25183        iwork.as_mut_ptr(),
25184        info,
25185    )
25186}
25187
25188#[inline]
25189pub unsafe fn sggsvd3(
25190    jobu: u8,
25191    jobv: u8,
25192    jobq: u8,
25193    m: i32,
25194    n: i32,
25195    p: i32,
25196    k: &mut i32,
25197    l: &mut i32,
25198    a: &mut [f32],
25199    lda: i32,
25200    b: &mut [f32],
25201    ldb: i32,
25202    alpha: &mut f32,
25203    beta: &mut f32,
25204    u: &mut [f32],
25205    ldu: i32,
25206    v: &mut [f32],
25207    ldv: i32,
25208    q: &mut [f32],
25209    ldq: i32,
25210    work: &mut [f32],
25211    lwork: i32,
25212    iwork: &mut [i32],
25213    info: &mut i32,
25214) {
25215    ffi::sggsvd3_(
25216        &(jobu as c_char),
25217        &(jobv as c_char),
25218        &(jobq as c_char),
25219        &m,
25220        &n,
25221        &p,
25222        k,
25223        l,
25224        a.as_mut_ptr(),
25225        &lda,
25226        b.as_mut_ptr(),
25227        &ldb,
25228        alpha,
25229        beta,
25230        u.as_mut_ptr(),
25231        &ldu,
25232        v.as_mut_ptr(),
25233        &ldv,
25234        q.as_mut_ptr(),
25235        &ldq,
25236        work.as_mut_ptr(),
25237        &lwork,
25238        iwork.as_mut_ptr(),
25239        info,
25240    )
25241}
25242
25243#[inline]
25244pub unsafe fn dggsvd3(
25245    jobu: u8,
25246    jobv: u8,
25247    jobq: u8,
25248    m: i32,
25249    n: i32,
25250    p: i32,
25251    k: &mut i32,
25252    l: &mut i32,
25253    a: &mut [f64],
25254    lda: i32,
25255    b: &mut [f64],
25256    ldb: i32,
25257    alpha: &mut f64,
25258    beta: &mut f64,
25259    u: &mut [f64],
25260    ldu: i32,
25261    v: &mut [f64],
25262    ldv: i32,
25263    q: &mut [f64],
25264    ldq: i32,
25265    work: &mut [f64],
25266    lwork: i32,
25267    iwork: &mut [i32],
25268    info: &mut i32,
25269) {
25270    ffi::dggsvd3_(
25271        &(jobu as c_char),
25272        &(jobv as c_char),
25273        &(jobq as c_char),
25274        &m,
25275        &n,
25276        &p,
25277        k,
25278        l,
25279        a.as_mut_ptr(),
25280        &lda,
25281        b.as_mut_ptr(),
25282        &ldb,
25283        alpha,
25284        beta,
25285        u.as_mut_ptr(),
25286        &ldu,
25287        v.as_mut_ptr(),
25288        &ldv,
25289        q.as_mut_ptr(),
25290        &ldq,
25291        work.as_mut_ptr(),
25292        &lwork,
25293        iwork.as_mut_ptr(),
25294        info,
25295    )
25296}
25297
25298#[inline]
25299pub unsafe fn cggsvd3(
25300    jobu: u8,
25301    jobv: u8,
25302    jobq: u8,
25303    m: i32,
25304    n: i32,
25305    p: i32,
25306    k: &mut i32,
25307    l: &mut i32,
25308    a: &mut [c32],
25309    lda: i32,
25310    b: &mut [c32],
25311    ldb: i32,
25312    alpha: &mut f32,
25313    beta: &mut f32,
25314    u: &mut [c32],
25315    ldu: i32,
25316    v: &mut [c32],
25317    ldv: i32,
25318    q: &mut [c32],
25319    ldq: i32,
25320    work: &mut [c32],
25321    lwork: i32,
25322    rwork: &mut [f32],
25323    iwork: &mut [i32],
25324    info: &mut i32,
25325) {
25326    ffi::cggsvd3_(
25327        &(jobu as c_char),
25328        &(jobv as c_char),
25329        &(jobq as c_char),
25330        &m,
25331        &n,
25332        &p,
25333        k,
25334        l,
25335        a.as_mut_ptr() as *mut _,
25336        &lda,
25337        b.as_mut_ptr() as *mut _,
25338        &ldb,
25339        alpha,
25340        beta,
25341        u.as_mut_ptr() as *mut _,
25342        &ldu,
25343        v.as_mut_ptr() as *mut _,
25344        &ldv,
25345        q.as_mut_ptr() as *mut _,
25346        &ldq,
25347        work.as_mut_ptr() as *mut _,
25348        &lwork,
25349        rwork.as_mut_ptr(),
25350        iwork.as_mut_ptr(),
25351        info,
25352    )
25353}
25354
25355#[inline]
25356pub unsafe fn zggsvd3(
25357    jobu: u8,
25358    jobv: u8,
25359    jobq: u8,
25360    m: i32,
25361    n: i32,
25362    p: i32,
25363    k: &mut i32,
25364    l: &mut i32,
25365    a: &mut [c64],
25366    lda: i32,
25367    b: &mut [c64],
25368    ldb: i32,
25369    alpha: &mut f64,
25370    beta: &mut f64,
25371    u: &mut [c64],
25372    ldu: i32,
25373    v: &mut [c64],
25374    ldv: i32,
25375    q: &mut [c64],
25376    ldq: i32,
25377    work: &mut [c64],
25378    lwork: i32,
25379    rwork: &mut [f64],
25380    iwork: &mut [i32],
25381    info: &mut i32,
25382) {
25383    ffi::zggsvd3_(
25384        &(jobu as c_char),
25385        &(jobv as c_char),
25386        &(jobq as c_char),
25387        &m,
25388        &n,
25389        &p,
25390        k,
25391        l,
25392        a.as_mut_ptr() as *mut _,
25393        &lda,
25394        b.as_mut_ptr() as *mut _,
25395        &ldb,
25396        alpha,
25397        beta,
25398        u.as_mut_ptr() as *mut _,
25399        &ldu,
25400        v.as_mut_ptr() as *mut _,
25401        &ldv,
25402        q.as_mut_ptr() as *mut _,
25403        &ldq,
25404        work.as_mut_ptr() as *mut _,
25405        &lwork,
25406        rwork.as_mut_ptr(),
25407        iwork.as_mut_ptr(),
25408        info,
25409    )
25410}
25411
25412#[inline]
25413pub unsafe fn ssygv(
25414    itype: &[i32],
25415    jobz: u8,
25416    uplo: u8,
25417    n: i32,
25418    a: &mut [f32],
25419    lda: i32,
25420    b: &mut [f32],
25421    ldb: i32,
25422    w: &mut [f32],
25423    work: &mut [f32],
25424    lwork: i32,
25425    info: &mut i32,
25426) {
25427    ffi::ssygv_(
25428        itype.as_ptr(),
25429        &(jobz as c_char),
25430        &(uplo as c_char),
25431        &n,
25432        a.as_mut_ptr(),
25433        &lda,
25434        b.as_mut_ptr(),
25435        &ldb,
25436        w.as_mut_ptr(),
25437        work.as_mut_ptr(),
25438        &lwork,
25439        info,
25440    )
25441}
25442
25443#[inline]
25444pub unsafe fn dsygv(
25445    itype: &[i32],
25446    jobz: u8,
25447    uplo: u8,
25448    n: i32,
25449    a: &mut [f64],
25450    lda: i32,
25451    b: &mut [f64],
25452    ldb: i32,
25453    w: &mut [f64],
25454    work: &mut [f64],
25455    lwork: i32,
25456    info: &mut i32,
25457) {
25458    ffi::dsygv_(
25459        itype.as_ptr(),
25460        &(jobz as c_char),
25461        &(uplo as c_char),
25462        &n,
25463        a.as_mut_ptr(),
25464        &lda,
25465        b.as_mut_ptr(),
25466        &ldb,
25467        w.as_mut_ptr(),
25468        work.as_mut_ptr(),
25469        &lwork,
25470        info,
25471    )
25472}
25473
25474#[inline]
25475pub unsafe fn chegv(
25476    itype: &[i32],
25477    jobz: u8,
25478    uplo: u8,
25479    n: i32,
25480    a: &mut [c32],
25481    lda: i32,
25482    b: &mut [c32],
25483    ldb: i32,
25484    w: &mut [f32],
25485    work: &mut [c32],
25486    lwork: i32,
25487    rwork: &mut [f32],
25488    info: &mut i32,
25489) {
25490    ffi::chegv_(
25491        itype.as_ptr(),
25492        &(jobz as c_char),
25493        &(uplo as c_char),
25494        &n,
25495        a.as_mut_ptr() as *mut _,
25496        &lda,
25497        b.as_mut_ptr() as *mut _,
25498        &ldb,
25499        w.as_mut_ptr(),
25500        work.as_mut_ptr() as *mut _,
25501        &lwork,
25502        rwork.as_mut_ptr(),
25503        info,
25504    )
25505}
25506
25507#[inline]
25508pub unsafe fn zhegv(
25509    itype: &[i32],
25510    jobz: u8,
25511    uplo: u8,
25512    n: i32,
25513    a: &mut [c64],
25514    lda: i32,
25515    b: &mut [c64],
25516    ldb: i32,
25517    w: &mut [f64],
25518    work: &mut [c64],
25519    lwork: i32,
25520    rwork: &mut [f64],
25521    info: &mut i32,
25522) {
25523    ffi::zhegv_(
25524        itype.as_ptr(),
25525        &(jobz as c_char),
25526        &(uplo as c_char),
25527        &n,
25528        a.as_mut_ptr() as *mut _,
25529        &lda,
25530        b.as_mut_ptr() as *mut _,
25531        &ldb,
25532        w.as_mut_ptr(),
25533        work.as_mut_ptr() as *mut _,
25534        &lwork,
25535        rwork.as_mut_ptr(),
25536        info,
25537    )
25538}
25539
25540#[inline]
25541pub unsafe fn ssygvd(
25542    itype: &[i32],
25543    jobz: u8,
25544    uplo: u8,
25545    n: i32,
25546    a: &mut [f32],
25547    lda: i32,
25548    b: &mut [f32],
25549    ldb: i32,
25550    w: &mut [f32],
25551    work: &mut [f32],
25552    lwork: i32,
25553    iwork: &mut [i32],
25554    liwork: i32,
25555    info: &mut i32,
25556) {
25557    ffi::ssygvd_(
25558        itype.as_ptr(),
25559        &(jobz as c_char),
25560        &(uplo as c_char),
25561        &n,
25562        a.as_mut_ptr(),
25563        &lda,
25564        b.as_mut_ptr(),
25565        &ldb,
25566        w.as_mut_ptr(),
25567        work.as_mut_ptr(),
25568        &lwork,
25569        iwork.as_mut_ptr(),
25570        &liwork,
25571        info,
25572    )
25573}
25574
25575#[inline]
25576pub unsafe fn dsygvd(
25577    itype: &[i32],
25578    jobz: u8,
25579    uplo: u8,
25580    n: i32,
25581    a: &mut [f64],
25582    lda: i32,
25583    b: &mut [f64],
25584    ldb: i32,
25585    w: &mut [f64],
25586    work: &mut [f64],
25587    lwork: i32,
25588    iwork: &mut [i32],
25589    liwork: i32,
25590    info: &mut i32,
25591) {
25592    ffi::dsygvd_(
25593        itype.as_ptr(),
25594        &(jobz as c_char),
25595        &(uplo as c_char),
25596        &n,
25597        a.as_mut_ptr(),
25598        &lda,
25599        b.as_mut_ptr(),
25600        &ldb,
25601        w.as_mut_ptr(),
25602        work.as_mut_ptr(),
25603        &lwork,
25604        iwork.as_mut_ptr(),
25605        &liwork,
25606        info,
25607    )
25608}
25609
25610#[inline]
25611pub unsafe fn chegvd(
25612    itype: &[i32],
25613    jobz: u8,
25614    uplo: u8,
25615    n: i32,
25616    a: &mut [c32],
25617    lda: i32,
25618    b: &mut [c32],
25619    ldb: i32,
25620    w: &mut [f32],
25621    work: &mut [c32],
25622    lwork: i32,
25623    rwork: &mut [f32],
25624    lrwork: i32,
25625    iwork: &mut [i32],
25626    liwork: i32,
25627    info: &mut i32,
25628) {
25629    ffi::chegvd_(
25630        itype.as_ptr(),
25631        &(jobz as c_char),
25632        &(uplo as c_char),
25633        &n,
25634        a.as_mut_ptr() as *mut _,
25635        &lda,
25636        b.as_mut_ptr() as *mut _,
25637        &ldb,
25638        w.as_mut_ptr(),
25639        work.as_mut_ptr() as *mut _,
25640        &lwork,
25641        rwork.as_mut_ptr(),
25642        &lrwork,
25643        iwork.as_mut_ptr(),
25644        &liwork,
25645        info,
25646    )
25647}
25648
25649#[inline]
25650pub unsafe fn zhegvd(
25651    itype: &[i32],
25652    jobz: u8,
25653    uplo: u8,
25654    n: i32,
25655    a: &mut [c64],
25656    lda: i32,
25657    b: &mut [c64],
25658    ldb: i32,
25659    w: &mut [f64],
25660    work: &mut [c64],
25661    lwork: i32,
25662    rwork: &mut [f64],
25663    lrwork: i32,
25664    iwork: &mut [i32],
25665    liwork: i32,
25666    info: &mut i32,
25667) {
25668    ffi::zhegvd_(
25669        itype.as_ptr(),
25670        &(jobz as c_char),
25671        &(uplo as c_char),
25672        &n,
25673        a.as_mut_ptr() as *mut _,
25674        &lda,
25675        b.as_mut_ptr() as *mut _,
25676        &ldb,
25677        w.as_mut_ptr(),
25678        work.as_mut_ptr() as *mut _,
25679        &lwork,
25680        rwork.as_mut_ptr(),
25681        &lrwork,
25682        iwork.as_mut_ptr(),
25683        &liwork,
25684        info,
25685    )
25686}
25687
25688#[inline]
25689pub unsafe fn ssygvx(
25690    itype: &[i32],
25691    jobz: u8,
25692    range: u8,
25693    uplo: u8,
25694    n: i32,
25695    a: &mut [f32],
25696    lda: i32,
25697    b: &mut [f32],
25698    ldb: i32,
25699    vl: f32,
25700    vu: f32,
25701    il: i32,
25702    iu: i32,
25703    abstol: f32,
25704    m: &mut i32,
25705    w: &mut [f32],
25706    z: &mut [f32],
25707    ldz: i32,
25708    work: &mut [f32],
25709    lwork: i32,
25710    iwork: &mut [i32],
25711    ifail: &mut [i32],
25712    info: &mut i32,
25713) {
25714    ffi::ssygvx_(
25715        itype.as_ptr(),
25716        &(jobz as c_char),
25717        &(range as c_char),
25718        &(uplo as c_char),
25719        &n,
25720        a.as_mut_ptr(),
25721        &lda,
25722        b.as_mut_ptr(),
25723        &ldb,
25724        &vl,
25725        &vu,
25726        &il,
25727        &iu,
25728        &abstol,
25729        m,
25730        w.as_mut_ptr(),
25731        z.as_mut_ptr(),
25732        &ldz,
25733        work.as_mut_ptr(),
25734        &lwork,
25735        iwork.as_mut_ptr(),
25736        ifail.as_mut_ptr(),
25737        info,
25738    )
25739}
25740
25741#[inline]
25742pub unsafe fn dsygvx(
25743    itype: &[i32],
25744    jobz: u8,
25745    range: u8,
25746    uplo: u8,
25747    n: i32,
25748    a: &mut [f64],
25749    lda: i32,
25750    b: &mut [f64],
25751    ldb: i32,
25752    vl: f64,
25753    vu: f64,
25754    il: i32,
25755    iu: i32,
25756    abstol: f64,
25757    m: &mut i32,
25758    w: &mut [f64],
25759    z: &mut [f64],
25760    ldz: i32,
25761    work: &mut [f64],
25762    lwork: i32,
25763    iwork: &mut [i32],
25764    ifail: &mut [i32],
25765    info: &mut i32,
25766) {
25767    ffi::dsygvx_(
25768        itype.as_ptr(),
25769        &(jobz as c_char),
25770        &(range as c_char),
25771        &(uplo as c_char),
25772        &n,
25773        a.as_mut_ptr(),
25774        &lda,
25775        b.as_mut_ptr(),
25776        &ldb,
25777        &vl,
25778        &vu,
25779        &il,
25780        &iu,
25781        &abstol,
25782        m,
25783        w.as_mut_ptr(),
25784        z.as_mut_ptr(),
25785        &ldz,
25786        work.as_mut_ptr(),
25787        &lwork,
25788        iwork.as_mut_ptr(),
25789        ifail.as_mut_ptr(),
25790        info,
25791    )
25792}
25793
25794#[inline]
25795pub unsafe fn chegvx(
25796    itype: &[i32],
25797    jobz: u8,
25798    range: u8,
25799    uplo: u8,
25800    n: i32,
25801    a: &mut [c32],
25802    lda: i32,
25803    b: &mut [c32],
25804    ldb: i32,
25805    vl: f32,
25806    vu: f32,
25807    il: i32,
25808    iu: i32,
25809    abstol: f32,
25810    m: &mut i32,
25811    w: &mut [f32],
25812    z: &mut [c32],
25813    ldz: i32,
25814    work: &mut [c32],
25815    lwork: i32,
25816    rwork: &mut [f32],
25817    iwork: &mut [i32],
25818    ifail: &mut [i32],
25819    info: &mut i32,
25820) {
25821    ffi::chegvx_(
25822        itype.as_ptr(),
25823        &(jobz as c_char),
25824        &(range as c_char),
25825        &(uplo as c_char),
25826        &n,
25827        a.as_mut_ptr() as *mut _,
25828        &lda,
25829        b.as_mut_ptr() as *mut _,
25830        &ldb,
25831        &vl,
25832        &vu,
25833        &il,
25834        &iu,
25835        &abstol,
25836        m,
25837        w.as_mut_ptr(),
25838        z.as_mut_ptr() as *mut _,
25839        &ldz,
25840        work.as_mut_ptr() as *mut _,
25841        &lwork,
25842        rwork.as_mut_ptr(),
25843        iwork.as_mut_ptr(),
25844        ifail.as_mut_ptr(),
25845        info,
25846    )
25847}
25848
25849#[inline]
25850pub unsafe fn zhegvx(
25851    itype: &[i32],
25852    jobz: u8,
25853    range: u8,
25854    uplo: u8,
25855    n: i32,
25856    a: &mut [c64],
25857    lda: i32,
25858    b: &mut [c64],
25859    ldb: i32,
25860    vl: f64,
25861    vu: f64,
25862    il: i32,
25863    iu: i32,
25864    abstol: f64,
25865    m: &mut i32,
25866    w: &mut [f64],
25867    z: &mut [c64],
25868    ldz: i32,
25869    work: &mut [c64],
25870    lwork: i32,
25871    rwork: &mut [f64],
25872    iwork: &mut [i32],
25873    ifail: &mut [i32],
25874    info: &mut i32,
25875) {
25876    ffi::zhegvx_(
25877        itype.as_ptr(),
25878        &(jobz as c_char),
25879        &(range as c_char),
25880        &(uplo as c_char),
25881        &n,
25882        a.as_mut_ptr() as *mut _,
25883        &lda,
25884        b.as_mut_ptr() as *mut _,
25885        &ldb,
25886        &vl,
25887        &vu,
25888        &il,
25889        &iu,
25890        &abstol,
25891        m,
25892        w.as_mut_ptr(),
25893        z.as_mut_ptr() as *mut _,
25894        &ldz,
25895        work.as_mut_ptr() as *mut _,
25896        &lwork,
25897        rwork.as_mut_ptr(),
25898        iwork.as_mut_ptr(),
25899        ifail.as_mut_ptr(),
25900        info,
25901    )
25902}
25903
25904#[inline]
25905pub unsafe fn sspgv(
25906    itype: &[i32],
25907    jobz: u8,
25908    uplo: u8,
25909    n: i32,
25910    ap: &mut [f32],
25911    bp: &mut [f32],
25912    w: &mut [f32],
25913    z: &mut [f32],
25914    ldz: i32,
25915    work: &mut [f32],
25916    info: &mut i32,
25917) {
25918    ffi::sspgv_(
25919        itype.as_ptr(),
25920        &(jobz as c_char),
25921        &(uplo as c_char),
25922        &n,
25923        ap.as_mut_ptr(),
25924        bp.as_mut_ptr(),
25925        w.as_mut_ptr(),
25926        z.as_mut_ptr(),
25927        &ldz,
25928        work.as_mut_ptr(),
25929        info,
25930    )
25931}
25932
25933#[inline]
25934pub unsafe fn dspgv(
25935    itype: &[i32],
25936    jobz: u8,
25937    uplo: u8,
25938    n: i32,
25939    ap: &mut [f64],
25940    bp: &mut [f64],
25941    w: &mut [f64],
25942    z: &mut [f64],
25943    ldz: i32,
25944    work: &mut [f64],
25945    info: &mut i32,
25946) {
25947    ffi::dspgv_(
25948        itype.as_ptr(),
25949        &(jobz as c_char),
25950        &(uplo as c_char),
25951        &n,
25952        ap.as_mut_ptr(),
25953        bp.as_mut_ptr(),
25954        w.as_mut_ptr(),
25955        z.as_mut_ptr(),
25956        &ldz,
25957        work.as_mut_ptr(),
25958        info,
25959    )
25960}
25961
25962#[inline]
25963pub unsafe fn chpgv(
25964    itype: &[i32],
25965    jobz: u8,
25966    uplo: u8,
25967    n: i32,
25968    ap: &mut [c32],
25969    bp: &mut [c32],
25970    w: &mut [f32],
25971    z: &mut [c32],
25972    ldz: i32,
25973    work: &mut [c32],
25974    rwork: &mut [f32],
25975    info: &mut i32,
25976) {
25977    ffi::chpgv_(
25978        itype.as_ptr(),
25979        &(jobz as c_char),
25980        &(uplo as c_char),
25981        &n,
25982        ap.as_mut_ptr() as *mut _,
25983        bp.as_mut_ptr() as *mut _,
25984        w.as_mut_ptr(),
25985        z.as_mut_ptr() as *mut _,
25986        &ldz,
25987        work.as_mut_ptr() as *mut _,
25988        rwork.as_mut_ptr(),
25989        info,
25990    )
25991}
25992
25993#[inline]
25994pub unsafe fn zhpgv(
25995    itype: &[i32],
25996    jobz: u8,
25997    uplo: u8,
25998    n: i32,
25999    ap: &mut [c64],
26000    bp: &mut [c64],
26001    w: &mut [f64],
26002    z: &mut [c64],
26003    ldz: i32,
26004    work: &mut [c64],
26005    rwork: &mut [f64],
26006    info: &mut i32,
26007) {
26008    ffi::zhpgv_(
26009        itype.as_ptr(),
26010        &(jobz as c_char),
26011        &(uplo as c_char),
26012        &n,
26013        ap.as_mut_ptr() as *mut _,
26014        bp.as_mut_ptr() as *mut _,
26015        w.as_mut_ptr(),
26016        z.as_mut_ptr() as *mut _,
26017        &ldz,
26018        work.as_mut_ptr() as *mut _,
26019        rwork.as_mut_ptr(),
26020        info,
26021    )
26022}
26023
26024#[inline]
26025pub unsafe fn sspgvd(
26026    itype: &[i32],
26027    jobz: u8,
26028    uplo: u8,
26029    n: i32,
26030    ap: &mut [f32],
26031    bp: &mut [f32],
26032    w: &mut [f32],
26033    z: &mut [f32],
26034    ldz: i32,
26035    work: &mut [f32],
26036    lwork: i32,
26037    iwork: &mut [i32],
26038    liwork: i32,
26039    info: &mut i32,
26040) {
26041    ffi::sspgvd_(
26042        itype.as_ptr(),
26043        &(jobz as c_char),
26044        &(uplo as c_char),
26045        &n,
26046        ap.as_mut_ptr(),
26047        bp.as_mut_ptr(),
26048        w.as_mut_ptr(),
26049        z.as_mut_ptr(),
26050        &ldz,
26051        work.as_mut_ptr(),
26052        &lwork,
26053        iwork.as_mut_ptr(),
26054        &liwork,
26055        info,
26056    )
26057}
26058
26059#[inline]
26060pub unsafe fn dspgvd(
26061    itype: &[i32],
26062    jobz: u8,
26063    uplo: u8,
26064    n: i32,
26065    ap: &mut [f64],
26066    bp: &mut [f64],
26067    w: &mut [f64],
26068    z: &mut [f64],
26069    ldz: i32,
26070    work: &mut [f64],
26071    lwork: i32,
26072    iwork: &mut [i32],
26073    liwork: i32,
26074    info: &mut i32,
26075) {
26076    ffi::dspgvd_(
26077        itype.as_ptr(),
26078        &(jobz as c_char),
26079        &(uplo as c_char),
26080        &n,
26081        ap.as_mut_ptr(),
26082        bp.as_mut_ptr(),
26083        w.as_mut_ptr(),
26084        z.as_mut_ptr(),
26085        &ldz,
26086        work.as_mut_ptr(),
26087        &lwork,
26088        iwork.as_mut_ptr(),
26089        &liwork,
26090        info,
26091    )
26092}
26093
26094#[inline]
26095pub unsafe fn chpgvd(
26096    itype: &[i32],
26097    jobz: u8,
26098    uplo: u8,
26099    n: i32,
26100    ap: &mut [c32],
26101    bp: &mut [c32],
26102    w: &mut [f32],
26103    z: &mut [c32],
26104    ldz: i32,
26105    work: &mut [c32],
26106    lwork: i32,
26107    rwork: &mut [f32],
26108    lrwork: i32,
26109    iwork: &mut [i32],
26110    liwork: i32,
26111    info: &mut i32,
26112) {
26113    ffi::chpgvd_(
26114        itype.as_ptr(),
26115        &(jobz as c_char),
26116        &(uplo as c_char),
26117        &n,
26118        ap.as_mut_ptr() as *mut _,
26119        bp.as_mut_ptr() as *mut _,
26120        w.as_mut_ptr(),
26121        z.as_mut_ptr() as *mut _,
26122        &ldz,
26123        work.as_mut_ptr() as *mut _,
26124        &lwork,
26125        rwork.as_mut_ptr(),
26126        &lrwork,
26127        iwork.as_mut_ptr(),
26128        &liwork,
26129        info,
26130    )
26131}
26132
26133#[inline]
26134pub unsafe fn zhpgvd(
26135    itype: &[i32],
26136    jobz: u8,
26137    uplo: u8,
26138    n: i32,
26139    ap: &mut [c64],
26140    bp: &mut [c64],
26141    w: &mut [f64],
26142    z: &mut [c64],
26143    ldz: i32,
26144    work: &mut [c64],
26145    lwork: i32,
26146    rwork: &mut [f64],
26147    lrwork: i32,
26148    iwork: &mut [i32],
26149    liwork: i32,
26150    info: &mut i32,
26151) {
26152    ffi::zhpgvd_(
26153        itype.as_ptr(),
26154        &(jobz as c_char),
26155        &(uplo as c_char),
26156        &n,
26157        ap.as_mut_ptr() as *mut _,
26158        bp.as_mut_ptr() as *mut _,
26159        w.as_mut_ptr(),
26160        z.as_mut_ptr() as *mut _,
26161        &ldz,
26162        work.as_mut_ptr() as *mut _,
26163        &lwork,
26164        rwork.as_mut_ptr(),
26165        &lrwork,
26166        iwork.as_mut_ptr(),
26167        &liwork,
26168        info,
26169    )
26170}
26171
26172#[inline]
26173pub unsafe fn sspgvx(
26174    itype: &[i32],
26175    jobz: u8,
26176    range: u8,
26177    uplo: u8,
26178    n: i32,
26179    ap: &mut [f32],
26180    bp: &mut [f32],
26181    vl: f32,
26182    vu: f32,
26183    il: i32,
26184    iu: i32,
26185    abstol: f32,
26186    m: &mut i32,
26187    w: &mut [f32],
26188    z: &mut [f32],
26189    ldz: i32,
26190    work: &mut [f32],
26191    iwork: &mut [i32],
26192    ifail: &mut [i32],
26193    info: &mut i32,
26194) {
26195    ffi::sspgvx_(
26196        itype.as_ptr(),
26197        &(jobz as c_char),
26198        &(range as c_char),
26199        &(uplo as c_char),
26200        &n,
26201        ap.as_mut_ptr(),
26202        bp.as_mut_ptr(),
26203        &vl,
26204        &vu,
26205        &il,
26206        &iu,
26207        &abstol,
26208        m,
26209        w.as_mut_ptr(),
26210        z.as_mut_ptr(),
26211        &ldz,
26212        work.as_mut_ptr(),
26213        iwork.as_mut_ptr(),
26214        ifail.as_mut_ptr(),
26215        info,
26216    )
26217}
26218
26219#[inline]
26220pub unsafe fn dspgvx(
26221    itype: &[i32],
26222    jobz: u8,
26223    range: u8,
26224    uplo: u8,
26225    n: i32,
26226    ap: &mut [f64],
26227    bp: &mut [f64],
26228    vl: f64,
26229    vu: f64,
26230    il: i32,
26231    iu: i32,
26232    abstol: f64,
26233    m: &mut i32,
26234    w: &mut [f64],
26235    z: &mut [f64],
26236    ldz: i32,
26237    work: &mut [f64],
26238    iwork: &mut [i32],
26239    ifail: &mut [i32],
26240    info: &mut i32,
26241) {
26242    ffi::dspgvx_(
26243        itype.as_ptr(),
26244        &(jobz as c_char),
26245        &(range as c_char),
26246        &(uplo as c_char),
26247        &n,
26248        ap.as_mut_ptr(),
26249        bp.as_mut_ptr(),
26250        &vl,
26251        &vu,
26252        &il,
26253        &iu,
26254        &abstol,
26255        m,
26256        w.as_mut_ptr(),
26257        z.as_mut_ptr(),
26258        &ldz,
26259        work.as_mut_ptr(),
26260        iwork.as_mut_ptr(),
26261        ifail.as_mut_ptr(),
26262        info,
26263    )
26264}
26265
26266#[inline]
26267pub unsafe fn chpgvx(
26268    itype: &[i32],
26269    jobz: u8,
26270    range: u8,
26271    uplo: u8,
26272    n: i32,
26273    ap: &mut [c32],
26274    bp: &mut [c32],
26275    vl: f32,
26276    vu: f32,
26277    il: i32,
26278    iu: i32,
26279    abstol: f32,
26280    m: &mut i32,
26281    w: &mut [f32],
26282    z: &mut [c32],
26283    ldz: i32,
26284    work: &mut [c32],
26285    rwork: &mut [f32],
26286    iwork: &mut [i32],
26287    ifail: &mut [i32],
26288    info: &mut i32,
26289) {
26290    ffi::chpgvx_(
26291        itype.as_ptr(),
26292        &(jobz as c_char),
26293        &(range as c_char),
26294        &(uplo as c_char),
26295        &n,
26296        ap.as_mut_ptr() as *mut _,
26297        bp.as_mut_ptr() as *mut _,
26298        &vl,
26299        &vu,
26300        &il,
26301        &iu,
26302        &abstol,
26303        m,
26304        w.as_mut_ptr(),
26305        z.as_mut_ptr() as *mut _,
26306        &ldz,
26307        work.as_mut_ptr() as *mut _,
26308        rwork.as_mut_ptr(),
26309        iwork.as_mut_ptr(),
26310        ifail.as_mut_ptr(),
26311        info,
26312    )
26313}
26314
26315#[inline]
26316pub unsafe fn zhpgvx(
26317    itype: &[i32],
26318    jobz: u8,
26319    range: u8,
26320    uplo: u8,
26321    n: i32,
26322    ap: &mut [c64],
26323    bp: &mut [c64],
26324    vl: f64,
26325    vu: f64,
26326    il: i32,
26327    iu: i32,
26328    abstol: f64,
26329    m: &mut i32,
26330    w: &mut [f64],
26331    z: &mut [c64],
26332    ldz: i32,
26333    work: &mut [c64],
26334    rwork: &mut [f64],
26335    iwork: &mut [i32],
26336    ifail: &mut [i32],
26337    info: &mut i32,
26338) {
26339    ffi::zhpgvx_(
26340        itype.as_ptr(),
26341        &(jobz as c_char),
26342        &(range as c_char),
26343        &(uplo as c_char),
26344        &n,
26345        ap.as_mut_ptr() as *mut _,
26346        bp.as_mut_ptr() as *mut _,
26347        &vl,
26348        &vu,
26349        &il,
26350        &iu,
26351        &abstol,
26352        m,
26353        w.as_mut_ptr(),
26354        z.as_mut_ptr() as *mut _,
26355        &ldz,
26356        work.as_mut_ptr() as *mut _,
26357        rwork.as_mut_ptr(),
26358        iwork.as_mut_ptr(),
26359        ifail.as_mut_ptr(),
26360        info,
26361    )
26362}
26363
26364#[inline]
26365pub unsafe fn ssbgv(
26366    jobz: u8,
26367    uplo: u8,
26368    n: i32,
26369    ka: i32,
26370    kb: i32,
26371    ab: &mut [f32],
26372    ldab: i32,
26373    bb: &mut [f32],
26374    ldbb: i32,
26375    w: &mut [f32],
26376    z: &mut [f32],
26377    ldz: i32,
26378    work: &mut [f32],
26379    info: &mut i32,
26380) {
26381    ffi::ssbgv_(
26382        &(jobz as c_char),
26383        &(uplo as c_char),
26384        &n,
26385        &ka,
26386        &kb,
26387        ab.as_mut_ptr(),
26388        &ldab,
26389        bb.as_mut_ptr(),
26390        &ldbb,
26391        w.as_mut_ptr(),
26392        z.as_mut_ptr(),
26393        &ldz,
26394        work.as_mut_ptr(),
26395        info,
26396    )
26397}
26398
26399#[inline]
26400pub unsafe fn dsbgv(
26401    jobz: u8,
26402    uplo: u8,
26403    n: i32,
26404    ka: i32,
26405    kb: i32,
26406    ab: &mut [f64],
26407    ldab: i32,
26408    bb: &mut [f64],
26409    ldbb: i32,
26410    w: &mut [f64],
26411    z: &mut [f64],
26412    ldz: i32,
26413    work: &mut [f64],
26414    info: &mut i32,
26415) {
26416    ffi::dsbgv_(
26417        &(jobz as c_char),
26418        &(uplo as c_char),
26419        &n,
26420        &ka,
26421        &kb,
26422        ab.as_mut_ptr(),
26423        &ldab,
26424        bb.as_mut_ptr(),
26425        &ldbb,
26426        w.as_mut_ptr(),
26427        z.as_mut_ptr(),
26428        &ldz,
26429        work.as_mut_ptr(),
26430        info,
26431    )
26432}
26433
26434#[inline]
26435pub unsafe fn chbgv(
26436    jobz: u8,
26437    uplo: u8,
26438    n: i32,
26439    ka: i32,
26440    kb: i32,
26441    ab: &mut [c32],
26442    ldab: i32,
26443    bb: &mut [c32],
26444    ldbb: i32,
26445    w: &mut [f32],
26446    z: &mut [c32],
26447    ldz: i32,
26448    work: &mut [c32],
26449    rwork: &mut [f32],
26450    info: &mut i32,
26451) {
26452    ffi::chbgv_(
26453        &(jobz as c_char),
26454        &(uplo as c_char),
26455        &n,
26456        &ka,
26457        &kb,
26458        ab.as_mut_ptr() as *mut _,
26459        &ldab,
26460        bb.as_mut_ptr() as *mut _,
26461        &ldbb,
26462        w.as_mut_ptr(),
26463        z.as_mut_ptr() as *mut _,
26464        &ldz,
26465        work.as_mut_ptr() as *mut _,
26466        rwork.as_mut_ptr(),
26467        info,
26468    )
26469}
26470
26471#[inline]
26472pub unsafe fn zhbgv(
26473    jobz: u8,
26474    uplo: u8,
26475    n: i32,
26476    ka: i32,
26477    kb: i32,
26478    ab: &mut [c64],
26479    ldab: i32,
26480    bb: &mut [c64],
26481    ldbb: i32,
26482    w: &mut [f64],
26483    z: &mut [c64],
26484    ldz: i32,
26485    work: &mut [c64],
26486    rwork: &mut [f64],
26487    info: &mut i32,
26488) {
26489    ffi::zhbgv_(
26490        &(jobz as c_char),
26491        &(uplo as c_char),
26492        &n,
26493        &ka,
26494        &kb,
26495        ab.as_mut_ptr() as *mut _,
26496        &ldab,
26497        bb.as_mut_ptr() as *mut _,
26498        &ldbb,
26499        w.as_mut_ptr(),
26500        z.as_mut_ptr() as *mut _,
26501        &ldz,
26502        work.as_mut_ptr() as *mut _,
26503        rwork.as_mut_ptr(),
26504        info,
26505    )
26506}
26507
26508#[inline]
26509pub unsafe fn ssbgvd(
26510    jobz: u8,
26511    uplo: u8,
26512    n: i32,
26513    ka: i32,
26514    kb: i32,
26515    ab: &mut [f32],
26516    ldab: i32,
26517    bb: &mut [f32],
26518    ldbb: i32,
26519    w: &mut [f32],
26520    z: &mut [f32],
26521    ldz: i32,
26522    work: &mut [f32],
26523    lwork: i32,
26524    iwork: &mut [i32],
26525    liwork: i32,
26526    info: &mut i32,
26527) {
26528    ffi::ssbgvd_(
26529        &(jobz as c_char),
26530        &(uplo as c_char),
26531        &n,
26532        &ka,
26533        &kb,
26534        ab.as_mut_ptr(),
26535        &ldab,
26536        bb.as_mut_ptr(),
26537        &ldbb,
26538        w.as_mut_ptr(),
26539        z.as_mut_ptr(),
26540        &ldz,
26541        work.as_mut_ptr(),
26542        &lwork,
26543        iwork.as_mut_ptr(),
26544        &liwork,
26545        info,
26546    )
26547}
26548
26549#[inline]
26550pub unsafe fn dsbgvd(
26551    jobz: u8,
26552    uplo: u8,
26553    n: i32,
26554    ka: i32,
26555    kb: i32,
26556    ab: &mut [f64],
26557    ldab: i32,
26558    bb: &mut [f64],
26559    ldbb: i32,
26560    w: &mut [f64],
26561    z: &mut [f64],
26562    ldz: i32,
26563    work: &mut [f64],
26564    lwork: i32,
26565    iwork: &mut [i32],
26566    liwork: i32,
26567    info: &mut i32,
26568) {
26569    ffi::dsbgvd_(
26570        &(jobz as c_char),
26571        &(uplo as c_char),
26572        &n,
26573        &ka,
26574        &kb,
26575        ab.as_mut_ptr(),
26576        &ldab,
26577        bb.as_mut_ptr(),
26578        &ldbb,
26579        w.as_mut_ptr(),
26580        z.as_mut_ptr(),
26581        &ldz,
26582        work.as_mut_ptr(),
26583        &lwork,
26584        iwork.as_mut_ptr(),
26585        &liwork,
26586        info,
26587    )
26588}
26589
26590#[inline]
26591pub unsafe fn chbgvd(
26592    jobz: u8,
26593    uplo: u8,
26594    n: i32,
26595    ka: i32,
26596    kb: i32,
26597    ab: &mut [c32],
26598    ldab: i32,
26599    bb: &mut [c32],
26600    ldbb: i32,
26601    w: &mut [f32],
26602    z: &mut [c32],
26603    ldz: i32,
26604    work: &mut [c32],
26605    lwork: i32,
26606    rwork: &mut [f32],
26607    lrwork: i32,
26608    iwork: &mut [i32],
26609    liwork: i32,
26610    info: &mut i32,
26611) {
26612    ffi::chbgvd_(
26613        &(jobz as c_char),
26614        &(uplo as c_char),
26615        &n,
26616        &ka,
26617        &kb,
26618        ab.as_mut_ptr() as *mut _,
26619        &ldab,
26620        bb.as_mut_ptr() as *mut _,
26621        &ldbb,
26622        w.as_mut_ptr(),
26623        z.as_mut_ptr() as *mut _,
26624        &ldz,
26625        work.as_mut_ptr() as *mut _,
26626        &lwork,
26627        rwork.as_mut_ptr(),
26628        &lrwork,
26629        iwork.as_mut_ptr(),
26630        &liwork,
26631        info,
26632    )
26633}
26634
26635#[inline]
26636pub unsafe fn zhbgvd(
26637    jobz: u8,
26638    uplo: u8,
26639    n: i32,
26640    ka: i32,
26641    kb: i32,
26642    ab: &mut [c64],
26643    ldab: i32,
26644    bb: &mut [c64],
26645    ldbb: i32,
26646    w: &mut [f64],
26647    z: &mut [c64],
26648    ldz: i32,
26649    work: &mut [c64],
26650    lwork: i32,
26651    rwork: &mut [f64],
26652    lrwork: i32,
26653    iwork: &mut [i32],
26654    liwork: i32,
26655    info: &mut i32,
26656) {
26657    ffi::zhbgvd_(
26658        &(jobz as c_char),
26659        &(uplo as c_char),
26660        &n,
26661        &ka,
26662        &kb,
26663        ab.as_mut_ptr() as *mut _,
26664        &ldab,
26665        bb.as_mut_ptr() as *mut _,
26666        &ldbb,
26667        w.as_mut_ptr(),
26668        z.as_mut_ptr() as *mut _,
26669        &ldz,
26670        work.as_mut_ptr() as *mut _,
26671        &lwork,
26672        rwork.as_mut_ptr(),
26673        &lrwork,
26674        iwork.as_mut_ptr(),
26675        &liwork,
26676        info,
26677    )
26678}
26679
26680#[inline]
26681pub unsafe fn ssbgvx(
26682    jobz: u8,
26683    range: u8,
26684    uplo: u8,
26685    n: i32,
26686    ka: i32,
26687    kb: i32,
26688    ab: &mut [f32],
26689    ldab: i32,
26690    bb: &mut [f32],
26691    ldbb: i32,
26692    q: &mut [f32],
26693    ldq: i32,
26694    vl: f32,
26695    vu: f32,
26696    il: i32,
26697    iu: i32,
26698    abstol: f32,
26699    m: &mut i32,
26700    w: &mut [f32],
26701    z: &mut [f32],
26702    ldz: i32,
26703    work: &mut [f32],
26704    iwork: &mut [i32],
26705    ifail: &mut [i32],
26706    info: &mut i32,
26707) {
26708    ffi::ssbgvx_(
26709        &(jobz as c_char),
26710        &(range as c_char),
26711        &(uplo as c_char),
26712        &n,
26713        &ka,
26714        &kb,
26715        ab.as_mut_ptr(),
26716        &ldab,
26717        bb.as_mut_ptr(),
26718        &ldbb,
26719        q.as_mut_ptr(),
26720        &ldq,
26721        &vl,
26722        &vu,
26723        &il,
26724        &iu,
26725        &abstol,
26726        m,
26727        w.as_mut_ptr(),
26728        z.as_mut_ptr(),
26729        &ldz,
26730        work.as_mut_ptr(),
26731        iwork.as_mut_ptr(),
26732        ifail.as_mut_ptr(),
26733        info,
26734    )
26735}
26736
26737#[inline]
26738pub unsafe fn dsbgvx(
26739    jobz: u8,
26740    range: u8,
26741    uplo: u8,
26742    n: i32,
26743    ka: i32,
26744    kb: i32,
26745    ab: &mut [f64],
26746    ldab: i32,
26747    bb: &mut [f64],
26748    ldbb: i32,
26749    q: &mut [f64],
26750    ldq: i32,
26751    vl: f64,
26752    vu: f64,
26753    il: i32,
26754    iu: i32,
26755    abstol: f64,
26756    m: &mut i32,
26757    w: &mut [f64],
26758    z: &mut [f64],
26759    ldz: i32,
26760    work: &mut [f64],
26761    iwork: &mut [i32],
26762    ifail: &mut [i32],
26763    info: &mut i32,
26764) {
26765    ffi::dsbgvx_(
26766        &(jobz as c_char),
26767        &(range as c_char),
26768        &(uplo as c_char),
26769        &n,
26770        &ka,
26771        &kb,
26772        ab.as_mut_ptr(),
26773        &ldab,
26774        bb.as_mut_ptr(),
26775        &ldbb,
26776        q.as_mut_ptr(),
26777        &ldq,
26778        &vl,
26779        &vu,
26780        &il,
26781        &iu,
26782        &abstol,
26783        m,
26784        w.as_mut_ptr(),
26785        z.as_mut_ptr(),
26786        &ldz,
26787        work.as_mut_ptr(),
26788        iwork.as_mut_ptr(),
26789        ifail.as_mut_ptr(),
26790        info,
26791    )
26792}
26793
26794#[inline]
26795pub unsafe fn chbgvx(
26796    jobz: u8,
26797    range: u8,
26798    uplo: u8,
26799    n: i32,
26800    ka: i32,
26801    kb: i32,
26802    ab: &mut [c32],
26803    ldab: i32,
26804    bb: &mut [c32],
26805    ldbb: i32,
26806    q: &mut [c32],
26807    ldq: i32,
26808    vl: f32,
26809    vu: f32,
26810    il: i32,
26811    iu: i32,
26812    abstol: f32,
26813    m: &mut i32,
26814    w: &mut [f32],
26815    z: &mut [c32],
26816    ldz: i32,
26817    work: &mut [c32],
26818    rwork: &mut [f32],
26819    iwork: &mut [i32],
26820    ifail: &mut [i32],
26821    info: &mut i32,
26822) {
26823    ffi::chbgvx_(
26824        &(jobz as c_char),
26825        &(range as c_char),
26826        &(uplo as c_char),
26827        &n,
26828        &ka,
26829        &kb,
26830        ab.as_mut_ptr() as *mut _,
26831        &ldab,
26832        bb.as_mut_ptr() as *mut _,
26833        &ldbb,
26834        q.as_mut_ptr() as *mut _,
26835        &ldq,
26836        &vl,
26837        &vu,
26838        &il,
26839        &iu,
26840        &abstol,
26841        m,
26842        w.as_mut_ptr(),
26843        z.as_mut_ptr() as *mut _,
26844        &ldz,
26845        work.as_mut_ptr() as *mut _,
26846        rwork.as_mut_ptr(),
26847        iwork.as_mut_ptr(),
26848        ifail.as_mut_ptr(),
26849        info,
26850    )
26851}
26852
26853#[inline]
26854pub unsafe fn zhbgvx(
26855    jobz: u8,
26856    range: u8,
26857    uplo: u8,
26858    n: i32,
26859    ka: i32,
26860    kb: i32,
26861    ab: &mut [c64],
26862    ldab: i32,
26863    bb: &mut [c64],
26864    ldbb: i32,
26865    q: &mut [c64],
26866    ldq: i32,
26867    vl: f64,
26868    vu: f64,
26869    il: i32,
26870    iu: i32,
26871    abstol: f64,
26872    m: &mut i32,
26873    w: &mut [f64],
26874    z: &mut [c64],
26875    ldz: i32,
26876    work: &mut [c64],
26877    rwork: &mut [f64],
26878    iwork: &mut [i32],
26879    ifail: &mut [i32],
26880    info: &mut i32,
26881) {
26882    ffi::zhbgvx_(
26883        &(jobz as c_char),
26884        &(range as c_char),
26885        &(uplo as c_char),
26886        &n,
26887        &ka,
26888        &kb,
26889        ab.as_mut_ptr() as *mut _,
26890        &ldab,
26891        bb.as_mut_ptr() as *mut _,
26892        &ldbb,
26893        q.as_mut_ptr() as *mut _,
26894        &ldq,
26895        &vl,
26896        &vu,
26897        &il,
26898        &iu,
26899        &abstol,
26900        m,
26901        w.as_mut_ptr(),
26902        z.as_mut_ptr() as *mut _,
26903        &ldz,
26904        work.as_mut_ptr() as *mut _,
26905        rwork.as_mut_ptr(),
26906        iwork.as_mut_ptr(),
26907        ifail.as_mut_ptr(),
26908        info,
26909    )
26910}
26911
26912#[inline]
26913pub unsafe fn sgges(
26914    jobvsl: u8,
26915    jobvsr: u8,
26916    sort: u8,
26917    selctg: Select3F32,
26918    n: i32,
26919    a: &mut [f32],
26920    lda: i32,
26921    b: &mut [f32],
26922    ldb: i32,
26923    sdim: &mut i32,
26924    alphar: &mut f32,
26925    alphai: &mut f32,
26926    beta: &mut f32,
26927    vsl: &mut [f32],
26928    ldvsl: i32,
26929    vsr: &mut [f32],
26930    ldvsr: i32,
26931    work: &mut [f32],
26932    lwork: i32,
26933    bwork: &mut [i32],
26934    info: &mut i32,
26935) {
26936    ffi::sgges_(
26937        &(jobvsl as c_char),
26938        &(jobvsr as c_char),
26939        &(sort as c_char),
26940        transmute(selctg),
26941        &n,
26942        a.as_mut_ptr(),
26943        &lda,
26944        b.as_mut_ptr(),
26945        &ldb,
26946        sdim,
26947        alphar,
26948        alphai,
26949        beta,
26950        vsl.as_mut_ptr(),
26951        &ldvsl,
26952        vsr.as_mut_ptr(),
26953        &ldvsr,
26954        work.as_mut_ptr(),
26955        &lwork,
26956        bwork.as_mut_ptr(),
26957        info,
26958    )
26959}
26960
26961#[inline]
26962pub unsafe fn dgges(
26963    jobvsl: u8,
26964    jobvsr: u8,
26965    sort: u8,
26966    selctg: Select3F64,
26967    n: i32,
26968    a: &mut [f64],
26969    lda: i32,
26970    b: &mut [f64],
26971    ldb: i32,
26972    sdim: &mut i32,
26973    alphar: &mut f64,
26974    alphai: &mut f64,
26975    beta: &mut f64,
26976    vsl: &mut [f64],
26977    ldvsl: i32,
26978    vsr: &mut [f64],
26979    ldvsr: i32,
26980    work: &mut [f64],
26981    lwork: i32,
26982    bwork: &mut [i32],
26983    info: &mut i32,
26984) {
26985    ffi::dgges_(
26986        &(jobvsl as c_char),
26987        &(jobvsr as c_char),
26988        &(sort as c_char),
26989        transmute(selctg),
26990        &n,
26991        a.as_mut_ptr(),
26992        &lda,
26993        b.as_mut_ptr(),
26994        &ldb,
26995        sdim,
26996        alphar,
26997        alphai,
26998        beta,
26999        vsl.as_mut_ptr(),
27000        &ldvsl,
27001        vsr.as_mut_ptr(),
27002        &ldvsr,
27003        work.as_mut_ptr(),
27004        &lwork,
27005        bwork.as_mut_ptr(),
27006        info,
27007    )
27008}
27009
27010#[inline]
27011pub unsafe fn cgges(
27012    jobvsl: u8,
27013    jobvsr: u8,
27014    sort: u8,
27015    selctg: Select2C32,
27016    n: i32,
27017    a: &mut [c32],
27018    lda: i32,
27019    b: &mut [c32],
27020    ldb: i32,
27021    sdim: &mut i32,
27022    alpha: &mut c32,
27023    beta: &mut c32,
27024    vsl: &mut [c32],
27025    ldvsl: i32,
27026    vsr: &mut [c32],
27027    ldvsr: i32,
27028    work: &mut [c32],
27029    lwork: i32,
27030    rwork: &mut [f32],
27031    bwork: &mut [i32],
27032    info: &mut i32,
27033) {
27034    ffi::cgges_(
27035        &(jobvsl as c_char),
27036        &(jobvsr as c_char),
27037        &(sort as c_char),
27038        transmute(selctg),
27039        &n,
27040        a.as_mut_ptr() as *mut _,
27041        &lda,
27042        b.as_mut_ptr() as *mut _,
27043        &ldb,
27044        sdim,
27045        alpha as *mut _ as *mut _,
27046        beta as *mut _ as *mut _,
27047        vsl.as_mut_ptr() as *mut _,
27048        &ldvsl,
27049        vsr.as_mut_ptr() as *mut _,
27050        &ldvsr,
27051        work.as_mut_ptr() as *mut _,
27052        &lwork,
27053        rwork.as_mut_ptr(),
27054        bwork.as_mut_ptr(),
27055        info,
27056    )
27057}
27058
27059#[inline]
27060pub unsafe fn zgges(
27061    jobvsl: u8,
27062    jobvsr: u8,
27063    sort: u8,
27064    selctg: Select2C64,
27065    n: i32,
27066    a: &mut [c64],
27067    lda: i32,
27068    b: &mut [c64],
27069    ldb: i32,
27070    sdim: &mut i32,
27071    alpha: &mut c64,
27072    beta: &mut c64,
27073    vsl: &mut [c64],
27074    ldvsl: i32,
27075    vsr: &mut [c64],
27076    ldvsr: i32,
27077    work: &mut [c64],
27078    lwork: i32,
27079    rwork: &mut [f64],
27080    bwork: &mut [i32],
27081    info: &mut i32,
27082) {
27083    ffi::zgges_(
27084        &(jobvsl as c_char),
27085        &(jobvsr as c_char),
27086        &(sort as c_char),
27087        transmute(selctg),
27088        &n,
27089        a.as_mut_ptr() as *mut _,
27090        &lda,
27091        b.as_mut_ptr() as *mut _,
27092        &ldb,
27093        sdim,
27094        alpha as *mut _ as *mut _,
27095        beta as *mut _ as *mut _,
27096        vsl.as_mut_ptr() as *mut _,
27097        &ldvsl,
27098        vsr.as_mut_ptr() as *mut _,
27099        &ldvsr,
27100        work.as_mut_ptr() as *mut _,
27101        &lwork,
27102        rwork.as_mut_ptr(),
27103        bwork.as_mut_ptr(),
27104        info,
27105    )
27106}
27107
27108#[inline]
27109pub unsafe fn sgges3(
27110    jobvsl: u8,
27111    jobvsr: u8,
27112    sort: u8,
27113    selctg: Select3F32,
27114    n: i32,
27115    a: &mut [f32],
27116    lda: i32,
27117    b: &mut [f32],
27118    ldb: i32,
27119    sdim: &mut i32,
27120    alphar: &mut f32,
27121    alphai: &mut f32,
27122    beta: &mut f32,
27123    vsl: &mut [f32],
27124    ldvsl: i32,
27125    vsr: &mut [f32],
27126    ldvsr: i32,
27127    work: &mut [f32],
27128    lwork: i32,
27129    bwork: &mut [i32],
27130    info: &mut i32,
27131) {
27132    ffi::sgges3_(
27133        &(jobvsl as c_char),
27134        &(jobvsr as c_char),
27135        &(sort as c_char),
27136        transmute(selctg),
27137        &n,
27138        a.as_mut_ptr(),
27139        &lda,
27140        b.as_mut_ptr(),
27141        &ldb,
27142        sdim,
27143        alphar,
27144        alphai,
27145        beta,
27146        vsl.as_mut_ptr(),
27147        &ldvsl,
27148        vsr.as_mut_ptr(),
27149        &ldvsr,
27150        work.as_mut_ptr(),
27151        &lwork,
27152        bwork.as_mut_ptr(),
27153        info,
27154    )
27155}
27156
27157#[inline]
27158pub unsafe fn dgges3(
27159    jobvsl: u8,
27160    jobvsr: u8,
27161    sort: u8,
27162    selctg: Select3F64,
27163    n: i32,
27164    a: &mut [f64],
27165    lda: i32,
27166    b: &mut [f64],
27167    ldb: i32,
27168    sdim: &mut i32,
27169    alphar: &mut f64,
27170    alphai: &mut f64,
27171    beta: &mut f64,
27172    vsl: &mut [f64],
27173    ldvsl: i32,
27174    vsr: &mut [f64],
27175    ldvsr: i32,
27176    work: &mut [f64],
27177    lwork: i32,
27178    bwork: &mut [i32],
27179    info: &mut i32,
27180) {
27181    ffi::dgges3_(
27182        &(jobvsl as c_char),
27183        &(jobvsr as c_char),
27184        &(sort as c_char),
27185        transmute(selctg),
27186        &n,
27187        a.as_mut_ptr(),
27188        &lda,
27189        b.as_mut_ptr(),
27190        &ldb,
27191        sdim,
27192        alphar,
27193        alphai,
27194        beta,
27195        vsl.as_mut_ptr(),
27196        &ldvsl,
27197        vsr.as_mut_ptr(),
27198        &ldvsr,
27199        work.as_mut_ptr(),
27200        &lwork,
27201        bwork.as_mut_ptr(),
27202        info,
27203    )
27204}
27205
27206#[inline]
27207pub unsafe fn cgges3(
27208    jobvsl: u8,
27209    jobvsr: u8,
27210    sort: u8,
27211    selctg: Select2C32,
27212    n: i32,
27213    a: &mut [c32],
27214    lda: i32,
27215    b: &mut [c32],
27216    ldb: i32,
27217    sdim: &mut i32,
27218    alpha: &mut c32,
27219    beta: &mut c32,
27220    vsl: &mut [c32],
27221    ldvsl: i32,
27222    vsr: &mut [c32],
27223    ldvsr: i32,
27224    work: &mut [c32],
27225    lwork: i32,
27226    rwork: &mut [f32],
27227    bwork: &mut [i32],
27228    info: &mut i32,
27229) {
27230    ffi::cgges3_(
27231        &(jobvsl as c_char),
27232        &(jobvsr as c_char),
27233        &(sort as c_char),
27234        transmute(selctg),
27235        &n,
27236        a.as_mut_ptr() as *mut _,
27237        &lda,
27238        b.as_mut_ptr() as *mut _,
27239        &ldb,
27240        sdim,
27241        alpha as *mut _ as *mut _,
27242        beta as *mut _ as *mut _,
27243        vsl.as_mut_ptr() as *mut _,
27244        &ldvsl,
27245        vsr.as_mut_ptr() as *mut _,
27246        &ldvsr,
27247        work.as_mut_ptr() as *mut _,
27248        &lwork,
27249        rwork.as_mut_ptr(),
27250        bwork.as_mut_ptr(),
27251        info,
27252    )
27253}
27254
27255#[inline]
27256pub unsafe fn zgges3(
27257    jobvsl: u8,
27258    jobvsr: u8,
27259    sort: u8,
27260    selctg: Select2C64,
27261    n: i32,
27262    a: &mut [c64],
27263    lda: i32,
27264    b: &mut [c64],
27265    ldb: i32,
27266    sdim: &mut i32,
27267    alpha: &mut c64,
27268    beta: &mut c64,
27269    vsl: &mut [c64],
27270    ldvsl: i32,
27271    vsr: &mut [c64],
27272    ldvsr: i32,
27273    work: &mut [c64],
27274    lwork: i32,
27275    rwork: &mut [f64],
27276    bwork: &mut [i32],
27277    info: &mut i32,
27278) {
27279    ffi::zgges3_(
27280        &(jobvsl as c_char),
27281        &(jobvsr as c_char),
27282        &(sort as c_char),
27283        transmute(selctg),
27284        &n,
27285        a.as_mut_ptr() as *mut _,
27286        &lda,
27287        b.as_mut_ptr() as *mut _,
27288        &ldb,
27289        sdim,
27290        alpha as *mut _ as *mut _,
27291        beta as *mut _ as *mut _,
27292        vsl.as_mut_ptr() as *mut _,
27293        &ldvsl,
27294        vsr.as_mut_ptr() as *mut _,
27295        &ldvsr,
27296        work.as_mut_ptr() as *mut _,
27297        &lwork,
27298        rwork.as_mut_ptr(),
27299        bwork.as_mut_ptr(),
27300        info,
27301    )
27302}
27303
27304#[inline]
27305pub unsafe fn sggesx(
27306    jobvsl: u8,
27307    jobvsr: u8,
27308    sort: u8,
27309    selctg: Select3F32,
27310    sense: u8,
27311    n: i32,
27312    a: &mut [f32],
27313    lda: i32,
27314    b: &mut [f32],
27315    ldb: i32,
27316    sdim: &mut i32,
27317    alphar: &mut f32,
27318    alphai: &mut f32,
27319    beta: &mut f32,
27320    vsl: &mut [f32],
27321    ldvsl: i32,
27322    vsr: &mut [f32],
27323    ldvsr: i32,
27324    rconde: &mut [f32],
27325    rcondv: &mut [f32],
27326    work: &mut [f32],
27327    lwork: i32,
27328    iwork: &mut [i32],
27329    liwork: i32,
27330    bwork: &mut [i32],
27331    info: &mut i32,
27332) {
27333    ffi::sggesx_(
27334        &(jobvsl as c_char),
27335        &(jobvsr as c_char),
27336        &(sort as c_char),
27337        transmute(selctg),
27338        &(sense as c_char),
27339        &n,
27340        a.as_mut_ptr(),
27341        &lda,
27342        b.as_mut_ptr(),
27343        &ldb,
27344        sdim,
27345        alphar,
27346        alphai,
27347        beta,
27348        vsl.as_mut_ptr(),
27349        &ldvsl,
27350        vsr.as_mut_ptr(),
27351        &ldvsr,
27352        rconde.as_mut_ptr(),
27353        rcondv.as_mut_ptr(),
27354        work.as_mut_ptr(),
27355        &lwork,
27356        iwork.as_mut_ptr(),
27357        &liwork,
27358        bwork.as_mut_ptr(),
27359        info,
27360    )
27361}
27362
27363#[inline]
27364pub unsafe fn dggesx(
27365    jobvsl: u8,
27366    jobvsr: u8,
27367    sort: u8,
27368    selctg: Select3F64,
27369    sense: u8,
27370    n: i32,
27371    a: &mut [f64],
27372    lda: i32,
27373    b: &mut [f64],
27374    ldb: i32,
27375    sdim: &mut i32,
27376    alphar: &mut f64,
27377    alphai: &mut f64,
27378    beta: &mut f64,
27379    vsl: &mut [f64],
27380    ldvsl: i32,
27381    vsr: &mut [f64],
27382    ldvsr: i32,
27383    rconde: &mut [f64],
27384    rcondv: &mut [f64],
27385    work: &mut [f64],
27386    lwork: i32,
27387    iwork: &mut [i32],
27388    liwork: i32,
27389    bwork: &mut [i32],
27390    info: &mut i32,
27391) {
27392    ffi::dggesx_(
27393        &(jobvsl as c_char),
27394        &(jobvsr as c_char),
27395        &(sort as c_char),
27396        transmute(selctg),
27397        &(sense as c_char),
27398        &n,
27399        a.as_mut_ptr(),
27400        &lda,
27401        b.as_mut_ptr(),
27402        &ldb,
27403        sdim,
27404        alphar,
27405        alphai,
27406        beta,
27407        vsl.as_mut_ptr(),
27408        &ldvsl,
27409        vsr.as_mut_ptr(),
27410        &ldvsr,
27411        rconde.as_mut_ptr(),
27412        rcondv.as_mut_ptr(),
27413        work.as_mut_ptr(),
27414        &lwork,
27415        iwork.as_mut_ptr(),
27416        &liwork,
27417        bwork.as_mut_ptr(),
27418        info,
27419    )
27420}
27421
27422#[inline]
27423pub unsafe fn cggesx(
27424    jobvsl: u8,
27425    jobvsr: u8,
27426    sort: u8,
27427    selctg: Select2C32,
27428    sense: u8,
27429    n: i32,
27430    a: &mut [c32],
27431    lda: i32,
27432    b: &mut [c32],
27433    ldb: i32,
27434    sdim: &mut i32,
27435    alpha: &mut c32,
27436    beta: &mut c32,
27437    vsl: &mut [c32],
27438    ldvsl: i32,
27439    vsr: &mut [c32],
27440    ldvsr: i32,
27441    rconde: &mut [f32],
27442    rcondv: &mut [f32],
27443    work: &mut [c32],
27444    lwork: i32,
27445    rwork: &mut [f32],
27446    iwork: &mut [i32],
27447    liwork: i32,
27448    bwork: &mut [i32],
27449    info: &mut i32,
27450) {
27451    ffi::cggesx_(
27452        &(jobvsl as c_char),
27453        &(jobvsr as c_char),
27454        &(sort as c_char),
27455        transmute(selctg),
27456        &(sense as c_char),
27457        &n,
27458        a.as_mut_ptr() as *mut _,
27459        &lda,
27460        b.as_mut_ptr() as *mut _,
27461        &ldb,
27462        sdim,
27463        alpha as *mut _ as *mut _,
27464        beta as *mut _ as *mut _,
27465        vsl.as_mut_ptr() as *mut _,
27466        &ldvsl,
27467        vsr.as_mut_ptr() as *mut _,
27468        &ldvsr,
27469        rconde.as_mut_ptr(),
27470        rcondv.as_mut_ptr(),
27471        work.as_mut_ptr() as *mut _,
27472        &lwork,
27473        rwork.as_mut_ptr(),
27474        iwork.as_mut_ptr(),
27475        &liwork,
27476        bwork.as_mut_ptr(),
27477        info,
27478    )
27479}
27480
27481#[inline]
27482pub unsafe fn zggesx(
27483    jobvsl: u8,
27484    jobvsr: u8,
27485    sort: u8,
27486    selctg: Select2C64,
27487    sense: u8,
27488    n: i32,
27489    a: &mut [c64],
27490    lda: i32,
27491    b: &mut [c64],
27492    ldb: i32,
27493    sdim: &mut i32,
27494    alpha: &mut c64,
27495    beta: &mut c64,
27496    vsl: &mut [c64],
27497    ldvsl: i32,
27498    vsr: &mut [c64],
27499    ldvsr: i32,
27500    rconde: &mut [f64],
27501    rcondv: &mut [f64],
27502    work: &mut [c64],
27503    lwork: i32,
27504    rwork: &mut [f64],
27505    iwork: &mut [i32],
27506    liwork: i32,
27507    bwork: &mut [i32],
27508    info: &mut i32,
27509) {
27510    ffi::zggesx_(
27511        &(jobvsl as c_char),
27512        &(jobvsr as c_char),
27513        &(sort as c_char),
27514        transmute(selctg),
27515        &(sense as c_char),
27516        &n,
27517        a.as_mut_ptr() as *mut _,
27518        &lda,
27519        b.as_mut_ptr() as *mut _,
27520        &ldb,
27521        sdim,
27522        alpha as *mut _ as *mut _,
27523        beta as *mut _ as *mut _,
27524        vsl.as_mut_ptr() as *mut _,
27525        &ldvsl,
27526        vsr.as_mut_ptr() as *mut _,
27527        &ldvsr,
27528        rconde.as_mut_ptr(),
27529        rcondv.as_mut_ptr(),
27530        work.as_mut_ptr() as *mut _,
27531        &lwork,
27532        rwork.as_mut_ptr(),
27533        iwork.as_mut_ptr(),
27534        &liwork,
27535        bwork.as_mut_ptr(),
27536        info,
27537    )
27538}
27539
27540#[inline]
27541pub unsafe fn sggev(
27542    jobvl: u8,
27543    jobvr: u8,
27544    n: i32,
27545    a: &mut [f32],
27546    lda: i32,
27547    b: &mut [f32],
27548    ldb: i32,
27549    alphar: &mut f32,
27550    alphai: &mut f32,
27551    beta: &mut f32,
27552    vl: &mut f32,
27553    ldvl: i32,
27554    vr: &mut f32,
27555    ldvr: i32,
27556    work: &mut [f32],
27557    lwork: i32,
27558    info: &mut i32,
27559) {
27560    ffi::sggev_(
27561        &(jobvl as c_char),
27562        &(jobvr as c_char),
27563        &n,
27564        a.as_mut_ptr(),
27565        &lda,
27566        b.as_mut_ptr(),
27567        &ldb,
27568        alphar,
27569        alphai,
27570        beta,
27571        vl,
27572        &ldvl,
27573        vr,
27574        &ldvr,
27575        work.as_mut_ptr(),
27576        &lwork,
27577        info,
27578    )
27579}
27580
27581#[inline]
27582pub unsafe fn dggev(
27583    jobvl: u8,
27584    jobvr: u8,
27585    n: i32,
27586    a: &mut [f64],
27587    lda: i32,
27588    b: &mut [f64],
27589    ldb: i32,
27590    alphar: &mut f64,
27591    alphai: &mut f64,
27592    beta: &mut f64,
27593    vl: &mut f64,
27594    ldvl: i32,
27595    vr: &mut f64,
27596    ldvr: i32,
27597    work: &mut [f64],
27598    lwork: i32,
27599    info: &mut i32,
27600) {
27601    ffi::dggev_(
27602        &(jobvl as c_char),
27603        &(jobvr as c_char),
27604        &n,
27605        a.as_mut_ptr(),
27606        &lda,
27607        b.as_mut_ptr(),
27608        &ldb,
27609        alphar,
27610        alphai,
27611        beta,
27612        vl,
27613        &ldvl,
27614        vr,
27615        &ldvr,
27616        work.as_mut_ptr(),
27617        &lwork,
27618        info,
27619    )
27620}
27621
27622#[inline]
27623pub unsafe fn cggev(
27624    jobvl: u8,
27625    jobvr: u8,
27626    n: i32,
27627    a: &mut [c32],
27628    lda: i32,
27629    b: &mut [c32],
27630    ldb: i32,
27631    alpha: &mut c32,
27632    beta: &mut c32,
27633    vl: &mut c32,
27634    ldvl: i32,
27635    vr: &mut c32,
27636    ldvr: i32,
27637    work: &mut [c32],
27638    lwork: i32,
27639    rwork: &mut [f32],
27640    info: &mut i32,
27641) {
27642    ffi::cggev_(
27643        &(jobvl as c_char),
27644        &(jobvr as c_char),
27645        &n,
27646        a.as_mut_ptr() as *mut _,
27647        &lda,
27648        b.as_mut_ptr() as *mut _,
27649        &ldb,
27650        alpha as *mut _ as *mut _,
27651        beta as *mut _ as *mut _,
27652        vl as *mut _ as *mut _,
27653        &ldvl,
27654        vr as *mut _ as *mut _,
27655        &ldvr,
27656        work.as_mut_ptr() as *mut _,
27657        &lwork,
27658        rwork.as_mut_ptr(),
27659        info,
27660    )
27661}
27662
27663#[inline]
27664pub unsafe fn zggev(
27665    jobvl: u8,
27666    jobvr: u8,
27667    n: i32,
27668    a: &mut [c64],
27669    lda: i32,
27670    b: &mut [c64],
27671    ldb: i32,
27672    alpha: &mut c64,
27673    beta: &mut c64,
27674    vl: &mut c64,
27675    ldvl: i32,
27676    vr: &mut c64,
27677    ldvr: i32,
27678    work: &mut [c64],
27679    lwork: i32,
27680    rwork: &mut [f64],
27681    info: &mut i32,
27682) {
27683    ffi::zggev_(
27684        &(jobvl as c_char),
27685        &(jobvr as c_char),
27686        &n,
27687        a.as_mut_ptr() as *mut _,
27688        &lda,
27689        b.as_mut_ptr() as *mut _,
27690        &ldb,
27691        alpha as *mut _ as *mut _,
27692        beta as *mut _ as *mut _,
27693        vl as *mut _ as *mut _,
27694        &ldvl,
27695        vr as *mut _ as *mut _,
27696        &ldvr,
27697        work.as_mut_ptr() as *mut _,
27698        &lwork,
27699        rwork.as_mut_ptr(),
27700        info,
27701    )
27702}
27703
27704#[inline]
27705pub unsafe fn sggev3(
27706    jobvl: u8,
27707    jobvr: u8,
27708    n: i32,
27709    a: &mut [f32],
27710    lda: i32,
27711    b: &mut [f32],
27712    ldb: i32,
27713    alphar: &mut f32,
27714    alphai: &mut f32,
27715    beta: &mut f32,
27716    vl: &mut f32,
27717    ldvl: i32,
27718    vr: &mut f32,
27719    ldvr: i32,
27720    work: &mut [f32],
27721    lwork: i32,
27722    info: &mut i32,
27723) {
27724    ffi::sggev3_(
27725        &(jobvl as c_char),
27726        &(jobvr as c_char),
27727        &n,
27728        a.as_mut_ptr(),
27729        &lda,
27730        b.as_mut_ptr(),
27731        &ldb,
27732        alphar,
27733        alphai,
27734        beta,
27735        vl,
27736        &ldvl,
27737        vr,
27738        &ldvr,
27739        work.as_mut_ptr(),
27740        &lwork,
27741        info,
27742    )
27743}
27744
27745#[inline]
27746pub unsafe fn dggev3(
27747    jobvl: u8,
27748    jobvr: u8,
27749    n: i32,
27750    a: &mut [f64],
27751    lda: i32,
27752    b: &mut [f64],
27753    ldb: i32,
27754    alphar: &mut f64,
27755    alphai: &mut f64,
27756    beta: &mut f64,
27757    vl: &mut f64,
27758    ldvl: i32,
27759    vr: &mut f64,
27760    ldvr: i32,
27761    work: &mut [f64],
27762    lwork: i32,
27763    info: &mut i32,
27764) {
27765    ffi::dggev3_(
27766        &(jobvl as c_char),
27767        &(jobvr as c_char),
27768        &n,
27769        a.as_mut_ptr(),
27770        &lda,
27771        b.as_mut_ptr(),
27772        &ldb,
27773        alphar,
27774        alphai,
27775        beta,
27776        vl,
27777        &ldvl,
27778        vr,
27779        &ldvr,
27780        work.as_mut_ptr(),
27781        &lwork,
27782        info,
27783    )
27784}
27785
27786#[inline]
27787pub unsafe fn cggev3(
27788    jobvl: u8,
27789    jobvr: u8,
27790    n: i32,
27791    a: &mut [c32],
27792    lda: i32,
27793    b: &mut [c32],
27794    ldb: i32,
27795    alpha: &mut c32,
27796    beta: &mut c32,
27797    vl: &mut c32,
27798    ldvl: i32,
27799    vr: &mut c32,
27800    ldvr: i32,
27801    work: &mut [c32],
27802    lwork: i32,
27803    rwork: &mut [f32],
27804    info: &mut i32,
27805) {
27806    ffi::cggev3_(
27807        &(jobvl as c_char),
27808        &(jobvr as c_char),
27809        &n,
27810        a.as_mut_ptr() as *mut _,
27811        &lda,
27812        b.as_mut_ptr() as *mut _,
27813        &ldb,
27814        alpha as *mut _ as *mut _,
27815        beta as *mut _ as *mut _,
27816        vl as *mut _ as *mut _,
27817        &ldvl,
27818        vr as *mut _ as *mut _,
27819        &ldvr,
27820        work.as_mut_ptr() as *mut _,
27821        &lwork,
27822        rwork.as_mut_ptr(),
27823        info,
27824    )
27825}
27826
27827#[inline]
27828pub unsafe fn zggev3(
27829    jobvl: u8,
27830    jobvr: u8,
27831    n: i32,
27832    a: &mut [c64],
27833    lda: i32,
27834    b: &mut [c64],
27835    ldb: i32,
27836    alpha: &mut c64,
27837    beta: &mut c64,
27838    vl: &mut c64,
27839    ldvl: i32,
27840    vr: &mut c64,
27841    ldvr: i32,
27842    work: &mut [c64],
27843    lwork: i32,
27844    rwork: &mut [f64],
27845    info: &mut i32,
27846) {
27847    ffi::zggev3_(
27848        &(jobvl as c_char),
27849        &(jobvr as c_char),
27850        &n,
27851        a.as_mut_ptr() as *mut _,
27852        &lda,
27853        b.as_mut_ptr() as *mut _,
27854        &ldb,
27855        alpha as *mut _ as *mut _,
27856        beta as *mut _ as *mut _,
27857        vl as *mut _ as *mut _,
27858        &ldvl,
27859        vr as *mut _ as *mut _,
27860        &ldvr,
27861        work.as_mut_ptr() as *mut _,
27862        &lwork,
27863        rwork.as_mut_ptr(),
27864        info,
27865    )
27866}
27867
27868#[inline]
27869pub unsafe fn sggevx(
27870    balanc: u8,
27871    jobvl: u8,
27872    jobvr: u8,
27873    sense: u8,
27874    n: i32,
27875    a: &mut [f32],
27876    lda: i32,
27877    b: &mut [f32],
27878    ldb: i32,
27879    alphar: &mut f32,
27880    alphai: &mut f32,
27881    beta: &mut f32,
27882    vl: &mut f32,
27883    ldvl: i32,
27884    vr: &mut f32,
27885    ldvr: i32,
27886    ilo: &mut i32,
27887    ihi: &mut i32,
27888    lscale: &mut [f32],
27889    rscale: &mut [f32],
27890    abnrm: &mut f32,
27891    bbnrm: &mut f32,
27892    rconde: &mut [f32],
27893    rcondv: &mut [f32],
27894    work: &mut [f32],
27895    lwork: i32,
27896    iwork: &mut [i32],
27897    bwork: &mut [i32],
27898    info: &mut i32,
27899) {
27900    ffi::sggevx_(
27901        &(balanc as c_char),
27902        &(jobvl as c_char),
27903        &(jobvr as c_char),
27904        &(sense as c_char),
27905        &n,
27906        a.as_mut_ptr(),
27907        &lda,
27908        b.as_mut_ptr(),
27909        &ldb,
27910        alphar,
27911        alphai,
27912        beta,
27913        vl,
27914        &ldvl,
27915        vr,
27916        &ldvr,
27917        ilo,
27918        ihi,
27919        lscale.as_mut_ptr(),
27920        rscale.as_mut_ptr(),
27921        abnrm,
27922        bbnrm,
27923        rconde.as_mut_ptr(),
27924        rcondv.as_mut_ptr(),
27925        work.as_mut_ptr(),
27926        &lwork,
27927        iwork.as_mut_ptr(),
27928        bwork.as_mut_ptr(),
27929        info,
27930    )
27931}
27932
27933#[inline]
27934pub unsafe fn dggevx(
27935    balanc: u8,
27936    jobvl: u8,
27937    jobvr: u8,
27938    sense: u8,
27939    n: i32,
27940    a: &mut [f64],
27941    lda: i32,
27942    b: &mut [f64],
27943    ldb: i32,
27944    alphar: &mut f64,
27945    alphai: &mut f64,
27946    beta: &mut f64,
27947    vl: &mut f64,
27948    ldvl: i32,
27949    vr: &mut f64,
27950    ldvr: i32,
27951    ilo: &mut i32,
27952    ihi: &mut i32,
27953    lscale: &mut [f64],
27954    rscale: &mut [f64],
27955    abnrm: &mut f64,
27956    bbnrm: &mut f64,
27957    rconde: &mut [f64],
27958    rcondv: &mut [f64],
27959    work: &mut [f64],
27960    lwork: i32,
27961    iwork: &mut [i32],
27962    bwork: &mut [i32],
27963    info: &mut i32,
27964) {
27965    ffi::dggevx_(
27966        &(balanc as c_char),
27967        &(jobvl as c_char),
27968        &(jobvr as c_char),
27969        &(sense as c_char),
27970        &n,
27971        a.as_mut_ptr(),
27972        &lda,
27973        b.as_mut_ptr(),
27974        &ldb,
27975        alphar,
27976        alphai,
27977        beta,
27978        vl,
27979        &ldvl,
27980        vr,
27981        &ldvr,
27982        ilo,
27983        ihi,
27984        lscale.as_mut_ptr(),
27985        rscale.as_mut_ptr(),
27986        abnrm,
27987        bbnrm,
27988        rconde.as_mut_ptr(),
27989        rcondv.as_mut_ptr(),
27990        work.as_mut_ptr(),
27991        &lwork,
27992        iwork.as_mut_ptr(),
27993        bwork.as_mut_ptr(),
27994        info,
27995    )
27996}
27997
27998#[inline]
27999pub unsafe fn cggevx(
28000    balanc: u8,
28001    jobvl: u8,
28002    jobvr: u8,
28003    sense: u8,
28004    n: i32,
28005    a: &mut [c32],
28006    lda: i32,
28007    b: &mut [c32],
28008    ldb: i32,
28009    alpha: &mut c32,
28010    beta: &mut c32,
28011    vl: &mut c32,
28012    ldvl: i32,
28013    vr: &mut c32,
28014    ldvr: i32,
28015    ilo: &mut i32,
28016    ihi: &mut i32,
28017    lscale: &mut [f32],
28018    rscale: &mut [f32],
28019    abnrm: &mut f32,
28020    bbnrm: &mut f32,
28021    rconde: &mut [f32],
28022    rcondv: &mut [f32],
28023    work: &mut [c32],
28024    lwork: i32,
28025    rwork: &mut [f32],
28026    iwork: &mut [i32],
28027    bwork: &mut [i32],
28028    info: &mut i32,
28029) {
28030    ffi::cggevx_(
28031        &(balanc as c_char),
28032        &(jobvl as c_char),
28033        &(jobvr as c_char),
28034        &(sense as c_char),
28035        &n,
28036        a.as_mut_ptr() as *mut _,
28037        &lda,
28038        b.as_mut_ptr() as *mut _,
28039        &ldb,
28040        alpha as *mut _ as *mut _,
28041        beta as *mut _ as *mut _,
28042        vl as *mut _ as *mut _,
28043        &ldvl,
28044        vr as *mut _ as *mut _,
28045        &ldvr,
28046        ilo,
28047        ihi,
28048        lscale.as_mut_ptr(),
28049        rscale.as_mut_ptr(),
28050        abnrm,
28051        bbnrm,
28052        rconde.as_mut_ptr(),
28053        rcondv.as_mut_ptr(),
28054        work.as_mut_ptr() as *mut _,
28055        &lwork,
28056        rwork.as_mut_ptr(),
28057        iwork.as_mut_ptr(),
28058        bwork.as_mut_ptr(),
28059        info,
28060    )
28061}
28062
28063#[inline]
28064pub unsafe fn zggevx(
28065    balanc: u8,
28066    jobvl: u8,
28067    jobvr: u8,
28068    sense: u8,
28069    n: i32,
28070    a: &mut [c64],
28071    lda: i32,
28072    b: &mut [c64],
28073    ldb: i32,
28074    alpha: &mut c64,
28075    beta: &mut c64,
28076    vl: &mut c64,
28077    ldvl: i32,
28078    vr: &mut c64,
28079    ldvr: i32,
28080    ilo: &mut i32,
28081    ihi: &mut i32,
28082    lscale: &mut [f64],
28083    rscale: &mut [f64],
28084    abnrm: &mut f64,
28085    bbnrm: &mut f64,
28086    rconde: &mut [f64],
28087    rcondv: &mut [f64],
28088    work: &mut [c64],
28089    lwork: i32,
28090    rwork: &mut [f64],
28091    iwork: &mut [i32],
28092    bwork: &mut [i32],
28093    info: &mut i32,
28094) {
28095    ffi::zggevx_(
28096        &(balanc as c_char),
28097        &(jobvl as c_char),
28098        &(jobvr as c_char),
28099        &(sense as c_char),
28100        &n,
28101        a.as_mut_ptr() as *mut _,
28102        &lda,
28103        b.as_mut_ptr() as *mut _,
28104        &ldb,
28105        alpha as *mut _ as *mut _,
28106        beta as *mut _ as *mut _,
28107        vl as *mut _ as *mut _,
28108        &ldvl,
28109        vr as *mut _ as *mut _,
28110        &ldvr,
28111        ilo,
28112        ihi,
28113        lscale.as_mut_ptr(),
28114        rscale.as_mut_ptr(),
28115        abnrm,
28116        bbnrm,
28117        rconde.as_mut_ptr(),
28118        rcondv.as_mut_ptr(),
28119        work.as_mut_ptr() as *mut _,
28120        &lwork,
28121        rwork.as_mut_ptr(),
28122        iwork.as_mut_ptr(),
28123        bwork.as_mut_ptr(),
28124        info,
28125    )
28126}
28127
28128#[inline]
28129pub unsafe fn dsfrk(
28130    transr: u8,
28131    uplo: u8,
28132    trans: u8,
28133    n: i32,
28134    k: i32,
28135    alpha: f64,
28136    a: &[f64],
28137    lda: i32,
28138    beta: f64,
28139    c: &mut [f64],
28140) {
28141    ffi::dsfrk_(
28142        &(transr as c_char),
28143        &(uplo as c_char),
28144        &(trans as c_char),
28145        &n,
28146        &k,
28147        &alpha,
28148        a.as_ptr(),
28149        &lda,
28150        &beta,
28151        c.as_mut_ptr(),
28152    )
28153}
28154
28155#[inline]
28156pub unsafe fn ssfrk(
28157    transr: u8,
28158    uplo: u8,
28159    trans: u8,
28160    n: i32,
28161    k: i32,
28162    alpha: f32,
28163    a: &[f32],
28164    lda: i32,
28165    beta: f32,
28166    c: &mut [f32],
28167) {
28168    ffi::ssfrk_(
28169        &(transr as c_char),
28170        &(uplo as c_char),
28171        &(trans as c_char),
28172        &n,
28173        &k,
28174        &alpha,
28175        a.as_ptr(),
28176        &lda,
28177        &beta,
28178        c.as_mut_ptr(),
28179    )
28180}
28181
28182#[inline]
28183pub unsafe fn zhfrk(
28184    transr: u8,
28185    uplo: u8,
28186    trans: u8,
28187    n: i32,
28188    k: i32,
28189    alpha: f64,
28190    a: &[c64],
28191    lda: i32,
28192    beta: f64,
28193    c: &mut [c64],
28194) {
28195    ffi::zhfrk_(
28196        &(transr as c_char),
28197        &(uplo as c_char),
28198        &(trans as c_char),
28199        &n,
28200        &k,
28201        &alpha,
28202        a.as_ptr() as *const _,
28203        &lda,
28204        &beta,
28205        c.as_mut_ptr() as *mut _,
28206    )
28207}
28208
28209#[inline]
28210pub unsafe fn chfrk(
28211    transr: u8,
28212    uplo: u8,
28213    trans: u8,
28214    n: i32,
28215    k: i32,
28216    alpha: f32,
28217    a: &[c32],
28218    lda: i32,
28219    beta: f32,
28220    c: &mut [c32],
28221) {
28222    ffi::chfrk_(
28223        &(transr as c_char),
28224        &(uplo as c_char),
28225        &(trans as c_char),
28226        &n,
28227        &k,
28228        &alpha,
28229        a.as_ptr() as *const _,
28230        &lda,
28231        &beta,
28232        c.as_mut_ptr() as *mut _,
28233    )
28234}
28235
28236#[inline]
28237pub unsafe fn dtfsm(
28238    transr: u8,
28239    side: u8,
28240    uplo: u8,
28241    trans: u8,
28242    diag: u8,
28243    m: i32,
28244    n: i32,
28245    alpha: f64,
28246    a: &[f64],
28247    b: &mut [f64],
28248    ldb: i32,
28249) {
28250    ffi::dtfsm_(
28251        &(transr as c_char),
28252        &(side as c_char),
28253        &(uplo as c_char),
28254        &(trans as c_char),
28255        &(diag as c_char),
28256        &m,
28257        &n,
28258        &alpha,
28259        a.as_ptr(),
28260        b.as_mut_ptr(),
28261        &ldb,
28262    )
28263}
28264
28265#[inline]
28266pub unsafe fn stfsm(
28267    transr: u8,
28268    side: u8,
28269    uplo: u8,
28270    trans: u8,
28271    diag: u8,
28272    m: i32,
28273    n: i32,
28274    alpha: f32,
28275    a: &[f32],
28276    b: &mut [f32],
28277    ldb: i32,
28278) {
28279    ffi::stfsm_(
28280        &(transr as c_char),
28281        &(side as c_char),
28282        &(uplo as c_char),
28283        &(trans as c_char),
28284        &(diag as c_char),
28285        &m,
28286        &n,
28287        &alpha,
28288        a.as_ptr(),
28289        b.as_mut_ptr(),
28290        &ldb,
28291    )
28292}
28293
28294#[inline]
28295pub unsafe fn ztfsm(
28296    transr: u8,
28297    side: u8,
28298    uplo: u8,
28299    trans: u8,
28300    diag: u8,
28301    m: i32,
28302    n: i32,
28303    alpha: c64,
28304    a: &[c64],
28305    b: &mut [c64],
28306    ldb: i32,
28307) {
28308    ffi::ztfsm_(
28309        &(transr as c_char),
28310        &(side as c_char),
28311        &(uplo as c_char),
28312        &(trans as c_char),
28313        &(diag as c_char),
28314        &m,
28315        &n,
28316        &alpha as *const _ as *const _,
28317        a.as_ptr() as *const _,
28318        b.as_mut_ptr() as *mut _,
28319        &ldb,
28320    )
28321}
28322
28323#[inline]
28324pub unsafe fn ctfsm(
28325    transr: u8,
28326    side: u8,
28327    uplo: u8,
28328    trans: u8,
28329    diag: u8,
28330    m: i32,
28331    n: i32,
28332    alpha: c32,
28333    a: &[c32],
28334    b: &mut [c32],
28335    ldb: i32,
28336) {
28337    ffi::ctfsm_(
28338        &(transr as c_char),
28339        &(side as c_char),
28340        &(uplo as c_char),
28341        &(trans as c_char),
28342        &(diag as c_char),
28343        &m,
28344        &n,
28345        &alpha as *const _ as *const _,
28346        a.as_ptr() as *const _,
28347        b.as_mut_ptr() as *mut _,
28348        &ldb,
28349    )
28350}
28351
28352#[inline]
28353pub unsafe fn dtfttp(transr: u8, uplo: u8, n: i32, arf: &[f64], ap: &mut [f64], info: &mut i32) {
28354    ffi::dtfttp_(
28355        &(transr as c_char),
28356        &(uplo as c_char),
28357        &n,
28358        arf.as_ptr(),
28359        ap.as_mut_ptr(),
28360        info,
28361    )
28362}
28363
28364#[inline]
28365pub unsafe fn stfttp(transr: u8, uplo: u8, n: i32, arf: &[f32], ap: &mut [f32], info: &mut i32) {
28366    ffi::stfttp_(
28367        &(transr as c_char),
28368        &(uplo as c_char),
28369        &n,
28370        arf.as_ptr(),
28371        ap.as_mut_ptr(),
28372        info,
28373    )
28374}
28375
28376#[inline]
28377pub unsafe fn ztfttp(transr: u8, uplo: u8, n: i32, arf: &[c64], ap: &mut [c64], info: &mut i32) {
28378    ffi::ztfttp_(
28379        &(transr as c_char),
28380        &(uplo as c_char),
28381        &n,
28382        arf.as_ptr() as *const _,
28383        ap.as_mut_ptr() as *mut _,
28384        info,
28385    )
28386}
28387
28388#[inline]
28389pub unsafe fn ctfttp(transr: u8, uplo: u8, n: i32, arf: &[c32], ap: &mut [c32], info: &mut i32) {
28390    ffi::ctfttp_(
28391        &(transr as c_char),
28392        &(uplo as c_char),
28393        &n,
28394        arf.as_ptr() as *const _,
28395        ap.as_mut_ptr() as *mut _,
28396        info,
28397    )
28398}
28399
28400#[inline]
28401pub unsafe fn dtfttr(
28402    transr: u8,
28403    uplo: u8,
28404    n: i32,
28405    arf: &[f64],
28406    a: &mut [f64],
28407    lda: i32,
28408    info: &mut i32,
28409) {
28410    ffi::dtfttr_(
28411        &(transr as c_char),
28412        &(uplo as c_char),
28413        &n,
28414        arf.as_ptr(),
28415        a.as_mut_ptr(),
28416        &lda,
28417        info,
28418    )
28419}
28420
28421#[inline]
28422pub unsafe fn stfttr(
28423    transr: u8,
28424    uplo: u8,
28425    n: i32,
28426    arf: &[f32],
28427    a: &mut [f32],
28428    lda: i32,
28429    info: &mut i32,
28430) {
28431    ffi::stfttr_(
28432        &(transr as c_char),
28433        &(uplo as c_char),
28434        &n,
28435        arf.as_ptr(),
28436        a.as_mut_ptr(),
28437        &lda,
28438        info,
28439    )
28440}
28441
28442#[inline]
28443pub unsafe fn ztfttr(
28444    transr: u8,
28445    uplo: u8,
28446    n: i32,
28447    arf: &[c64],
28448    a: &mut [c64],
28449    lda: i32,
28450    info: &mut i32,
28451) {
28452    ffi::ztfttr_(
28453        &(transr as c_char),
28454        &(uplo as c_char),
28455        &n,
28456        arf.as_ptr() as *const _,
28457        a.as_mut_ptr() as *mut _,
28458        &lda,
28459        info,
28460    )
28461}
28462
28463#[inline]
28464pub unsafe fn ctfttr(
28465    transr: u8,
28466    uplo: u8,
28467    n: i32,
28468    arf: &[c32],
28469    a: &mut [c32],
28470    lda: i32,
28471    info: &mut i32,
28472) {
28473    ffi::ctfttr_(
28474        &(transr as c_char),
28475        &(uplo as c_char),
28476        &n,
28477        arf.as_ptr() as *const _,
28478        a.as_mut_ptr() as *mut _,
28479        &lda,
28480        info,
28481    )
28482}
28483
28484#[inline]
28485pub unsafe fn dtpttf(transr: u8, uplo: u8, n: i32, ap: &[f64], arf: &mut [f64], info: &mut i32) {
28486    ffi::dtpttf_(
28487        &(transr as c_char),
28488        &(uplo as c_char),
28489        &n,
28490        ap.as_ptr(),
28491        arf.as_mut_ptr(),
28492        info,
28493    )
28494}
28495
28496#[inline]
28497pub unsafe fn stpttf(transr: u8, uplo: u8, n: i32, ap: &[f32], arf: &mut [f32], info: &mut i32) {
28498    ffi::stpttf_(
28499        &(transr as c_char),
28500        &(uplo as c_char),
28501        &n,
28502        ap.as_ptr(),
28503        arf.as_mut_ptr(),
28504        info,
28505    )
28506}
28507
28508#[inline]
28509pub unsafe fn ztpttf(transr: u8, uplo: u8, n: i32, ap: &[c64], arf: &mut [c64], info: &mut i32) {
28510    ffi::ztpttf_(
28511        &(transr as c_char),
28512        &(uplo as c_char),
28513        &n,
28514        ap.as_ptr() as *const _,
28515        arf.as_mut_ptr() as *mut _,
28516        info,
28517    )
28518}
28519
28520#[inline]
28521pub unsafe fn ctpttf(transr: u8, uplo: u8, n: i32, ap: &[c32], arf: &mut [c32], info: &mut i32) {
28522    ffi::ctpttf_(
28523        &(transr as c_char),
28524        &(uplo as c_char),
28525        &n,
28526        ap.as_ptr() as *const _,
28527        arf.as_mut_ptr() as *mut _,
28528        info,
28529    )
28530}
28531
28532#[inline]
28533pub unsafe fn dtpttr(uplo: u8, n: i32, ap: &[f64], a: &mut [f64], lda: i32, info: &mut i32) {
28534    ffi::dtpttr_(
28535        &(uplo as c_char),
28536        &n,
28537        ap.as_ptr(),
28538        a.as_mut_ptr(),
28539        &lda,
28540        info,
28541    )
28542}
28543
28544#[inline]
28545pub unsafe fn stpttr(uplo: u8, n: i32, ap: &[f32], a: &mut [f32], lda: i32, info: &mut i32) {
28546    ffi::stpttr_(
28547        &(uplo as c_char),
28548        &n,
28549        ap.as_ptr(),
28550        a.as_mut_ptr(),
28551        &lda,
28552        info,
28553    )
28554}
28555
28556#[inline]
28557pub unsafe fn ztpttr(uplo: u8, n: i32, ap: &[c64], a: &mut [c64], lda: i32, info: &mut i32) {
28558    ffi::ztpttr_(
28559        &(uplo as c_char),
28560        &n,
28561        ap.as_ptr() as *const _,
28562        a.as_mut_ptr() as *mut _,
28563        &lda,
28564        info,
28565    )
28566}
28567
28568#[inline]
28569pub unsafe fn ctpttr(uplo: u8, n: i32, ap: &[c32], a: &mut [c32], lda: i32, info: &mut i32) {
28570    ffi::ctpttr_(
28571        &(uplo as c_char),
28572        &n,
28573        ap.as_ptr() as *const _,
28574        a.as_mut_ptr() as *mut _,
28575        &lda,
28576        info,
28577    )
28578}
28579
28580#[inline]
28581pub unsafe fn dtrttf(
28582    transr: u8,
28583    uplo: u8,
28584    n: i32,
28585    a: &[f64],
28586    lda: i32,
28587    arf: &mut [f64],
28588    info: &mut i32,
28589) {
28590    ffi::dtrttf_(
28591        &(transr as c_char),
28592        &(uplo as c_char),
28593        &n,
28594        a.as_ptr(),
28595        &lda,
28596        arf.as_mut_ptr(),
28597        info,
28598    )
28599}
28600
28601#[inline]
28602pub unsafe fn strttf(
28603    transr: u8,
28604    uplo: u8,
28605    n: i32,
28606    a: &[f32],
28607    lda: i32,
28608    arf: &mut [f32],
28609    info: &mut i32,
28610) {
28611    ffi::strttf_(
28612        &(transr as c_char),
28613        &(uplo as c_char),
28614        &n,
28615        a.as_ptr(),
28616        &lda,
28617        arf.as_mut_ptr(),
28618        info,
28619    )
28620}
28621
28622#[inline]
28623pub unsafe fn ztrttf(
28624    transr: u8,
28625    uplo: u8,
28626    n: i32,
28627    a: &[c64],
28628    lda: i32,
28629    arf: &mut [c64],
28630    info: &mut i32,
28631) {
28632    ffi::ztrttf_(
28633        &(transr as c_char),
28634        &(uplo as c_char),
28635        &n,
28636        a.as_ptr() as *const _,
28637        &lda,
28638        arf.as_mut_ptr() as *mut _,
28639        info,
28640    )
28641}
28642
28643#[inline]
28644pub unsafe fn ctrttf(
28645    transr: u8,
28646    uplo: u8,
28647    n: i32,
28648    a: &[c32],
28649    lda: i32,
28650    arf: &mut [c32],
28651    info: &mut i32,
28652) {
28653    ffi::ctrttf_(
28654        &(transr as c_char),
28655        &(uplo as c_char),
28656        &n,
28657        a.as_ptr() as *const _,
28658        &lda,
28659        arf.as_mut_ptr() as *mut _,
28660        info,
28661    )
28662}
28663
28664#[inline]
28665pub unsafe fn dtrttp(uplo: u8, n: i32, a: &[f64], lda: i32, ap: &mut [f64], info: &mut i32) {
28666    ffi::dtrttp_(
28667        &(uplo as c_char),
28668        &n,
28669        a.as_ptr(),
28670        &lda,
28671        ap.as_mut_ptr(),
28672        info,
28673    )
28674}
28675
28676#[inline]
28677pub unsafe fn strttp(uplo: u8, n: i32, a: &[f32], lda: i32, ap: &mut [f32], info: &mut i32) {
28678    ffi::strttp_(
28679        &(uplo as c_char),
28680        &n,
28681        a.as_ptr(),
28682        &lda,
28683        ap.as_mut_ptr(),
28684        info,
28685    )
28686}
28687
28688#[inline]
28689pub unsafe fn ztrttp(uplo: u8, n: i32, a: &[c64], lda: i32, ap: &mut [c64], info: &mut i32) {
28690    ffi::ztrttp_(
28691        &(uplo as c_char),
28692        &n,
28693        a.as_ptr() as *const _,
28694        &lda,
28695        ap.as_mut_ptr() as *mut _,
28696        info,
28697    )
28698}
28699
28700#[inline]
28701pub unsafe fn ctrttp(uplo: u8, n: i32, a: &[c32], lda: i32, ap: &mut [c32], info: &mut i32) {
28702    ffi::ctrttp_(
28703        &(uplo as c_char),
28704        &n,
28705        a.as_ptr() as *const _,
28706        &lda,
28707        ap.as_mut_ptr() as *mut _,
28708        info,
28709    )
28710}
28711
28712#[inline]
28713pub unsafe fn sgeqrfp(
28714    m: i32,
28715    n: i32,
28716    a: &mut [f32],
28717    lda: i32,
28718    tau: &mut [f32],
28719    work: &mut [f32],
28720    lwork: i32,
28721    info: &mut i32,
28722) {
28723    ffi::sgeqrfp_(
28724        &m,
28725        &n,
28726        a.as_mut_ptr(),
28727        &lda,
28728        tau.as_mut_ptr(),
28729        work.as_mut_ptr(),
28730        &lwork,
28731        info,
28732    )
28733}
28734
28735#[inline]
28736pub unsafe fn dgeqrfp(
28737    m: i32,
28738    n: i32,
28739    a: &mut [f64],
28740    lda: i32,
28741    tau: &mut [f64],
28742    work: &mut [f64],
28743    lwork: i32,
28744    info: &mut i32,
28745) {
28746    ffi::dgeqrfp_(
28747        &m,
28748        &n,
28749        a.as_mut_ptr(),
28750        &lda,
28751        tau.as_mut_ptr(),
28752        work.as_mut_ptr(),
28753        &lwork,
28754        info,
28755    )
28756}
28757
28758#[inline]
28759pub unsafe fn cgeqrfp(
28760    m: i32,
28761    n: i32,
28762    a: &mut [c32],
28763    lda: i32,
28764    tau: &mut [c32],
28765    work: &mut [c32],
28766    lwork: i32,
28767    info: &mut i32,
28768) {
28769    ffi::cgeqrfp_(
28770        &m,
28771        &n,
28772        a.as_mut_ptr() as *mut _,
28773        &lda,
28774        tau.as_mut_ptr() as *mut _,
28775        work.as_mut_ptr() as *mut _,
28776        &lwork,
28777        info,
28778    )
28779}
28780
28781#[inline]
28782pub unsafe fn zgeqrfp(
28783    m: i32,
28784    n: i32,
28785    a: &mut [c64],
28786    lda: i32,
28787    tau: &mut [c64],
28788    work: &mut [c64],
28789    lwork: i32,
28790    info: &mut i32,
28791) {
28792    ffi::zgeqrfp_(
28793        &m,
28794        &n,
28795        a.as_mut_ptr() as *mut _,
28796        &lda,
28797        tau.as_mut_ptr() as *mut _,
28798        work.as_mut_ptr() as *mut _,
28799        &lwork,
28800        info,
28801    )
28802}
28803
28804#[inline]
28805pub unsafe fn clacgv(n: i32, x: &mut [c32], incx: i32) {
28806    ffi::clacgv_(&n, x.as_mut_ptr() as *mut _, &incx)
28807}
28808
28809#[inline]
28810pub unsafe fn zlacgv(n: i32, x: &mut [c64], incx: i32) {
28811    ffi::zlacgv_(&n, x.as_mut_ptr() as *mut _, &incx)
28812}
28813
28814#[inline]
28815pub unsafe fn slarnv(idist: &[i32], iseed: &mut [i32], n: i32, x: &mut [f32]) {
28816    ffi::slarnv_(idist.as_ptr(), iseed.as_mut_ptr(), &n, x.as_mut_ptr())
28817}
28818
28819#[inline]
28820pub unsafe fn dlarnv(idist: &[i32], iseed: &mut [i32], n: i32, x: &mut [f64]) {
28821    ffi::dlarnv_(idist.as_ptr(), iseed.as_mut_ptr(), &n, x.as_mut_ptr())
28822}
28823
28824#[inline]
28825pub unsafe fn clarnv(idist: &[i32], iseed: &mut [i32], n: i32, x: &mut [c32]) {
28826    ffi::clarnv_(
28827        idist.as_ptr(),
28828        iseed.as_mut_ptr(),
28829        &n,
28830        x.as_mut_ptr() as *mut _,
28831    )
28832}
28833
28834#[inline]
28835pub unsafe fn zlarnv(idist: &[i32], iseed: &mut [i32], n: i32, x: &mut [c64]) {
28836    ffi::zlarnv_(
28837        idist.as_ptr(),
28838        iseed.as_mut_ptr(),
28839        &n,
28840        x.as_mut_ptr() as *mut _,
28841    )
28842}
28843
28844#[inline]
28845pub unsafe fn sgeqr2(
28846    m: i32,
28847    n: i32,
28848    a: &mut [f32],
28849    lda: i32,
28850    tau: &mut [f32],
28851    work: &mut [f32],
28852    info: &mut i32,
28853) {
28854    ffi::sgeqr2_(
28855        &m,
28856        &n,
28857        a.as_mut_ptr(),
28858        &lda,
28859        tau.as_mut_ptr(),
28860        work.as_mut_ptr(),
28861        info,
28862    )
28863}
28864
28865#[inline]
28866pub unsafe fn dgeqr2(
28867    m: i32,
28868    n: i32,
28869    a: &mut [f64],
28870    lda: i32,
28871    tau: &mut [f64],
28872    work: &mut [f64],
28873    info: &mut i32,
28874) {
28875    ffi::dgeqr2_(
28876        &m,
28877        &n,
28878        a.as_mut_ptr(),
28879        &lda,
28880        tau.as_mut_ptr(),
28881        work.as_mut_ptr(),
28882        info,
28883    )
28884}
28885
28886#[inline]
28887pub unsafe fn cgeqr2(
28888    m: i32,
28889    n: i32,
28890    a: &mut [c32],
28891    lda: i32,
28892    tau: &mut [c32],
28893    work: &mut [c32],
28894    info: &mut i32,
28895) {
28896    ffi::cgeqr2_(
28897        &m,
28898        &n,
28899        a.as_mut_ptr() as *mut _,
28900        &lda,
28901        tau.as_mut_ptr() as *mut _,
28902        work.as_mut_ptr() as *mut _,
28903        info,
28904    )
28905}
28906
28907#[inline]
28908pub unsafe fn zgeqr2(
28909    m: i32,
28910    n: i32,
28911    a: &mut [c64],
28912    lda: i32,
28913    tau: &mut [c64],
28914    work: &mut [c64],
28915    info: &mut i32,
28916) {
28917    ffi::zgeqr2_(
28918        &m,
28919        &n,
28920        a.as_mut_ptr() as *mut _,
28921        &lda,
28922        tau.as_mut_ptr() as *mut _,
28923        work.as_mut_ptr() as *mut _,
28924        info,
28925    )
28926}
28927
28928#[inline]
28929pub unsafe fn slacn2(
28930    n: i32,
28931    v: &mut [f32],
28932    x: &mut [f32],
28933    isgn: &mut [i32],
28934    est: &mut [f32],
28935    kase: &mut i32,
28936    isave: &mut [i32],
28937) {
28938    ffi::slacn2_(
28939        &n,
28940        v.as_mut_ptr(),
28941        x.as_mut_ptr(),
28942        isgn.as_mut_ptr(),
28943        est.as_mut_ptr(),
28944        kase,
28945        isave.as_mut_ptr(),
28946    )
28947}
28948
28949#[inline]
28950pub unsafe fn dlacn2(
28951    n: i32,
28952    v: &mut [f64],
28953    x: &mut [f64],
28954    isgn: &mut [i32],
28955    est: &mut [f64],
28956    kase: &mut i32,
28957    isave: &mut [i32],
28958) {
28959    ffi::dlacn2_(
28960        &n,
28961        v.as_mut_ptr(),
28962        x.as_mut_ptr(),
28963        isgn.as_mut_ptr(),
28964        est.as_mut_ptr(),
28965        kase,
28966        isave.as_mut_ptr(),
28967    )
28968}
28969
28970#[inline]
28971pub unsafe fn clacn2(
28972    n: i32,
28973    v: &mut [c32],
28974    x: &mut [c32],
28975    est: &mut [f32],
28976    kase: &mut i32,
28977    isave: &mut [i32],
28978) {
28979    ffi::clacn2_(
28980        &n,
28981        v.as_mut_ptr() as *mut _,
28982        x.as_mut_ptr() as *mut _,
28983        est.as_mut_ptr(),
28984        kase,
28985        isave.as_mut_ptr(),
28986    )
28987}
28988
28989#[inline]
28990pub unsafe fn zlacn2(
28991    n: i32,
28992    v: &mut [c64],
28993    x: &mut [c64],
28994    est: &mut [f64],
28995    kase: &mut i32,
28996    isave: &mut [i32],
28997) {
28998    ffi::zlacn2_(
28999        &n,
29000        v.as_mut_ptr() as *mut _,
29001        x.as_mut_ptr() as *mut _,
29002        est.as_mut_ptr(),
29003        kase,
29004        isave.as_mut_ptr(),
29005    )
29006}
29007
29008#[inline]
29009pub unsafe fn slacpy(uplo: u8, m: i32, n: i32, a: &[f32], lda: i32, b: &mut [f32], ldb: i32) {
29010    ffi::slacpy_(
29011        &(uplo as c_char),
29012        &m,
29013        &n,
29014        a.as_ptr(),
29015        &lda,
29016        b.as_mut_ptr(),
29017        &ldb,
29018    )
29019}
29020
29021#[inline]
29022pub unsafe fn dlacpy(uplo: u8, m: i32, n: i32, a: &[f64], lda: i32, b: &mut [f64], ldb: i32) {
29023    ffi::dlacpy_(
29024        &(uplo as c_char),
29025        &m,
29026        &n,
29027        a.as_ptr(),
29028        &lda,
29029        b.as_mut_ptr(),
29030        &ldb,
29031    )
29032}
29033
29034#[inline]
29035pub unsafe fn clacpy(uplo: u8, m: i32, n: i32, a: &[c32], lda: i32, b: &mut [c32], ldb: i32) {
29036    ffi::clacpy_(
29037        &(uplo as c_char),
29038        &m,
29039        &n,
29040        a.as_ptr() as *const _,
29041        &lda,
29042        b.as_mut_ptr() as *mut _,
29043        &ldb,
29044    )
29045}
29046
29047#[inline]
29048pub unsafe fn zlacpy(uplo: u8, m: i32, n: i32, a: &[c64], lda: i32, b: &mut [c64], ldb: i32) {
29049    ffi::zlacpy_(
29050        &(uplo as c_char),
29051        &m,
29052        &n,
29053        a.as_ptr() as *const _,
29054        &lda,
29055        b.as_mut_ptr() as *mut _,
29056        &ldb,
29057    )
29058}
29059
29060#[inline]
29061pub unsafe fn clacp2(uplo: u8, m: i32, n: i32, a: &[f32], lda: i32, b: &mut [c32], ldb: i32) {
29062    ffi::clacp2_(
29063        &(uplo as c_char),
29064        &m,
29065        &n,
29066        a.as_ptr(),
29067        &lda,
29068        b.as_mut_ptr() as *mut _,
29069        &ldb,
29070    )
29071}
29072
29073#[inline]
29074pub unsafe fn zlacp2(uplo: u8, m: i32, n: i32, a: &[f64], lda: i32, b: &mut [c64], ldb: i32) {
29075    ffi::zlacp2_(
29076        &(uplo as c_char),
29077        &m,
29078        &n,
29079        a.as_ptr(),
29080        &lda,
29081        b.as_mut_ptr() as *mut _,
29082        &ldb,
29083    )
29084}
29085
29086#[inline]
29087pub unsafe fn sgetf2(m: i32, n: i32, a: &mut [f32], lda: i32, ipiv: &mut [i32], info: &mut i32) {
29088    ffi::sgetf2_(&m, &n, a.as_mut_ptr(), &lda, ipiv.as_mut_ptr(), info)
29089}
29090
29091#[inline]
29092pub unsafe fn dgetf2(m: i32, n: i32, a: &mut [f64], lda: i32, ipiv: &mut [i32], info: &mut i32) {
29093    ffi::dgetf2_(&m, &n, a.as_mut_ptr(), &lda, ipiv.as_mut_ptr(), info)
29094}
29095
29096#[inline]
29097pub unsafe fn cgetf2(m: i32, n: i32, a: &mut [c32], lda: i32, ipiv: &mut [i32], info: &mut i32) {
29098    ffi::cgetf2_(
29099        &m,
29100        &n,
29101        a.as_mut_ptr() as *mut _,
29102        &lda,
29103        ipiv.as_mut_ptr(),
29104        info,
29105    )
29106}
29107
29108#[inline]
29109pub unsafe fn zgetf2(m: i32, n: i32, a: &mut [c64], lda: i32, ipiv: &mut [i32], info: &mut i32) {
29110    ffi::zgetf2_(
29111        &m,
29112        &n,
29113        a.as_mut_ptr() as *mut _,
29114        &lda,
29115        ipiv.as_mut_ptr(),
29116        info,
29117    )
29118}
29119
29120#[inline]
29121pub unsafe fn slaswp(n: i32, a: &mut [f32], lda: i32, k1: i32, k2: i32, ipiv: &[i32], incx: i32) {
29122    ffi::slaswp_(&n, a.as_mut_ptr(), &lda, &k1, &k2, ipiv.as_ptr(), &incx)
29123}
29124
29125#[inline]
29126pub unsafe fn dlaswp(n: i32, a: &mut [f64], lda: i32, k1: i32, k2: i32, ipiv: &[i32], incx: i32) {
29127    ffi::dlaswp_(&n, a.as_mut_ptr(), &lda, &k1, &k2, ipiv.as_ptr(), &incx)
29128}
29129
29130#[inline]
29131pub unsafe fn claswp(n: i32, a: &mut [c32], lda: i32, k1: i32, k2: i32, ipiv: &[i32], incx: i32) {
29132    ffi::claswp_(
29133        &n,
29134        a.as_mut_ptr() as *mut _,
29135        &lda,
29136        &k1,
29137        &k2,
29138        ipiv.as_ptr(),
29139        &incx,
29140    )
29141}
29142
29143#[inline]
29144pub unsafe fn zlaswp(n: i32, a: &mut [c64], lda: i32, k1: i32, k2: i32, ipiv: &[i32], incx: i32) {
29145    ffi::zlaswp_(
29146        &n,
29147        a.as_mut_ptr() as *mut _,
29148        &lda,
29149        &k1,
29150        &k2,
29151        ipiv.as_ptr(),
29152        &incx,
29153    )
29154}
29155
29156#[inline]
29157pub unsafe fn slange(norm: u8, m: i32, n: i32, a: &[f32], lda: i32, work: &mut [f32]) -> f32 {
29158    ffi::slange_(
29159        &(norm as c_char),
29160        &m,
29161        &n,
29162        a.as_ptr(),
29163        &lda,
29164        work.as_mut_ptr(),
29165    )
29166}
29167
29168#[inline]
29169pub unsafe fn dlange(norm: u8, m: i32, n: i32, a: &[f64], lda: i32, work: &mut [f64]) -> f64 {
29170    ffi::dlange_(
29171        &(norm as c_char),
29172        &m,
29173        &n,
29174        a.as_ptr(),
29175        &lda,
29176        work.as_mut_ptr(),
29177    )
29178}
29179
29180#[inline]
29181pub unsafe fn clange(norm: u8, m: i32, n: i32, a: &[c32], lda: i32, work: &mut [f32]) -> f32 {
29182    ffi::clange_(
29183        &(norm as c_char),
29184        &m,
29185        &n,
29186        a.as_ptr() as *const _,
29187        &lda,
29188        work.as_mut_ptr(),
29189    )
29190}
29191
29192#[inline]
29193pub unsafe fn zlange(norm: u8, m: i32, n: i32, a: &[c64], lda: i32, work: &mut [f64]) -> f64 {
29194    ffi::zlange_(
29195        &(norm as c_char),
29196        &m,
29197        &n,
29198        a.as_ptr() as *const _,
29199        &lda,
29200        work.as_mut_ptr(),
29201    )
29202}
29203
29204#[inline]
29205pub unsafe fn clanhe(norm: u8, uplo: u8, n: i32, a: &[c32], lda: i32, work: &mut [f32]) -> f32 {
29206    ffi::clanhe_(
29207        &(norm as c_char),
29208        &(uplo as c_char),
29209        &n,
29210        a.as_ptr() as *const _,
29211        &lda,
29212        work.as_mut_ptr(),
29213    )
29214}
29215
29216#[inline]
29217pub unsafe fn zlanhe(norm: u8, uplo: u8, n: i32, a: &[c64], lda: i32, work: &mut [f64]) -> f64 {
29218    ffi::zlanhe_(
29219        &(norm as c_char),
29220        &(uplo as c_char),
29221        &n,
29222        a.as_ptr() as *const _,
29223        &lda,
29224        work.as_mut_ptr(),
29225    )
29226}
29227
29228#[inline]
29229pub unsafe fn slansy(norm: u8, uplo: u8, n: i32, a: &[f32], lda: i32, work: &mut [f32]) -> f32 {
29230    ffi::slansy_(
29231        &(norm as c_char),
29232        &(uplo as c_char),
29233        &n,
29234        a.as_ptr(),
29235        &lda,
29236        work.as_mut_ptr(),
29237    )
29238}
29239
29240#[inline]
29241pub unsafe fn dlansy(norm: u8, uplo: u8, n: i32, a: &[f64], lda: i32, work: &mut [f64]) -> f64 {
29242    ffi::dlansy_(
29243        &(norm as c_char),
29244        &(uplo as c_char),
29245        &n,
29246        a.as_ptr(),
29247        &lda,
29248        work.as_mut_ptr(),
29249    )
29250}
29251
29252#[inline]
29253pub unsafe fn clansy(norm: u8, uplo: u8, n: i32, a: &[c32], lda: i32, work: &mut [f32]) -> f32 {
29254    ffi::clansy_(
29255        &(norm as c_char),
29256        &(uplo as c_char),
29257        &n,
29258        a.as_ptr() as *const _,
29259        &lda,
29260        work.as_mut_ptr(),
29261    )
29262}
29263
29264#[inline]
29265pub unsafe fn zlansy(norm: u8, uplo: u8, n: i32, a: &[c64], lda: i32, work: &mut [f64]) -> f64 {
29266    ffi::zlansy_(
29267        &(norm as c_char),
29268        &(uplo as c_char),
29269        &n,
29270        a.as_ptr() as *const _,
29271        &lda,
29272        work.as_mut_ptr(),
29273    )
29274}
29275
29276#[inline]
29277pub unsafe fn slantr(
29278    norm: u8,
29279    uplo: u8,
29280    diag: u8,
29281    m: i32,
29282    n: i32,
29283    a: &[f32],
29284    lda: i32,
29285    work: &mut [f32],
29286) -> f32 {
29287    ffi::slantr_(
29288        &(norm as c_char),
29289        &(uplo as c_char),
29290        &(diag as c_char),
29291        &m,
29292        &n,
29293        a.as_ptr(),
29294        &lda,
29295        work.as_mut_ptr(),
29296    )
29297}
29298
29299#[inline]
29300pub unsafe fn dlantr(
29301    norm: u8,
29302    uplo: u8,
29303    diag: u8,
29304    m: i32,
29305    n: i32,
29306    a: &[f64],
29307    lda: i32,
29308    work: &mut [f64],
29309) -> f64 {
29310    ffi::dlantr_(
29311        &(norm as c_char),
29312        &(uplo as c_char),
29313        &(diag as c_char),
29314        &m,
29315        &n,
29316        a.as_ptr(),
29317        &lda,
29318        work.as_mut_ptr(),
29319    )
29320}
29321
29322#[inline]
29323pub unsafe fn clantr(
29324    norm: u8,
29325    uplo: u8,
29326    diag: u8,
29327    m: i32,
29328    n: i32,
29329    a: &[c32],
29330    lda: i32,
29331    work: &mut [f32],
29332) -> f32 {
29333    ffi::clantr_(
29334        &(norm as c_char),
29335        &(uplo as c_char),
29336        &(diag as c_char),
29337        &m,
29338        &n,
29339        a.as_ptr() as *const _,
29340        &lda,
29341        work.as_mut_ptr(),
29342    )
29343}
29344
29345#[inline]
29346pub unsafe fn zlantr(
29347    norm: u8,
29348    uplo: u8,
29349    diag: u8,
29350    m: i32,
29351    n: i32,
29352    a: &[c64],
29353    lda: i32,
29354    work: &mut [f64],
29355) -> f64 {
29356    ffi::zlantr_(
29357        &(norm as c_char),
29358        &(uplo as c_char),
29359        &(diag as c_char),
29360        &m,
29361        &n,
29362        a.as_ptr() as *const _,
29363        &lda,
29364        work.as_mut_ptr(),
29365    )
29366}
29367
29368#[inline]
29369pub unsafe fn slamch(cmach: u8) -> f32 {
29370    ffi::slamch_(&(cmach as c_char))
29371}
29372
29373#[inline]
29374pub unsafe fn dlamch(cmach: u8) -> f64 {
29375    ffi::dlamch_(&(cmach as c_char))
29376}
29377
29378#[inline]
29379pub unsafe fn sgelq2(
29380    m: i32,
29381    n: i32,
29382    a: &mut [f32],
29383    lda: i32,
29384    tau: &mut [f32],
29385    work: &mut [f32],
29386    info: &mut i32,
29387) {
29388    ffi::sgelq2_(
29389        &m,
29390        &n,
29391        a.as_mut_ptr(),
29392        &lda,
29393        tau.as_mut_ptr(),
29394        work.as_mut_ptr(),
29395        info,
29396    )
29397}
29398
29399#[inline]
29400pub unsafe fn dgelq2(
29401    m: i32,
29402    n: i32,
29403    a: &mut [f64],
29404    lda: i32,
29405    tau: &mut [f64],
29406    work: &mut [f64],
29407    info: &mut i32,
29408) {
29409    ffi::dgelq2_(
29410        &m,
29411        &n,
29412        a.as_mut_ptr(),
29413        &lda,
29414        tau.as_mut_ptr(),
29415        work.as_mut_ptr(),
29416        info,
29417    )
29418}
29419
29420#[inline]
29421pub unsafe fn cgelq2(
29422    m: i32,
29423    n: i32,
29424    a: &mut [c32],
29425    lda: i32,
29426    tau: &mut [c32],
29427    work: &mut [c32],
29428    info: &mut i32,
29429) {
29430    ffi::cgelq2_(
29431        &m,
29432        &n,
29433        a.as_mut_ptr() as *mut _,
29434        &lda,
29435        tau.as_mut_ptr() as *mut _,
29436        work.as_mut_ptr() as *mut _,
29437        info,
29438    )
29439}
29440
29441#[inline]
29442pub unsafe fn zgelq2(
29443    m: i32,
29444    n: i32,
29445    a: &mut [c64],
29446    lda: i32,
29447    tau: &mut [c64],
29448    work: &mut [c64],
29449    info: &mut i32,
29450) {
29451    ffi::zgelq2_(
29452        &m,
29453        &n,
29454        a.as_mut_ptr() as *mut _,
29455        &lda,
29456        tau.as_mut_ptr() as *mut _,
29457        work.as_mut_ptr() as *mut _,
29458        info,
29459    )
29460}
29461
29462#[inline]
29463pub unsafe fn slarfb(
29464    side: u8,
29465    trans: u8,
29466    direct: u8,
29467    storev: u8,
29468    m: i32,
29469    n: i32,
29470    k: i32,
29471    v: &[f32],
29472    ldv: i32,
29473    t: &[f32],
29474    ldt: i32,
29475    c: &mut [f32],
29476    ldc: i32,
29477    work: &mut [f32],
29478    ldwork: i32,
29479) {
29480    ffi::slarfb_(
29481        &(side as c_char),
29482        &(trans as c_char),
29483        &(direct as c_char),
29484        &(storev as c_char),
29485        &m,
29486        &n,
29487        &k,
29488        v.as_ptr(),
29489        &ldv,
29490        t.as_ptr(),
29491        &ldt,
29492        c.as_mut_ptr(),
29493        &ldc,
29494        work.as_mut_ptr(),
29495        &ldwork,
29496    )
29497}
29498
29499#[inline]
29500pub unsafe fn dlarfb(
29501    side: u8,
29502    trans: u8,
29503    direct: u8,
29504    storev: u8,
29505    m: i32,
29506    n: i32,
29507    k: i32,
29508    v: &[f64],
29509    ldv: i32,
29510    t: &[f64],
29511    ldt: i32,
29512    c: &mut [f64],
29513    ldc: i32,
29514    work: &mut [f64],
29515    ldwork: i32,
29516) {
29517    ffi::dlarfb_(
29518        &(side as c_char),
29519        &(trans as c_char),
29520        &(direct as c_char),
29521        &(storev as c_char),
29522        &m,
29523        &n,
29524        &k,
29525        v.as_ptr(),
29526        &ldv,
29527        t.as_ptr(),
29528        &ldt,
29529        c.as_mut_ptr(),
29530        &ldc,
29531        work.as_mut_ptr(),
29532        &ldwork,
29533    )
29534}
29535
29536#[inline]
29537pub unsafe fn clarfb(
29538    side: u8,
29539    trans: u8,
29540    direct: u8,
29541    storev: u8,
29542    m: i32,
29543    n: i32,
29544    k: i32,
29545    v: &[c32],
29546    ldv: i32,
29547    t: &[c32],
29548    ldt: i32,
29549    c: &mut [c32],
29550    ldc: i32,
29551    work: &mut [c32],
29552    ldwork: i32,
29553) {
29554    ffi::clarfb_(
29555        &(side as c_char),
29556        &(trans as c_char),
29557        &(direct as c_char),
29558        &(storev as c_char),
29559        &m,
29560        &n,
29561        &k,
29562        v.as_ptr() as *const _,
29563        &ldv,
29564        t.as_ptr() as *const _,
29565        &ldt,
29566        c.as_mut_ptr() as *mut _,
29567        &ldc,
29568        work.as_mut_ptr() as *mut _,
29569        &ldwork,
29570    )
29571}
29572
29573#[inline]
29574pub unsafe fn zlarfb(
29575    side: u8,
29576    trans: u8,
29577    direct: u8,
29578    storev: u8,
29579    m: i32,
29580    n: i32,
29581    k: i32,
29582    v: &[c64],
29583    ldv: i32,
29584    t: &[c64],
29585    ldt: i32,
29586    c: &mut [c64],
29587    ldc: i32,
29588    work: &mut [c64],
29589    ldwork: i32,
29590) {
29591    ffi::zlarfb_(
29592        &(side as c_char),
29593        &(trans as c_char),
29594        &(direct as c_char),
29595        &(storev as c_char),
29596        &m,
29597        &n,
29598        &k,
29599        v.as_ptr() as *const _,
29600        &ldv,
29601        t.as_ptr() as *const _,
29602        &ldt,
29603        c.as_mut_ptr() as *mut _,
29604        &ldc,
29605        work.as_mut_ptr() as *mut _,
29606        &ldwork,
29607    )
29608}
29609
29610#[inline]
29611pub unsafe fn slarfg(n: i32, alpha: &mut f32, x: &mut [f32], incx: i32, tau: &mut [f32]) {
29612    ffi::slarfg_(&n, alpha, x.as_mut_ptr(), &incx, tau.as_mut_ptr())
29613}
29614
29615#[inline]
29616pub unsafe fn dlarfg(n: i32, alpha: &mut f64, x: &mut [f64], incx: i32, tau: &mut [f64]) {
29617    ffi::dlarfg_(&n, alpha, x.as_mut_ptr(), &incx, tau.as_mut_ptr())
29618}
29619
29620#[inline]
29621pub unsafe fn clarfg(n: i32, alpha: &mut c32, x: &mut [c32], incx: i32, tau: &mut [c32]) {
29622    ffi::clarfg_(
29623        &n,
29624        alpha as *mut _ as *mut _,
29625        x.as_mut_ptr() as *mut _,
29626        &incx,
29627        tau.as_mut_ptr() as *mut _,
29628    )
29629}
29630
29631#[inline]
29632pub unsafe fn zlarfg(n: i32, alpha: &mut c64, x: &mut [c64], incx: i32, tau: &mut [c64]) {
29633    ffi::zlarfg_(
29634        &n,
29635        alpha as *mut _ as *mut _,
29636        x.as_mut_ptr() as *mut _,
29637        &incx,
29638        tau.as_mut_ptr() as *mut _,
29639    )
29640}
29641
29642#[inline]
29643pub unsafe fn slarft(
29644    direct: u8,
29645    storev: u8,
29646    n: i32,
29647    k: i32,
29648    v: &[f32],
29649    ldv: i32,
29650    tau: &[f32],
29651    t: &mut [f32],
29652    ldt: i32,
29653) {
29654    ffi::slarft_(
29655        &(direct as c_char),
29656        &(storev as c_char),
29657        &n,
29658        &k,
29659        v.as_ptr(),
29660        &ldv,
29661        tau.as_ptr(),
29662        t.as_mut_ptr(),
29663        &ldt,
29664    )
29665}
29666
29667#[inline]
29668pub unsafe fn dlarft(
29669    direct: u8,
29670    storev: u8,
29671    n: i32,
29672    k: i32,
29673    v: &[f64],
29674    ldv: i32,
29675    tau: &[f64],
29676    t: &mut [f64],
29677    ldt: i32,
29678) {
29679    ffi::dlarft_(
29680        &(direct as c_char),
29681        &(storev as c_char),
29682        &n,
29683        &k,
29684        v.as_ptr(),
29685        &ldv,
29686        tau.as_ptr(),
29687        t.as_mut_ptr(),
29688        &ldt,
29689    )
29690}
29691
29692#[inline]
29693pub unsafe fn clarft(
29694    direct: u8,
29695    storev: u8,
29696    n: i32,
29697    k: i32,
29698    v: &[c32],
29699    ldv: i32,
29700    tau: &[c32],
29701    t: &mut [c32],
29702    ldt: i32,
29703) {
29704    ffi::clarft_(
29705        &(direct as c_char),
29706        &(storev as c_char),
29707        &n,
29708        &k,
29709        v.as_ptr() as *const _,
29710        &ldv,
29711        tau.as_ptr() as *const _,
29712        t.as_mut_ptr() as *mut _,
29713        &ldt,
29714    )
29715}
29716
29717#[inline]
29718pub unsafe fn zlarft(
29719    direct: u8,
29720    storev: u8,
29721    n: i32,
29722    k: i32,
29723    v: &[c64],
29724    ldv: i32,
29725    tau: &[c64],
29726    t: &mut [c64],
29727    ldt: i32,
29728) {
29729    ffi::zlarft_(
29730        &(direct as c_char),
29731        &(storev as c_char),
29732        &n,
29733        &k,
29734        v.as_ptr() as *const _,
29735        &ldv,
29736        tau.as_ptr() as *const _,
29737        t.as_mut_ptr() as *mut _,
29738        &ldt,
29739    )
29740}
29741
29742#[inline]
29743pub unsafe fn slarfx(
29744    side: u8,
29745    m: i32,
29746    n: i32,
29747    v: &[f32],
29748    tau: &[f32],
29749    c: &mut [f32],
29750    ldc: i32,
29751    work: &mut [f32],
29752) {
29753    ffi::slarfx_(
29754        &(side as c_char),
29755        &m,
29756        &n,
29757        v.as_ptr(),
29758        tau.as_ptr(),
29759        c.as_mut_ptr(),
29760        &ldc,
29761        work.as_mut_ptr(),
29762    )
29763}
29764
29765#[inline]
29766pub unsafe fn dlarfx(
29767    side: u8,
29768    m: i32,
29769    n: i32,
29770    v: &[f64],
29771    tau: &[f64],
29772    c: &mut [f64],
29773    ldc: i32,
29774    work: &mut [f64],
29775) {
29776    ffi::dlarfx_(
29777        &(side as c_char),
29778        &m,
29779        &n,
29780        v.as_ptr(),
29781        tau.as_ptr(),
29782        c.as_mut_ptr(),
29783        &ldc,
29784        work.as_mut_ptr(),
29785    )
29786}
29787
29788#[inline]
29789pub unsafe fn clarfx(
29790    side: u8,
29791    m: i32,
29792    n: i32,
29793    v: &[c32],
29794    tau: &[c32],
29795    c: &mut [c32],
29796    ldc: i32,
29797    work: &mut [c32],
29798) {
29799    ffi::clarfx_(
29800        &(side as c_char),
29801        &m,
29802        &n,
29803        v.as_ptr() as *const _,
29804        tau.as_ptr() as *const _,
29805        c.as_mut_ptr() as *mut _,
29806        &ldc,
29807        work.as_mut_ptr() as *mut _,
29808    )
29809}
29810
29811#[inline]
29812pub unsafe fn zlarfx(
29813    side: u8,
29814    m: i32,
29815    n: i32,
29816    v: &[c64],
29817    tau: &[c64],
29818    c: &mut [c64],
29819    ldc: i32,
29820    work: &mut [c64],
29821) {
29822    ffi::zlarfx_(
29823        &(side as c_char),
29824        &m,
29825        &n,
29826        v.as_ptr() as *const _,
29827        tau.as_ptr() as *const _,
29828        c.as_mut_ptr() as *mut _,
29829        &ldc,
29830        work.as_mut_ptr() as *mut _,
29831    )
29832}
29833
29834#[inline]
29835pub unsafe fn slatms(
29836    m: i32,
29837    n: i32,
29838    dist: u8,
29839    iseed: &mut [i32],
29840    sym: u8,
29841    d: &mut [f32],
29842    mode: &[i32],
29843    cond: &[f32],
29844    dmax: &[f32],
29845    kl: i32,
29846    ku: i32,
29847    pack: u8,
29848    a: &mut [f32],
29849    lda: i32,
29850    work: &mut [f32],
29851    info: &mut i32,
29852) {
29853    ffi::slatms_(
29854        &m,
29855        &n,
29856        &(dist as c_char),
29857        iseed.as_mut_ptr(),
29858        &(sym as c_char),
29859        d.as_mut_ptr(),
29860        mode.as_ptr(),
29861        cond.as_ptr(),
29862        dmax.as_ptr(),
29863        &kl,
29864        &ku,
29865        &(pack as c_char),
29866        a.as_mut_ptr(),
29867        &lda,
29868        work.as_mut_ptr(),
29869        info,
29870    )
29871}
29872
29873#[inline]
29874pub unsafe fn dlatms(
29875    m: i32,
29876    n: i32,
29877    dist: u8,
29878    iseed: &mut [i32],
29879    sym: u8,
29880    d: &mut [f64],
29881    mode: &[i32],
29882    cond: &[f64],
29883    dmax: &[f64],
29884    kl: i32,
29885    ku: i32,
29886    pack: u8,
29887    a: &mut [f64],
29888    lda: i32,
29889    work: &mut [f64],
29890    info: &mut i32,
29891) {
29892    ffi::dlatms_(
29893        &m,
29894        &n,
29895        &(dist as c_char),
29896        iseed.as_mut_ptr(),
29897        &(sym as c_char),
29898        d.as_mut_ptr(),
29899        mode.as_ptr(),
29900        cond.as_ptr(),
29901        dmax.as_ptr(),
29902        &kl,
29903        &ku,
29904        &(pack as c_char),
29905        a.as_mut_ptr(),
29906        &lda,
29907        work.as_mut_ptr(),
29908        info,
29909    )
29910}
29911
29912#[inline]
29913pub unsafe fn clatms(
29914    m: i32,
29915    n: i32,
29916    dist: u8,
29917    iseed: &mut [i32],
29918    sym: u8,
29919    d: &mut [f32],
29920    mode: &[i32],
29921    cond: &[f32],
29922    dmax: &[f32],
29923    kl: i32,
29924    ku: i32,
29925    pack: u8,
29926    a: &mut [c32],
29927    lda: i32,
29928    work: &mut [c32],
29929    info: &mut i32,
29930) {
29931    ffi::clatms_(
29932        &m,
29933        &n,
29934        &(dist as c_char),
29935        iseed.as_mut_ptr(),
29936        &(sym as c_char),
29937        d.as_mut_ptr(),
29938        mode.as_ptr(),
29939        cond.as_ptr(),
29940        dmax.as_ptr(),
29941        &kl,
29942        &ku,
29943        &(pack as c_char),
29944        a.as_mut_ptr() as *mut _,
29945        &lda,
29946        work.as_mut_ptr() as *mut _,
29947        info,
29948    )
29949}
29950
29951#[inline]
29952pub unsafe fn zlatms(
29953    m: i32,
29954    n: i32,
29955    dist: u8,
29956    iseed: &mut [i32],
29957    sym: u8,
29958    d: &mut [f64],
29959    mode: &[i32],
29960    cond: &[f64],
29961    dmax: &[f64],
29962    kl: i32,
29963    ku: i32,
29964    pack: u8,
29965    a: &mut [c64],
29966    lda: i32,
29967    work: &mut [c64],
29968    info: &mut i32,
29969) {
29970    ffi::zlatms_(
29971        &m,
29972        &n,
29973        &(dist as c_char),
29974        iseed.as_mut_ptr(),
29975        &(sym as c_char),
29976        d.as_mut_ptr(),
29977        mode.as_ptr(),
29978        cond.as_ptr(),
29979        dmax.as_ptr(),
29980        &kl,
29981        &ku,
29982        &(pack as c_char),
29983        a.as_mut_ptr() as *mut _,
29984        &lda,
29985        work.as_mut_ptr() as *mut _,
29986        info,
29987    )
29988}
29989
29990#[inline]
29991pub unsafe fn slag2d(
29992    m: i32,
29993    n: i32,
29994    sa: &[f32],
29995    ldsa: i32,
29996    a: &mut [f64],
29997    lda: i32,
29998    info: &mut i32,
29999) {
30000    ffi::slag2d_(&m, &n, sa.as_ptr(), &ldsa, a.as_mut_ptr(), &lda, info)
30001}
30002
30003#[inline]
30004pub unsafe fn dlag2s(
30005    m: i32,
30006    n: i32,
30007    a: &[f64],
30008    lda: i32,
30009    sa: &mut [f32],
30010    ldsa: i32,
30011    info: &mut i32,
30012) {
30013    ffi::dlag2s_(&m, &n, a.as_ptr(), &lda, sa.as_mut_ptr(), &ldsa, info)
30014}
30015
30016#[inline]
30017pub unsafe fn clag2z(
30018    m: i32,
30019    n: i32,
30020    sa: &[c32],
30021    ldsa: i32,
30022    a: &mut [c64],
30023    lda: i32,
30024    info: &mut i32,
30025) {
30026    ffi::clag2z_(
30027        &m,
30028        &n,
30029        sa.as_ptr() as *const _,
30030        &ldsa,
30031        a.as_mut_ptr() as *mut _,
30032        &lda,
30033        info,
30034    )
30035}
30036
30037#[inline]
30038pub unsafe fn zlag2c(
30039    m: i32,
30040    n: i32,
30041    a: &[c64],
30042    lda: i32,
30043    sa: &mut [c32],
30044    ldsa: i32,
30045    info: &mut i32,
30046) {
30047    ffi::zlag2c_(
30048        &m,
30049        &n,
30050        a.as_ptr() as *const _,
30051        &lda,
30052        sa.as_mut_ptr() as *mut _,
30053        &ldsa,
30054        info,
30055    )
30056}
30057
30058#[inline]
30059pub unsafe fn slauum(uplo: u8, n: i32, a: &mut [f32], lda: i32, info: &mut i32) {
30060    ffi::slauum_(&(uplo as c_char), &n, a.as_mut_ptr(), &lda, info)
30061}
30062
30063#[inline]
30064pub unsafe fn dlauum(uplo: u8, n: i32, a: &mut [f64], lda: i32, info: &mut i32) {
30065    ffi::dlauum_(&(uplo as c_char), &n, a.as_mut_ptr(), &lda, info)
30066}
30067
30068#[inline]
30069pub unsafe fn clauum(uplo: u8, n: i32, a: &mut [c32], lda: i32, info: &mut i32) {
30070    ffi::clauum_(&(uplo as c_char), &n, a.as_mut_ptr() as *mut _, &lda, info)
30071}
30072
30073#[inline]
30074pub unsafe fn zlauum(uplo: u8, n: i32, a: &mut [c64], lda: i32, info: &mut i32) {
30075    ffi::zlauum_(&(uplo as c_char), &n, a.as_mut_ptr() as *mut _, &lda, info)
30076}
30077
30078#[inline]
30079pub unsafe fn slagge(
30080    m: i32,
30081    n: i32,
30082    kl: i32,
30083    ku: i32,
30084    d: &[f32],
30085    a: &mut [f32],
30086    lda: i32,
30087    iseed: &mut [i32],
30088    work: &mut [f32],
30089    info: &mut i32,
30090) {
30091    ffi::slagge_(
30092        &m,
30093        &n,
30094        &kl,
30095        &ku,
30096        d.as_ptr(),
30097        a.as_mut_ptr(),
30098        &lda,
30099        iseed.as_mut_ptr(),
30100        work.as_mut_ptr(),
30101        info,
30102    )
30103}
30104
30105#[inline]
30106pub unsafe fn dlagge(
30107    m: i32,
30108    n: i32,
30109    kl: i32,
30110    ku: i32,
30111    d: &[f64],
30112    a: &mut [f64],
30113    lda: i32,
30114    iseed: &mut [i32],
30115    work: &mut [f64],
30116    info: &mut i32,
30117) {
30118    ffi::dlagge_(
30119        &m,
30120        &n,
30121        &kl,
30122        &ku,
30123        d.as_ptr(),
30124        a.as_mut_ptr(),
30125        &lda,
30126        iseed.as_mut_ptr(),
30127        work.as_mut_ptr(),
30128        info,
30129    )
30130}
30131
30132#[inline]
30133pub unsafe fn clagge(
30134    m: i32,
30135    n: i32,
30136    kl: i32,
30137    ku: i32,
30138    d: &[f32],
30139    a: &mut [c32],
30140    lda: i32,
30141    iseed: &mut [i32],
30142    work: &mut [c32],
30143    info: &mut i32,
30144) {
30145    ffi::clagge_(
30146        &m,
30147        &n,
30148        &kl,
30149        &ku,
30150        d.as_ptr(),
30151        a.as_mut_ptr() as *mut _,
30152        &lda,
30153        iseed.as_mut_ptr(),
30154        work.as_mut_ptr() as *mut _,
30155        info,
30156    )
30157}
30158
30159#[inline]
30160pub unsafe fn zlagge(
30161    m: i32,
30162    n: i32,
30163    kl: i32,
30164    ku: i32,
30165    d: &[f64],
30166    a: &mut [c64],
30167    lda: i32,
30168    iseed: &mut [i32],
30169    work: &mut [c64],
30170    info: &mut i32,
30171) {
30172    ffi::zlagge_(
30173        &m,
30174        &n,
30175        &kl,
30176        &ku,
30177        d.as_ptr(),
30178        a.as_mut_ptr() as *mut _,
30179        &lda,
30180        iseed.as_mut_ptr(),
30181        work.as_mut_ptr() as *mut _,
30182        info,
30183    )
30184}
30185
30186#[inline]
30187pub unsafe fn slascl(
30188    _type: u8,
30189    kl: i32,
30190    ku: i32,
30191    cfrom: &[f32],
30192    cto: &[f32],
30193    m: i32,
30194    n: i32,
30195    a: &mut [f32],
30196    lda: i32,
30197    info: &mut i32,
30198) {
30199    ffi::slascl_(
30200        &(_type as c_char),
30201        &kl,
30202        &ku,
30203        cfrom.as_ptr(),
30204        cto.as_ptr(),
30205        &m,
30206        &n,
30207        a.as_mut_ptr(),
30208        &lda,
30209        info,
30210    )
30211}
30212
30213#[inline]
30214pub unsafe fn dlascl(
30215    _type: u8,
30216    kl: i32,
30217    ku: i32,
30218    cfrom: &[f64],
30219    cto: &[f64],
30220    m: i32,
30221    n: i32,
30222    a: &mut [f64],
30223    lda: i32,
30224    info: &mut i32,
30225) {
30226    ffi::dlascl_(
30227        &(_type as c_char),
30228        &kl,
30229        &ku,
30230        cfrom.as_ptr(),
30231        cto.as_ptr(),
30232        &m,
30233        &n,
30234        a.as_mut_ptr(),
30235        &lda,
30236        info,
30237    )
30238}
30239
30240#[inline]
30241pub unsafe fn clascl(
30242    _type: u8,
30243    kl: i32,
30244    ku: i32,
30245    cfrom: &[f32],
30246    cto: &[f32],
30247    m: i32,
30248    n: i32,
30249    a: &mut [c32],
30250    lda: i32,
30251    info: &mut i32,
30252) {
30253    ffi::clascl_(
30254        &(_type as c_char),
30255        &kl,
30256        &ku,
30257        cfrom.as_ptr(),
30258        cto.as_ptr(),
30259        &m,
30260        &n,
30261        a.as_mut_ptr() as *mut _,
30262        &lda,
30263        info,
30264    )
30265}
30266
30267#[inline]
30268pub unsafe fn zlascl(
30269    _type: u8,
30270    kl: i32,
30271    ku: i32,
30272    cfrom: &[f64],
30273    cto: &[f64],
30274    m: i32,
30275    n: i32,
30276    a: &mut [c64],
30277    lda: i32,
30278    info: &mut i32,
30279) {
30280    ffi::zlascl_(
30281        &(_type as c_char),
30282        &kl,
30283        &ku,
30284        cfrom.as_ptr(),
30285        cto.as_ptr(),
30286        &m,
30287        &n,
30288        a.as_mut_ptr() as *mut _,
30289        &lda,
30290        info,
30291    )
30292}
30293
30294#[inline]
30295pub unsafe fn slaset(uplo: u8, m: i32, n: i32, alpha: f32, beta: f32, a: &mut [f32], lda: i32) {
30296    ffi::slaset_(
30297        &(uplo as c_char),
30298        &m,
30299        &n,
30300        &alpha,
30301        &beta,
30302        a.as_mut_ptr(),
30303        &lda,
30304    )
30305}
30306
30307#[inline]
30308pub unsafe fn dlaset(uplo: u8, m: i32, n: i32, alpha: f64, beta: f64, a: &mut [f64], lda: i32) {
30309    ffi::dlaset_(
30310        &(uplo as c_char),
30311        &m,
30312        &n,
30313        &alpha,
30314        &beta,
30315        a.as_mut_ptr(),
30316        &lda,
30317    )
30318}
30319
30320#[inline]
30321pub unsafe fn claset(uplo: u8, m: i32, n: i32, alpha: c32, beta: c32, a: &mut [c32], lda: i32) {
30322    ffi::claset_(
30323        &(uplo as c_char),
30324        &m,
30325        &n,
30326        &alpha as *const _ as *const _,
30327        &beta as *const _ as *const _,
30328        a.as_mut_ptr() as *mut _,
30329        &lda,
30330    )
30331}
30332
30333#[inline]
30334pub unsafe fn zlaset(uplo: u8, m: i32, n: i32, alpha: c64, beta: c64, a: &mut [c64], lda: i32) {
30335    ffi::zlaset_(
30336        &(uplo as c_char),
30337        &m,
30338        &n,
30339        &alpha as *const _ as *const _,
30340        &beta as *const _ as *const _,
30341        a.as_mut_ptr() as *mut _,
30342        &lda,
30343    )
30344}
30345
30346#[inline]
30347pub unsafe fn slasrt(id: u8, n: i32, d: &mut [f32], info: &mut i32) {
30348    ffi::slasrt_(&(id as c_char), &n, d.as_mut_ptr(), info)
30349}
30350
30351#[inline]
30352pub unsafe fn dlasrt(id: u8, n: i32, d: &mut [f64], info: &mut i32) {
30353    ffi::dlasrt_(&(id as c_char), &n, d.as_mut_ptr(), info)
30354}
30355
30356#[inline]
30357pub unsafe fn claghe(
30358    n: i32,
30359    k: i32,
30360    d: &[f32],
30361    a: &mut [c32],
30362    lda: i32,
30363    iseed: &mut [i32],
30364    work: &mut [c32],
30365    info: &mut i32,
30366) {
30367    ffi::claghe_(
30368        &n,
30369        &k,
30370        d.as_ptr(),
30371        a.as_mut_ptr() as *mut _,
30372        &lda,
30373        iseed.as_mut_ptr(),
30374        work.as_mut_ptr() as *mut _,
30375        info,
30376    )
30377}
30378
30379#[inline]
30380pub unsafe fn zlaghe(
30381    n: i32,
30382    k: i32,
30383    d: &[f64],
30384    a: &mut [c64],
30385    lda: i32,
30386    iseed: &mut [i32],
30387    work: &mut [c64],
30388    info: &mut i32,
30389) {
30390    ffi::zlaghe_(
30391        &n,
30392        &k,
30393        d.as_ptr(),
30394        a.as_mut_ptr() as *mut _,
30395        &lda,
30396        iseed.as_mut_ptr(),
30397        work.as_mut_ptr() as *mut _,
30398        info,
30399    )
30400}
30401
30402#[inline]
30403pub unsafe fn slagsy(
30404    n: i32,
30405    k: i32,
30406    d: &[f32],
30407    a: &mut [f32],
30408    lda: i32,
30409    iseed: &mut [i32],
30410    work: &mut [f32],
30411    info: &mut i32,
30412) {
30413    ffi::slagsy_(
30414        &n,
30415        &k,
30416        d.as_ptr(),
30417        a.as_mut_ptr(),
30418        &lda,
30419        iseed.as_mut_ptr(),
30420        work.as_mut_ptr(),
30421        info,
30422    )
30423}
30424
30425#[inline]
30426pub unsafe fn dlagsy(
30427    n: i32,
30428    k: i32,
30429    d: &[f64],
30430    a: &mut [f64],
30431    lda: i32,
30432    iseed: &mut [i32],
30433    work: &mut [f64],
30434    info: &mut i32,
30435) {
30436    ffi::dlagsy_(
30437        &n,
30438        &k,
30439        d.as_ptr(),
30440        a.as_mut_ptr(),
30441        &lda,
30442        iseed.as_mut_ptr(),
30443        work.as_mut_ptr(),
30444        info,
30445    )
30446}
30447
30448#[inline]
30449pub unsafe fn clagsy(
30450    n: i32,
30451    k: i32,
30452    d: &[f32],
30453    a: &mut [c32],
30454    lda: i32,
30455    iseed: &mut [i32],
30456    work: &mut [c32],
30457    info: &mut i32,
30458) {
30459    ffi::clagsy_(
30460        &n,
30461        &k,
30462        d.as_ptr(),
30463        a.as_mut_ptr() as *mut _,
30464        &lda,
30465        iseed.as_mut_ptr(),
30466        work.as_mut_ptr() as *mut _,
30467        info,
30468    )
30469}
30470
30471#[inline]
30472pub unsafe fn zlagsy(
30473    n: i32,
30474    k: i32,
30475    d: &[f64],
30476    a: &mut [c64],
30477    lda: i32,
30478    iseed: &mut [i32],
30479    work: &mut [c64],
30480    info: &mut i32,
30481) {
30482    ffi::zlagsy_(
30483        &n,
30484        &k,
30485        d.as_ptr(),
30486        a.as_mut_ptr() as *mut _,
30487        &lda,
30488        iseed.as_mut_ptr(),
30489        work.as_mut_ptr() as *mut _,
30490        info,
30491    )
30492}
30493
30494#[inline]
30495pub unsafe fn slapmr(forwrd: &[i32], m: i32, n: i32, x: &mut [f32], ldx: i32, k: &mut i32) {
30496    ffi::slapmr_(forwrd.as_ptr(), &m, &n, x.as_mut_ptr(), &ldx, k)
30497}
30498
30499#[inline]
30500pub unsafe fn dlapmr(forwrd: &[i32], m: i32, n: i32, x: &mut [f64], ldx: i32, k: &mut i32) {
30501    ffi::dlapmr_(forwrd.as_ptr(), &m, &n, x.as_mut_ptr(), &ldx, k)
30502}
30503
30504#[inline]
30505pub unsafe fn clapmr(forwrd: &[i32], m: i32, n: i32, x: &mut [c32], ldx: i32, k: &mut i32) {
30506    ffi::clapmr_(forwrd.as_ptr(), &m, &n, x.as_mut_ptr() as *mut _, &ldx, k)
30507}
30508
30509#[inline]
30510pub unsafe fn zlapmr(forwrd: &[i32], m: i32, n: i32, x: &mut [c64], ldx: i32, k: &mut i32) {
30511    ffi::zlapmr_(forwrd.as_ptr(), &m, &n, x.as_mut_ptr() as *mut _, &ldx, k)
30512}
30513
30514#[inline]
30515pub unsafe fn slapmt(forwrd: &[i32], m: i32, n: i32, x: &mut [f32], ldx: i32, k: &mut i32) {
30516    ffi::slapmt_(forwrd.as_ptr(), &m, &n, x.as_mut_ptr(), &ldx, k)
30517}
30518
30519#[inline]
30520pub unsafe fn dlapmt(forwrd: &[i32], m: i32, n: i32, x: &mut [f64], ldx: i32, k: &mut i32) {
30521    ffi::dlapmt_(forwrd.as_ptr(), &m, &n, x.as_mut_ptr(), &ldx, k)
30522}
30523
30524#[inline]
30525pub unsafe fn clapmt(forwrd: &[i32], m: i32, n: i32, x: &mut [c32], ldx: i32, k: &mut i32) {
30526    ffi::clapmt_(forwrd.as_ptr(), &m, &n, x.as_mut_ptr() as *mut _, &ldx, k)
30527}
30528
30529#[inline]
30530pub unsafe fn zlapmt(forwrd: &[i32], m: i32, n: i32, x: &mut [c64], ldx: i32, k: &mut i32) {
30531    ffi::zlapmt_(forwrd.as_ptr(), &m, &n, x.as_mut_ptr() as *mut _, &ldx, k)
30532}
30533
30534#[inline]
30535pub unsafe fn slapy2(x: &[f32], y: &[f32]) -> f32 {
30536    ffi::slapy2_(x.as_ptr(), y.as_ptr())
30537}
30538
30539#[inline]
30540pub unsafe fn dlapy2(x: &[f64], y: &[f64]) -> f64 {
30541    ffi::dlapy2_(x.as_ptr(), y.as_ptr())
30542}
30543
30544#[inline]
30545pub unsafe fn slapy3(x: &[f32], y: &[f32], z: &[f32]) -> f32 {
30546    ffi::slapy3_(x.as_ptr(), y.as_ptr(), z.as_ptr())
30547}
30548
30549#[inline]
30550pub unsafe fn dlapy3(x: &[f64], y: &[f64], z: &[f64]) -> f64 {
30551    ffi::dlapy3_(x.as_ptr(), y.as_ptr(), z.as_ptr())
30552}
30553
30554#[inline]
30555pub unsafe fn slartgp(f: &[f32], g: &[f32], cs: &mut [f32], sn: &mut [f32], r: &mut [f32]) {
30556    ffi::slartgp_(
30557        f.as_ptr(),
30558        g.as_ptr(),
30559        cs.as_mut_ptr(),
30560        sn.as_mut_ptr(),
30561        r.as_mut_ptr(),
30562    )
30563}
30564
30565#[inline]
30566pub unsafe fn dlartgp(f: &[f64], g: &[f64], cs: &mut [f64], sn: &mut [f64], r: &mut [f64]) {
30567    ffi::dlartgp_(
30568        f.as_ptr(),
30569        g.as_ptr(),
30570        cs.as_mut_ptr(),
30571        sn.as_mut_ptr(),
30572        r.as_mut_ptr(),
30573    )
30574}
30575
30576#[inline]
30577pub unsafe fn slartgs(x: &[f32], y: &[f32], sigma: &[f32], cs: &mut [f32], sn: &mut [f32]) {
30578    ffi::slartgs_(
30579        x.as_ptr(),
30580        y.as_ptr(),
30581        sigma.as_ptr(),
30582        cs.as_mut_ptr(),
30583        sn.as_mut_ptr(),
30584    )
30585}
30586
30587#[inline]
30588pub unsafe fn dlartgs(x: &[f64], y: &[f64], sigma: &[f64], cs: &mut [f64], sn: &mut [f64]) {
30589    ffi::dlartgs_(
30590        x.as_ptr(),
30591        y.as_ptr(),
30592        sigma.as_ptr(),
30593        cs.as_mut_ptr(),
30594        sn.as_mut_ptr(),
30595    )
30596}
30597
30598#[inline]
30599pub unsafe fn cbbcsd(
30600    jobu1: u8,
30601    jobu2: u8,
30602    jobv1t: u8,
30603    jobv2t: u8,
30604    trans: u8,
30605    m: i32,
30606    p: i32,
30607    q: i32,
30608    theta: &mut [f32],
30609    phi: &mut [f32],
30610    u1: &mut [c32],
30611    ldu1: i32,
30612    u2: &mut [c32],
30613    ldu2: i32,
30614    v1t: &mut [c32],
30615    ldv1t: i32,
30616    v2t: &mut [c32],
30617    ldv2t: i32,
30618    b11d: &mut [f32],
30619    b11e: &mut [f32],
30620    b12d: &mut [f32],
30621    b12e: &mut [f32],
30622    b21d: &mut [f32],
30623    b21e: &mut [f32],
30624    b22d: &mut [f32],
30625    b22e: &mut [f32],
30626    rwork: &mut [f32],
30627    lrwork: i32,
30628    info: &mut i32,
30629) {
30630    ffi::cbbcsd_(
30631        &(jobu1 as c_char),
30632        &(jobu2 as c_char),
30633        &(jobv1t as c_char),
30634        &(jobv2t as c_char),
30635        &(trans as c_char),
30636        &m,
30637        &p,
30638        &q,
30639        theta.as_mut_ptr(),
30640        phi.as_mut_ptr(),
30641        u1.as_mut_ptr() as *mut _,
30642        &ldu1,
30643        u2.as_mut_ptr() as *mut _,
30644        &ldu2,
30645        v1t.as_mut_ptr() as *mut _,
30646        &ldv1t,
30647        v2t.as_mut_ptr() as *mut _,
30648        &ldv2t,
30649        b11d.as_mut_ptr(),
30650        b11e.as_mut_ptr(),
30651        b12d.as_mut_ptr(),
30652        b12e.as_mut_ptr(),
30653        b21d.as_mut_ptr(),
30654        b21e.as_mut_ptr(),
30655        b22d.as_mut_ptr(),
30656        b22e.as_mut_ptr(),
30657        rwork.as_mut_ptr(),
30658        &lrwork,
30659        info,
30660    )
30661}
30662
30663#[inline]
30664pub unsafe fn cheswapr(uplo: u8, n: i32, a: &mut [c32], i1: &[i32], i2: &[i32]) {
30665    ffi::cheswapr_(
30666        &(uplo as c_char),
30667        &n,
30668        a.as_mut_ptr() as *mut _,
30669        i1.as_ptr(),
30670        i2.as_ptr(),
30671    )
30672}
30673
30674#[inline]
30675pub unsafe fn chetri2(
30676    uplo: u8,
30677    n: i32,
30678    a: &mut [c32],
30679    lda: i32,
30680    ipiv: &[i32],
30681    work: &mut [c32],
30682    lwork: i32,
30683    info: &mut i32,
30684) {
30685    ffi::chetri2_(
30686        &(uplo as c_char),
30687        &n,
30688        a.as_mut_ptr() as *mut _,
30689        &lda,
30690        ipiv.as_ptr(),
30691        work.as_mut_ptr() as *mut _,
30692        &lwork,
30693        info,
30694    )
30695}
30696
30697#[inline]
30698pub unsafe fn chetri2x(
30699    uplo: u8,
30700    n: i32,
30701    a: &mut [c32],
30702    lda: i32,
30703    ipiv: &[i32],
30704    work: &mut [c32],
30705    nb: i32,
30706    info: &mut i32,
30707) {
30708    ffi::chetri2x_(
30709        &(uplo as c_char),
30710        &n,
30711        a.as_mut_ptr() as *mut _,
30712        &lda,
30713        ipiv.as_ptr(),
30714        work.as_mut_ptr() as *mut _,
30715        &nb,
30716        info,
30717    )
30718}
30719
30720#[inline]
30721pub unsafe fn chetrs2(
30722    uplo: u8,
30723    n: i32,
30724    nrhs: i32,
30725    a: &[c32],
30726    lda: i32,
30727    ipiv: &[i32],
30728    b: &mut [c32],
30729    ldb: i32,
30730    work: &mut [c32],
30731    info: &mut i32,
30732) {
30733    ffi::chetrs2_(
30734        &(uplo as c_char),
30735        &n,
30736        &nrhs,
30737        a.as_ptr() as *const _,
30738        &lda,
30739        ipiv.as_ptr(),
30740        b.as_mut_ptr() as *mut _,
30741        &ldb,
30742        work.as_mut_ptr() as *mut _,
30743        info,
30744    )
30745}
30746
30747#[inline]
30748pub unsafe fn csyconv(
30749    uplo: u8,
30750    way: u8,
30751    n: i32,
30752    a: &mut [c32],
30753    lda: i32,
30754    ipiv: &[i32],
30755    work: &mut [c32],
30756    info: &mut i32,
30757) {
30758    ffi::csyconv_(
30759        &(uplo as c_char),
30760        &(way as c_char),
30761        &n,
30762        a.as_mut_ptr() as *mut _,
30763        &lda,
30764        ipiv.as_ptr(),
30765        work.as_mut_ptr() as *mut _,
30766        info,
30767    )
30768}
30769
30770#[inline]
30771pub unsafe fn csyswapr(uplo: u8, n: i32, a: &mut [c32], i1: &[i32], i2: &[i32]) {
30772    ffi::csyswapr_(
30773        &(uplo as c_char),
30774        &n,
30775        a.as_mut_ptr() as *mut _,
30776        i1.as_ptr(),
30777        i2.as_ptr(),
30778    )
30779}
30780
30781#[inline]
30782pub unsafe fn csytri2(
30783    uplo: u8,
30784    n: i32,
30785    a: &mut [c32],
30786    lda: i32,
30787    ipiv: &[i32],
30788    work: &mut [c32],
30789    lwork: i32,
30790    info: &mut i32,
30791) {
30792    ffi::csytri2_(
30793        &(uplo as c_char),
30794        &n,
30795        a.as_mut_ptr() as *mut _,
30796        &lda,
30797        ipiv.as_ptr(),
30798        work.as_mut_ptr() as *mut _,
30799        &lwork,
30800        info,
30801    )
30802}
30803
30804#[inline]
30805pub unsafe fn csytri2x(
30806    uplo: u8,
30807    n: i32,
30808    a: &mut [c32],
30809    lda: i32,
30810    ipiv: &[i32],
30811    work: &mut [c32],
30812    nb: i32,
30813    info: &mut i32,
30814) {
30815    ffi::csytri2x_(
30816        &(uplo as c_char),
30817        &n,
30818        a.as_mut_ptr() as *mut _,
30819        &lda,
30820        ipiv.as_ptr(),
30821        work.as_mut_ptr() as *mut _,
30822        &nb,
30823        info,
30824    )
30825}
30826
30827#[inline]
30828pub unsafe fn csytrs2(
30829    uplo: u8,
30830    n: i32,
30831    nrhs: i32,
30832    a: &[c32],
30833    lda: i32,
30834    ipiv: &[i32],
30835    b: &mut [c32],
30836    ldb: i32,
30837    work: &mut [c32],
30838    info: &mut i32,
30839) {
30840    ffi::csytrs2_(
30841        &(uplo as c_char),
30842        &n,
30843        &nrhs,
30844        a.as_ptr() as *const _,
30845        &lda,
30846        ipiv.as_ptr(),
30847        b.as_mut_ptr() as *mut _,
30848        &ldb,
30849        work.as_mut_ptr() as *mut _,
30850        info,
30851    )
30852}
30853
30854#[inline]
30855pub unsafe fn cunbdb(
30856    trans: u8,
30857    signs: u8,
30858    m: i32,
30859    p: i32,
30860    q: i32,
30861    x11: &mut [c32],
30862    ldx11: i32,
30863    x12: &mut [c32],
30864    ldx12: i32,
30865    x21: &mut [c32],
30866    ldx21: i32,
30867    x22: &mut [c32],
30868    ldx22: i32,
30869    theta: &mut [f32],
30870    phi: &mut [f32],
30871    taup1: &mut [c32],
30872    taup2: &mut [c32],
30873    tauq1: &mut [c32],
30874    tauq2: &mut [c32],
30875    work: &mut [c32],
30876    lwork: i32,
30877    info: &mut i32,
30878) {
30879    ffi::cunbdb_(
30880        &(trans as c_char),
30881        &(signs as c_char),
30882        &m,
30883        &p,
30884        &q,
30885        x11.as_mut_ptr() as *mut _,
30886        &ldx11,
30887        x12.as_mut_ptr() as *mut _,
30888        &ldx12,
30889        x21.as_mut_ptr() as *mut _,
30890        &ldx21,
30891        x22.as_mut_ptr() as *mut _,
30892        &ldx22,
30893        theta.as_mut_ptr(),
30894        phi.as_mut_ptr(),
30895        taup1.as_mut_ptr() as *mut _,
30896        taup2.as_mut_ptr() as *mut _,
30897        tauq1.as_mut_ptr() as *mut _,
30898        tauq2.as_mut_ptr() as *mut _,
30899        work.as_mut_ptr() as *mut _,
30900        &lwork,
30901        info,
30902    )
30903}
30904
30905#[inline]
30906pub unsafe fn cuncsd(
30907    jobu1: u8,
30908    jobu2: u8,
30909    jobv1t: u8,
30910    jobv2t: u8,
30911    trans: u8,
30912    signs: u8,
30913    m: i32,
30914    p: i32,
30915    q: i32,
30916    x11: &mut [c32],
30917    ldx11: i32,
30918    x12: &mut [c32],
30919    ldx12: i32,
30920    x21: &mut [c32],
30921    ldx21: i32,
30922    x22: &mut [c32],
30923    ldx22: i32,
30924    theta: &mut [f32],
30925    u1: &mut [c32],
30926    ldu1: i32,
30927    u2: &mut [c32],
30928    ldu2: i32,
30929    v1t: &mut [c32],
30930    ldv1t: i32,
30931    v2t: &mut [c32],
30932    ldv2t: i32,
30933    work: &mut [c32],
30934    lwork: i32,
30935    rwork: &mut [f32],
30936    lrwork: i32,
30937    iwork: &mut [i32],
30938    info: &mut i32,
30939) {
30940    ffi::cuncsd_(
30941        &(jobu1 as c_char),
30942        &(jobu2 as c_char),
30943        &(jobv1t as c_char),
30944        &(jobv2t as c_char),
30945        &(trans as c_char),
30946        &(signs as c_char),
30947        &m,
30948        &p,
30949        &q,
30950        x11.as_mut_ptr() as *mut _,
30951        &ldx11,
30952        x12.as_mut_ptr() as *mut _,
30953        &ldx12,
30954        x21.as_mut_ptr() as *mut _,
30955        &ldx21,
30956        x22.as_mut_ptr() as *mut _,
30957        &ldx22,
30958        theta.as_mut_ptr(),
30959        u1.as_mut_ptr() as *mut _,
30960        &ldu1,
30961        u2.as_mut_ptr() as *mut _,
30962        &ldu2,
30963        v1t.as_mut_ptr() as *mut _,
30964        &ldv1t,
30965        v2t.as_mut_ptr() as *mut _,
30966        &ldv2t,
30967        work.as_mut_ptr() as *mut _,
30968        &lwork,
30969        rwork.as_mut_ptr(),
30970        &lrwork,
30971        iwork.as_mut_ptr(),
30972        info,
30973    )
30974}
30975
30976#[inline]
30977pub unsafe fn cuncsd2by1(
30978    jobu1: u8,
30979    jobu2: u8,
30980    jobv1t: u8,
30981    m: i32,
30982    p: i32,
30983    q: i32,
30984    x11: &mut [c32],
30985    ldx11: i32,
30986    x21: &mut [c32],
30987    ldx21: i32,
30988    theta: &mut [c32],
30989    u1: &mut [c32],
30990    ldu1: i32,
30991    u2: &mut [c32],
30992    ldu2: i32,
30993    v1t: &mut [c32],
30994    ldv1t: i32,
30995    work: &mut [c32],
30996    lwork: i32,
30997    rwork: &mut [f32],
30998    lrwork: i32,
30999    iwork: &mut [i32],
31000    info: &mut i32,
31001) {
31002    ffi::cuncsd2by1_(
31003        &(jobu1 as c_char),
31004        &(jobu2 as c_char),
31005        &(jobv1t as c_char),
31006        &m,
31007        &p,
31008        &q,
31009        x11.as_mut_ptr() as *mut _,
31010        &ldx11,
31011        x21.as_mut_ptr() as *mut _,
31012        &ldx21,
31013        theta.as_mut_ptr() as *mut _,
31014        u1.as_mut_ptr() as *mut _,
31015        &ldu1,
31016        u2.as_mut_ptr() as *mut _,
31017        &ldu2,
31018        v1t.as_mut_ptr() as *mut _,
31019        &ldv1t,
31020        work.as_mut_ptr() as *mut _,
31021        &lwork,
31022        rwork.as_mut_ptr(),
31023        &lrwork,
31024        iwork.as_mut_ptr(),
31025        info,
31026    )
31027}
31028
31029#[inline]
31030pub unsafe fn dbbcsd(
31031    jobu1: u8,
31032    jobu2: u8,
31033    jobv1t: u8,
31034    jobv2t: u8,
31035    trans: u8,
31036    m: i32,
31037    p: i32,
31038    q: i32,
31039    theta: &mut [f64],
31040    phi: &mut [f64],
31041    u1: &mut [f64],
31042    ldu1: i32,
31043    u2: &mut [f64],
31044    ldu2: i32,
31045    v1t: &mut [f64],
31046    ldv1t: i32,
31047    v2t: &mut [f64],
31048    ldv2t: i32,
31049    b11d: &mut [f64],
31050    b11e: &mut [f64],
31051    b12d: &mut [f64],
31052    b12e: &mut [f64],
31053    b21d: &mut [f64],
31054    b21e: &mut [f64],
31055    b22d: &mut [f64],
31056    b22e: &mut [f64],
31057    work: &mut [f64],
31058    lwork: i32,
31059    info: &mut i32,
31060) {
31061    ffi::dbbcsd_(
31062        &(jobu1 as c_char),
31063        &(jobu2 as c_char),
31064        &(jobv1t as c_char),
31065        &(jobv2t as c_char),
31066        &(trans as c_char),
31067        &m,
31068        &p,
31069        &q,
31070        theta.as_mut_ptr(),
31071        phi.as_mut_ptr(),
31072        u1.as_mut_ptr(),
31073        &ldu1,
31074        u2.as_mut_ptr(),
31075        &ldu2,
31076        v1t.as_mut_ptr(),
31077        &ldv1t,
31078        v2t.as_mut_ptr(),
31079        &ldv2t,
31080        b11d.as_mut_ptr(),
31081        b11e.as_mut_ptr(),
31082        b12d.as_mut_ptr(),
31083        b12e.as_mut_ptr(),
31084        b21d.as_mut_ptr(),
31085        b21e.as_mut_ptr(),
31086        b22d.as_mut_ptr(),
31087        b22e.as_mut_ptr(),
31088        work.as_mut_ptr(),
31089        &lwork,
31090        info,
31091    )
31092}
31093
31094#[inline]
31095pub unsafe fn dorbdb(
31096    trans: u8,
31097    signs: u8,
31098    m: i32,
31099    p: i32,
31100    q: i32,
31101    x11: &mut [f64],
31102    ldx11: i32,
31103    x12: &mut [f64],
31104    ldx12: i32,
31105    x21: &mut [f64],
31106    ldx21: i32,
31107    x22: &mut [f64],
31108    ldx22: i32,
31109    theta: &mut [f64],
31110    phi: &mut [f64],
31111    taup1: &mut [f64],
31112    taup2: &mut [f64],
31113    tauq1: &mut [f64],
31114    tauq2: &mut [f64],
31115    work: &mut [f64],
31116    lwork: i32,
31117    info: &mut i32,
31118) {
31119    ffi::dorbdb_(
31120        &(trans as c_char),
31121        &(signs as c_char),
31122        &m,
31123        &p,
31124        &q,
31125        x11.as_mut_ptr(),
31126        &ldx11,
31127        x12.as_mut_ptr(),
31128        &ldx12,
31129        x21.as_mut_ptr(),
31130        &ldx21,
31131        x22.as_mut_ptr(),
31132        &ldx22,
31133        theta.as_mut_ptr(),
31134        phi.as_mut_ptr(),
31135        taup1.as_mut_ptr(),
31136        taup2.as_mut_ptr(),
31137        tauq1.as_mut_ptr(),
31138        tauq2.as_mut_ptr(),
31139        work.as_mut_ptr(),
31140        &lwork,
31141        info,
31142    )
31143}
31144
31145#[inline]
31146pub unsafe fn dorcsd(
31147    jobu1: u8,
31148    jobu2: u8,
31149    jobv1t: u8,
31150    jobv2t: u8,
31151    trans: u8,
31152    signs: u8,
31153    m: i32,
31154    p: i32,
31155    q: i32,
31156    x11: &mut [f64],
31157    ldx11: i32,
31158    x12: &mut [f64],
31159    ldx12: i32,
31160    x21: &mut [f64],
31161    ldx21: i32,
31162    x22: &mut [f64],
31163    ldx22: i32,
31164    theta: &mut [f64],
31165    u1: &mut [f64],
31166    ldu1: i32,
31167    u2: &mut [f64],
31168    ldu2: i32,
31169    v1t: &mut [f64],
31170    ldv1t: i32,
31171    v2t: &mut [f64],
31172    ldv2t: i32,
31173    work: &mut [f64],
31174    lwork: i32,
31175    iwork: &mut [i32],
31176    info: &mut i32,
31177) {
31178    ffi::dorcsd_(
31179        &(jobu1 as c_char),
31180        &(jobu2 as c_char),
31181        &(jobv1t as c_char),
31182        &(jobv2t as c_char),
31183        &(trans as c_char),
31184        &(signs as c_char),
31185        &m,
31186        &p,
31187        &q,
31188        x11.as_mut_ptr(),
31189        &ldx11,
31190        x12.as_mut_ptr(),
31191        &ldx12,
31192        x21.as_mut_ptr(),
31193        &ldx21,
31194        x22.as_mut_ptr(),
31195        &ldx22,
31196        theta.as_mut_ptr(),
31197        u1.as_mut_ptr(),
31198        &ldu1,
31199        u2.as_mut_ptr(),
31200        &ldu2,
31201        v1t.as_mut_ptr(),
31202        &ldv1t,
31203        v2t.as_mut_ptr(),
31204        &ldv2t,
31205        work.as_mut_ptr(),
31206        &lwork,
31207        iwork.as_mut_ptr(),
31208        info,
31209    )
31210}
31211
31212#[inline]
31213pub unsafe fn dorcsd2by1(
31214    jobu1: u8,
31215    jobu2: u8,
31216    jobv1t: u8,
31217    m: i32,
31218    p: i32,
31219    q: i32,
31220    x11: &mut [f64],
31221    ldx11: i32,
31222    x21: &mut [f64],
31223    ldx21: i32,
31224    theta: &mut [f64],
31225    u1: &mut [f64],
31226    ldu1: i32,
31227    u2: &mut [f64],
31228    ldu2: i32,
31229    v1t: &mut [f64],
31230    ldv1t: i32,
31231    work: &mut [f64],
31232    lwork: i32,
31233    iwork: &mut [i32],
31234    info: &mut i32,
31235) {
31236    ffi::dorcsd2by1_(
31237        &(jobu1 as c_char),
31238        &(jobu2 as c_char),
31239        &(jobv1t as c_char),
31240        &m,
31241        &p,
31242        &q,
31243        x11.as_mut_ptr(),
31244        &ldx11,
31245        x21.as_mut_ptr(),
31246        &ldx21,
31247        theta.as_mut_ptr(),
31248        u1.as_mut_ptr(),
31249        &ldu1,
31250        u2.as_mut_ptr(),
31251        &ldu2,
31252        v1t.as_mut_ptr(),
31253        &ldv1t,
31254        work.as_mut_ptr(),
31255        &lwork,
31256        iwork.as_mut_ptr(),
31257        info,
31258    )
31259}
31260
31261#[inline]
31262pub unsafe fn dsyconv(
31263    uplo: u8,
31264    way: u8,
31265    n: i32,
31266    a: &mut [f64],
31267    lda: i32,
31268    ipiv: &[i32],
31269    work: &mut [f64],
31270    info: &mut i32,
31271) {
31272    ffi::dsyconv_(
31273        &(uplo as c_char),
31274        &(way as c_char),
31275        &n,
31276        a.as_mut_ptr(),
31277        &lda,
31278        ipiv.as_ptr(),
31279        work.as_mut_ptr(),
31280        info,
31281    )
31282}
31283
31284#[inline]
31285pub unsafe fn dsyswapr(uplo: u8, n: i32, a: &mut [f64], i1: &[i32], i2: &[i32]) {
31286    ffi::dsyswapr_(
31287        &(uplo as c_char),
31288        &n,
31289        a.as_mut_ptr(),
31290        i1.as_ptr(),
31291        i2.as_ptr(),
31292    )
31293}
31294
31295#[inline]
31296pub unsafe fn dsytri2(
31297    uplo: u8,
31298    n: i32,
31299    a: &mut [f64],
31300    lda: i32,
31301    ipiv: &[i32],
31302    work: &mut [c64],
31303    lwork: i32,
31304    info: &mut i32,
31305) {
31306    ffi::dsytri2_(
31307        &(uplo as c_char),
31308        &n,
31309        a.as_mut_ptr(),
31310        &lda,
31311        ipiv.as_ptr(),
31312        work.as_mut_ptr() as *mut _,
31313        &lwork,
31314        info,
31315    )
31316}
31317
31318#[inline]
31319pub unsafe fn dsytri2x(
31320    uplo: u8,
31321    n: i32,
31322    a: &mut [f64],
31323    lda: i32,
31324    ipiv: &[i32],
31325    work: &mut [f64],
31326    nb: i32,
31327    info: &mut i32,
31328) {
31329    ffi::dsytri2x_(
31330        &(uplo as c_char),
31331        &n,
31332        a.as_mut_ptr(),
31333        &lda,
31334        ipiv.as_ptr(),
31335        work.as_mut_ptr(),
31336        &nb,
31337        info,
31338    )
31339}
31340
31341#[inline]
31342pub unsafe fn dsytrs2(
31343    uplo: u8,
31344    n: i32,
31345    nrhs: i32,
31346    a: &[f64],
31347    lda: i32,
31348    ipiv: &[i32],
31349    b: &mut [f64],
31350    ldb: i32,
31351    work: &mut [f64],
31352    info: &mut i32,
31353) {
31354    ffi::dsytrs2_(
31355        &(uplo as c_char),
31356        &n,
31357        &nrhs,
31358        a.as_ptr(),
31359        &lda,
31360        ipiv.as_ptr(),
31361        b.as_mut_ptr(),
31362        &ldb,
31363        work.as_mut_ptr(),
31364        info,
31365    )
31366}
31367
31368#[inline]
31369pub unsafe fn sbbcsd(
31370    jobu1: u8,
31371    jobu2: u8,
31372    jobv1t: u8,
31373    jobv2t: u8,
31374    trans: u8,
31375    m: i32,
31376    p: i32,
31377    q: i32,
31378    theta: &mut [f32],
31379    phi: &mut [f32],
31380    u1: &mut [f32],
31381    ldu1: i32,
31382    u2: &mut [f32],
31383    ldu2: i32,
31384    v1t: &mut [f32],
31385    ldv1t: i32,
31386    v2t: &mut [f32],
31387    ldv2t: i32,
31388    b11d: &mut [f32],
31389    b11e: &mut [f32],
31390    b12d: &mut [f32],
31391    b12e: &mut [f32],
31392    b21d: &mut [f32],
31393    b21e: &mut [f32],
31394    b22d: &mut [f32],
31395    b22e: &mut [f32],
31396    work: &mut [f32],
31397    lwork: i32,
31398    info: &mut i32,
31399) {
31400    ffi::sbbcsd_(
31401        &(jobu1 as c_char),
31402        &(jobu2 as c_char),
31403        &(jobv1t as c_char),
31404        &(jobv2t as c_char),
31405        &(trans as c_char),
31406        &m,
31407        &p,
31408        &q,
31409        theta.as_mut_ptr(),
31410        phi.as_mut_ptr(),
31411        u1.as_mut_ptr(),
31412        &ldu1,
31413        u2.as_mut_ptr(),
31414        &ldu2,
31415        v1t.as_mut_ptr(),
31416        &ldv1t,
31417        v2t.as_mut_ptr(),
31418        &ldv2t,
31419        b11d.as_mut_ptr(),
31420        b11e.as_mut_ptr(),
31421        b12d.as_mut_ptr(),
31422        b12e.as_mut_ptr(),
31423        b21d.as_mut_ptr(),
31424        b21e.as_mut_ptr(),
31425        b22d.as_mut_ptr(),
31426        b22e.as_mut_ptr(),
31427        work.as_mut_ptr(),
31428        &lwork,
31429        info,
31430    )
31431}
31432
31433#[inline]
31434pub unsafe fn sorbdb(
31435    trans: u8,
31436    signs: u8,
31437    m: i32,
31438    p: i32,
31439    q: i32,
31440    x11: &mut [f32],
31441    ldx11: i32,
31442    x12: &mut [f32],
31443    ldx12: i32,
31444    x21: &mut [f32],
31445    ldx21: i32,
31446    x22: &mut [f32],
31447    ldx22: i32,
31448    theta: &mut [f32],
31449    phi: &mut [f32],
31450    taup1: &mut [f32],
31451    taup2: &mut [f32],
31452    tauq1: &mut [f32],
31453    tauq2: &mut [f32],
31454    work: &mut [f32],
31455    lwork: i32,
31456    info: &mut i32,
31457) {
31458    ffi::sorbdb_(
31459        &(trans as c_char),
31460        &(signs as c_char),
31461        &m,
31462        &p,
31463        &q,
31464        x11.as_mut_ptr(),
31465        &ldx11,
31466        x12.as_mut_ptr(),
31467        &ldx12,
31468        x21.as_mut_ptr(),
31469        &ldx21,
31470        x22.as_mut_ptr(),
31471        &ldx22,
31472        theta.as_mut_ptr(),
31473        phi.as_mut_ptr(),
31474        taup1.as_mut_ptr(),
31475        taup2.as_mut_ptr(),
31476        tauq1.as_mut_ptr(),
31477        tauq2.as_mut_ptr(),
31478        work.as_mut_ptr(),
31479        &lwork,
31480        info,
31481    )
31482}
31483
31484#[inline]
31485pub unsafe fn sorcsd(
31486    jobu1: u8,
31487    jobu2: u8,
31488    jobv1t: u8,
31489    jobv2t: u8,
31490    trans: u8,
31491    signs: u8,
31492    m: i32,
31493    p: i32,
31494    q: i32,
31495    x11: &mut [f32],
31496    ldx11: i32,
31497    x12: &mut [f32],
31498    ldx12: i32,
31499    x21: &mut [f32],
31500    ldx21: i32,
31501    x22: &mut [f32],
31502    ldx22: i32,
31503    theta: &mut [f32],
31504    u1: &mut [f32],
31505    ldu1: i32,
31506    u2: &mut [f32],
31507    ldu2: i32,
31508    v1t: &mut [f32],
31509    ldv1t: i32,
31510    v2t: &mut [f32],
31511    ldv2t: i32,
31512    work: &mut [f32],
31513    lwork: i32,
31514    iwork: &mut [i32],
31515    info: &mut i32,
31516) {
31517    ffi::sorcsd_(
31518        &(jobu1 as c_char),
31519        &(jobu2 as c_char),
31520        &(jobv1t as c_char),
31521        &(jobv2t as c_char),
31522        &(trans as c_char),
31523        &(signs as c_char),
31524        &m,
31525        &p,
31526        &q,
31527        x11.as_mut_ptr(),
31528        &ldx11,
31529        x12.as_mut_ptr(),
31530        &ldx12,
31531        x21.as_mut_ptr(),
31532        &ldx21,
31533        x22.as_mut_ptr(),
31534        &ldx22,
31535        theta.as_mut_ptr(),
31536        u1.as_mut_ptr(),
31537        &ldu1,
31538        u2.as_mut_ptr(),
31539        &ldu2,
31540        v1t.as_mut_ptr(),
31541        &ldv1t,
31542        v2t.as_mut_ptr(),
31543        &ldv2t,
31544        work.as_mut_ptr(),
31545        &lwork,
31546        iwork.as_mut_ptr(),
31547        info,
31548    )
31549}
31550
31551#[inline]
31552pub unsafe fn sorcsd2by1(
31553    jobu1: u8,
31554    jobu2: u8,
31555    jobv1t: u8,
31556    m: i32,
31557    p: i32,
31558    q: i32,
31559    x11: &mut [f32],
31560    ldx11: i32,
31561    x21: &mut [f32],
31562    ldx21: i32,
31563    theta: &mut [f32],
31564    u1: &mut [f32],
31565    ldu1: i32,
31566    u2: &mut [f32],
31567    ldu2: i32,
31568    v1t: &mut [f32],
31569    ldv1t: i32,
31570    work: &mut [f32],
31571    lwork: i32,
31572    iwork: &mut [i32],
31573    info: &mut i32,
31574) {
31575    ffi::sorcsd2by1_(
31576        &(jobu1 as c_char),
31577        &(jobu2 as c_char),
31578        &(jobv1t as c_char),
31579        &m,
31580        &p,
31581        &q,
31582        x11.as_mut_ptr(),
31583        &ldx11,
31584        x21.as_mut_ptr(),
31585        &ldx21,
31586        theta.as_mut_ptr(),
31587        u1.as_mut_ptr(),
31588        &ldu1,
31589        u2.as_mut_ptr(),
31590        &ldu2,
31591        v1t.as_mut_ptr(),
31592        &ldv1t,
31593        work.as_mut_ptr(),
31594        &lwork,
31595        iwork.as_mut_ptr(),
31596        info,
31597    )
31598}
31599
31600#[inline]
31601pub unsafe fn ssyconv(
31602    uplo: u8,
31603    way: u8,
31604    n: i32,
31605    a: &mut [f32],
31606    lda: i32,
31607    ipiv: &[i32],
31608    work: &mut [f32],
31609    info: &mut i32,
31610) {
31611    ffi::ssyconv_(
31612        &(uplo as c_char),
31613        &(way as c_char),
31614        &n,
31615        a.as_mut_ptr(),
31616        &lda,
31617        ipiv.as_ptr(),
31618        work.as_mut_ptr(),
31619        info,
31620    )
31621}
31622
31623#[inline]
31624pub unsafe fn ssyswapr(uplo: u8, n: i32, a: &mut [f32], i1: &[i32], i2: &[i32]) {
31625    ffi::ssyswapr_(
31626        &(uplo as c_char),
31627        &n,
31628        a.as_mut_ptr(),
31629        i1.as_ptr(),
31630        i2.as_ptr(),
31631    )
31632}
31633
31634#[inline]
31635pub unsafe fn ssytri2(
31636    uplo: u8,
31637    n: i32,
31638    a: &mut [f32],
31639    lda: i32,
31640    ipiv: &[i32],
31641    work: &mut [c32],
31642    lwork: i32,
31643    info: &mut i32,
31644) {
31645    ffi::ssytri2_(
31646        &(uplo as c_char),
31647        &n,
31648        a.as_mut_ptr(),
31649        &lda,
31650        ipiv.as_ptr(),
31651        work.as_mut_ptr() as *mut _,
31652        &lwork,
31653        info,
31654    )
31655}
31656
31657#[inline]
31658pub unsafe fn ssytri2x(
31659    uplo: u8,
31660    n: i32,
31661    a: &mut [f32],
31662    lda: i32,
31663    ipiv: &[i32],
31664    work: &mut [f32],
31665    nb: i32,
31666    info: &mut i32,
31667) {
31668    ffi::ssytri2x_(
31669        &(uplo as c_char),
31670        &n,
31671        a.as_mut_ptr(),
31672        &lda,
31673        ipiv.as_ptr(),
31674        work.as_mut_ptr(),
31675        &nb,
31676        info,
31677    )
31678}
31679
31680#[inline]
31681pub unsafe fn ssytrs2(
31682    uplo: u8,
31683    n: i32,
31684    nrhs: i32,
31685    a: &[f32],
31686    lda: i32,
31687    ipiv: &[i32],
31688    b: &mut [f32],
31689    ldb: i32,
31690    work: &mut [f32],
31691    info: &mut i32,
31692) {
31693    ffi::ssytrs2_(
31694        &(uplo as c_char),
31695        &n,
31696        &nrhs,
31697        a.as_ptr(),
31698        &lda,
31699        ipiv.as_ptr(),
31700        b.as_mut_ptr(),
31701        &ldb,
31702        work.as_mut_ptr(),
31703        info,
31704    )
31705}
31706
31707#[inline]
31708pub unsafe fn zbbcsd(
31709    jobu1: u8,
31710    jobu2: u8,
31711    jobv1t: u8,
31712    jobv2t: u8,
31713    trans: u8,
31714    m: i32,
31715    p: i32,
31716    q: i32,
31717    theta: &mut [f64],
31718    phi: &mut [f64],
31719    u1: &mut [c64],
31720    ldu1: i32,
31721    u2: &mut [c64],
31722    ldu2: i32,
31723    v1t: &mut [c64],
31724    ldv1t: i32,
31725    v2t: &mut [c64],
31726    ldv2t: i32,
31727    b11d: &mut [f64],
31728    b11e: &mut [f64],
31729    b12d: &mut [f64],
31730    b12e: &mut [f64],
31731    b21d: &mut [f64],
31732    b21e: &mut [f64],
31733    b22d: &mut [f64],
31734    b22e: &mut [f64],
31735    rwork: &mut [f64],
31736    lrwork: i32,
31737    info: &mut i32,
31738) {
31739    ffi::zbbcsd_(
31740        &(jobu1 as c_char),
31741        &(jobu2 as c_char),
31742        &(jobv1t as c_char),
31743        &(jobv2t as c_char),
31744        &(trans as c_char),
31745        &m,
31746        &p,
31747        &q,
31748        theta.as_mut_ptr(),
31749        phi.as_mut_ptr(),
31750        u1.as_mut_ptr() as *mut _,
31751        &ldu1,
31752        u2.as_mut_ptr() as *mut _,
31753        &ldu2,
31754        v1t.as_mut_ptr() as *mut _,
31755        &ldv1t,
31756        v2t.as_mut_ptr() as *mut _,
31757        &ldv2t,
31758        b11d.as_mut_ptr(),
31759        b11e.as_mut_ptr(),
31760        b12d.as_mut_ptr(),
31761        b12e.as_mut_ptr(),
31762        b21d.as_mut_ptr(),
31763        b21e.as_mut_ptr(),
31764        b22d.as_mut_ptr(),
31765        b22e.as_mut_ptr(),
31766        rwork.as_mut_ptr(),
31767        &lrwork,
31768        info,
31769    )
31770}
31771
31772#[inline]
31773pub unsafe fn zheswapr(uplo: u8, n: i32, a: &mut [c64], i1: &[i32], i2: &[i32]) {
31774    ffi::zheswapr_(
31775        &(uplo as c_char),
31776        &n,
31777        a.as_mut_ptr() as *mut _,
31778        i1.as_ptr(),
31779        i2.as_ptr(),
31780    )
31781}
31782
31783#[inline]
31784pub unsafe fn zhetri2(
31785    uplo: u8,
31786    n: i32,
31787    a: &mut [c64],
31788    lda: i32,
31789    ipiv: &[i32],
31790    work: &mut [c64],
31791    lwork: i32,
31792    info: &mut i32,
31793) {
31794    ffi::zhetri2_(
31795        &(uplo as c_char),
31796        &n,
31797        a.as_mut_ptr() as *mut _,
31798        &lda,
31799        ipiv.as_ptr(),
31800        work.as_mut_ptr() as *mut _,
31801        &lwork,
31802        info,
31803    )
31804}
31805
31806#[inline]
31807pub unsafe fn zhetri2x(
31808    uplo: u8,
31809    n: i32,
31810    a: &mut [c64],
31811    lda: i32,
31812    ipiv: &[i32],
31813    work: &mut [c64],
31814    nb: i32,
31815    info: &mut i32,
31816) {
31817    ffi::zhetri2x_(
31818        &(uplo as c_char),
31819        &n,
31820        a.as_mut_ptr() as *mut _,
31821        &lda,
31822        ipiv.as_ptr(),
31823        work.as_mut_ptr() as *mut _,
31824        &nb,
31825        info,
31826    )
31827}
31828
31829#[inline]
31830pub unsafe fn zhetrs2(
31831    uplo: u8,
31832    n: i32,
31833    nrhs: i32,
31834    a: &[c64],
31835    lda: i32,
31836    ipiv: &[i32],
31837    b: &mut [c64],
31838    ldb: i32,
31839    work: &mut [c64],
31840    info: &mut i32,
31841) {
31842    ffi::zhetrs2_(
31843        &(uplo as c_char),
31844        &n,
31845        &nrhs,
31846        a.as_ptr() as *const _,
31847        &lda,
31848        ipiv.as_ptr(),
31849        b.as_mut_ptr() as *mut _,
31850        &ldb,
31851        work.as_mut_ptr() as *mut _,
31852        info,
31853    )
31854}
31855
31856#[inline]
31857pub unsafe fn zsyconv(
31858    uplo: u8,
31859    way: u8,
31860    n: i32,
31861    a: &mut [c64],
31862    lda: i32,
31863    ipiv: &[i32],
31864    work: &mut [c64],
31865    info: &mut i32,
31866) {
31867    ffi::zsyconv_(
31868        &(uplo as c_char),
31869        &(way as c_char),
31870        &n,
31871        a.as_mut_ptr() as *mut _,
31872        &lda,
31873        ipiv.as_ptr(),
31874        work.as_mut_ptr() as *mut _,
31875        info,
31876    )
31877}
31878
31879#[inline]
31880pub unsafe fn zsyswapr(uplo: u8, n: i32, a: &mut [c64], i1: &[i32], i2: &[i32]) {
31881    ffi::zsyswapr_(
31882        &(uplo as c_char),
31883        &n,
31884        a.as_mut_ptr() as *mut _,
31885        i1.as_ptr(),
31886        i2.as_ptr(),
31887    )
31888}
31889
31890#[inline]
31891pub unsafe fn zsytri2(
31892    uplo: u8,
31893    n: i32,
31894    a: &mut [c64],
31895    lda: i32,
31896    ipiv: &[i32],
31897    work: &mut [c64],
31898    lwork: i32,
31899    info: &mut i32,
31900) {
31901    ffi::zsytri2_(
31902        &(uplo as c_char),
31903        &n,
31904        a.as_mut_ptr() as *mut _,
31905        &lda,
31906        ipiv.as_ptr(),
31907        work.as_mut_ptr() as *mut _,
31908        &lwork,
31909        info,
31910    )
31911}
31912
31913#[inline]
31914pub unsafe fn zsytri2x(
31915    uplo: u8,
31916    n: i32,
31917    a: &mut [c64],
31918    lda: i32,
31919    ipiv: &[i32],
31920    work: &mut [c64],
31921    nb: i32,
31922    info: &mut i32,
31923) {
31924    ffi::zsytri2x_(
31925        &(uplo as c_char),
31926        &n,
31927        a.as_mut_ptr() as *mut _,
31928        &lda,
31929        ipiv.as_ptr(),
31930        work.as_mut_ptr() as *mut _,
31931        &nb,
31932        info,
31933    )
31934}
31935
31936#[inline]
31937pub unsafe fn zsytrs2(
31938    uplo: u8,
31939    n: i32,
31940    nrhs: i32,
31941    a: &[c64],
31942    lda: i32,
31943    ipiv: &[i32],
31944    b: &mut [c64],
31945    ldb: i32,
31946    work: &mut [c64],
31947    info: &mut i32,
31948) {
31949    ffi::zsytrs2_(
31950        &(uplo as c_char),
31951        &n,
31952        &nrhs,
31953        a.as_ptr() as *const _,
31954        &lda,
31955        ipiv.as_ptr(),
31956        b.as_mut_ptr() as *mut _,
31957        &ldb,
31958        work.as_mut_ptr() as *mut _,
31959        info,
31960    )
31961}
31962
31963#[inline]
31964pub unsafe fn zunbdb(
31965    trans: u8,
31966    signs: u8,
31967    m: i32,
31968    p: i32,
31969    q: i32,
31970    x11: &mut [c64],
31971    ldx11: i32,
31972    x12: &mut [c64],
31973    ldx12: i32,
31974    x21: &mut [c64],
31975    ldx21: i32,
31976    x22: &mut [c64],
31977    ldx22: i32,
31978    theta: &mut [f64],
31979    phi: &mut [f64],
31980    taup1: &mut [c64],
31981    taup2: &mut [c64],
31982    tauq1: &mut [c64],
31983    tauq2: &mut [c64],
31984    work: &mut [c64],
31985    lwork: i32,
31986    info: &mut i32,
31987) {
31988    ffi::zunbdb_(
31989        &(trans as c_char),
31990        &(signs as c_char),
31991        &m,
31992        &p,
31993        &q,
31994        x11.as_mut_ptr() as *mut _,
31995        &ldx11,
31996        x12.as_mut_ptr() as *mut _,
31997        &ldx12,
31998        x21.as_mut_ptr() as *mut _,
31999        &ldx21,
32000        x22.as_mut_ptr() as *mut _,
32001        &ldx22,
32002        theta.as_mut_ptr(),
32003        phi.as_mut_ptr(),
32004        taup1.as_mut_ptr() as *mut _,
32005        taup2.as_mut_ptr() as *mut _,
32006        tauq1.as_mut_ptr() as *mut _,
32007        tauq2.as_mut_ptr() as *mut _,
32008        work.as_mut_ptr() as *mut _,
32009        &lwork,
32010        info,
32011    )
32012}
32013
32014#[inline]
32015pub unsafe fn zuncsd(
32016    jobu1: u8,
32017    jobu2: u8,
32018    jobv1t: u8,
32019    jobv2t: u8,
32020    trans: u8,
32021    signs: u8,
32022    m: i32,
32023    p: i32,
32024    q: i32,
32025    x11: &mut [c64],
32026    ldx11: i32,
32027    x12: &mut [c64],
32028    ldx12: i32,
32029    x21: &mut [c64],
32030    ldx21: i32,
32031    x22: &mut [c64],
32032    ldx22: i32,
32033    theta: &mut [f64],
32034    u1: &mut [c64],
32035    ldu1: i32,
32036    u2: &mut [c64],
32037    ldu2: i32,
32038    v1t: &mut [c64],
32039    ldv1t: i32,
32040    v2t: &mut [c64],
32041    ldv2t: i32,
32042    work: &mut [c64],
32043    lwork: i32,
32044    rwork: &mut [f64],
32045    lrwork: i32,
32046    iwork: &mut [i32],
32047    info: &mut i32,
32048) {
32049    ffi::zuncsd_(
32050        &(jobu1 as c_char),
32051        &(jobu2 as c_char),
32052        &(jobv1t as c_char),
32053        &(jobv2t as c_char),
32054        &(trans as c_char),
32055        &(signs as c_char),
32056        &m,
32057        &p,
32058        &q,
32059        x11.as_mut_ptr() as *mut _,
32060        &ldx11,
32061        x12.as_mut_ptr() as *mut _,
32062        &ldx12,
32063        x21.as_mut_ptr() as *mut _,
32064        &ldx21,
32065        x22.as_mut_ptr() as *mut _,
32066        &ldx22,
32067        theta.as_mut_ptr(),
32068        u1.as_mut_ptr() as *mut _,
32069        &ldu1,
32070        u2.as_mut_ptr() as *mut _,
32071        &ldu2,
32072        v1t.as_mut_ptr() as *mut _,
32073        &ldv1t,
32074        v2t.as_mut_ptr() as *mut _,
32075        &ldv2t,
32076        work.as_mut_ptr() as *mut _,
32077        &lwork,
32078        rwork.as_mut_ptr(),
32079        &lrwork,
32080        iwork.as_mut_ptr(),
32081        info,
32082    )
32083}
32084
32085#[inline]
32086pub unsafe fn zuncsd2by1(
32087    jobu1: u8,
32088    jobu2: u8,
32089    jobv1t: u8,
32090    m: i32,
32091    p: i32,
32092    q: i32,
32093    x11: &mut [c64],
32094    ldx11: i32,
32095    x21: &mut [c64],
32096    ldx21: i32,
32097    theta: &mut [c64],
32098    u1: &mut [c64],
32099    ldu1: i32,
32100    u2: &mut [c64],
32101    ldu2: i32,
32102    v1t: &mut [c64],
32103    ldv1t: i32,
32104    work: &mut [c64],
32105    lwork: i32,
32106    rwork: &mut [f64],
32107    lrwork: i32,
32108    iwork: &mut [i32],
32109    info: &mut i32,
32110) {
32111    ffi::zuncsd2by1_(
32112        &(jobu1 as c_char),
32113        &(jobu2 as c_char),
32114        &(jobv1t as c_char),
32115        &m,
32116        &p,
32117        &q,
32118        x11.as_mut_ptr() as *mut _,
32119        &ldx11,
32120        x21.as_mut_ptr() as *mut _,
32121        &ldx21,
32122        theta.as_mut_ptr() as *mut _,
32123        u1.as_mut_ptr() as *mut _,
32124        &ldu1,
32125        u2.as_mut_ptr() as *mut _,
32126        &ldu2,
32127        v1t.as_mut_ptr() as *mut _,
32128        &ldv1t,
32129        work.as_mut_ptr() as *mut _,
32130        &lwork,
32131        rwork.as_mut_ptr(),
32132        &lrwork,
32133        iwork.as_mut_ptr(),
32134        info,
32135    )
32136}
32137
32138#[inline]
32139pub unsafe fn sgemqrt(
32140    side: u8,
32141    trans: u8,
32142    m: i32,
32143    n: i32,
32144    k: i32,
32145    nb: i32,
32146    v: &[f32],
32147    ldv: i32,
32148    t: &[f32],
32149    ldt: i32,
32150    c: &mut [f32],
32151    ldc: i32,
32152    work: &mut [f32],
32153    info: &mut i32,
32154) {
32155    ffi::sgemqrt_(
32156        &(side as c_char),
32157        &(trans as c_char),
32158        &m,
32159        &n,
32160        &k,
32161        &nb,
32162        v.as_ptr(),
32163        &ldv,
32164        t.as_ptr(),
32165        &ldt,
32166        c.as_mut_ptr(),
32167        &ldc,
32168        work.as_mut_ptr(),
32169        info,
32170    )
32171}
32172
32173#[inline]
32174pub unsafe fn dgemqrt(
32175    side: u8,
32176    trans: u8,
32177    m: i32,
32178    n: i32,
32179    k: i32,
32180    nb: i32,
32181    v: &[f64],
32182    ldv: i32,
32183    t: &[f64],
32184    ldt: i32,
32185    c: &mut [f64],
32186    ldc: i32,
32187    work: &mut [f64],
32188    info: &mut i32,
32189) {
32190    ffi::dgemqrt_(
32191        &(side as c_char),
32192        &(trans as c_char),
32193        &m,
32194        &n,
32195        &k,
32196        &nb,
32197        v.as_ptr(),
32198        &ldv,
32199        t.as_ptr(),
32200        &ldt,
32201        c.as_mut_ptr(),
32202        &ldc,
32203        work.as_mut_ptr(),
32204        info,
32205    )
32206}
32207
32208#[inline]
32209pub unsafe fn cgemqrt(
32210    side: u8,
32211    trans: u8,
32212    m: i32,
32213    n: i32,
32214    k: i32,
32215    nb: i32,
32216    v: &[c32],
32217    ldv: i32,
32218    t: &[c32],
32219    ldt: i32,
32220    c: &mut [c32],
32221    ldc: i32,
32222    work: &mut [c32],
32223    info: &mut i32,
32224) {
32225    ffi::cgemqrt_(
32226        &(side as c_char),
32227        &(trans as c_char),
32228        &m,
32229        &n,
32230        &k,
32231        &nb,
32232        v.as_ptr() as *const _,
32233        &ldv,
32234        t.as_ptr() as *const _,
32235        &ldt,
32236        c.as_mut_ptr() as *mut _,
32237        &ldc,
32238        work.as_mut_ptr() as *mut _,
32239        info,
32240    )
32241}
32242
32243#[inline]
32244pub unsafe fn zgemqrt(
32245    side: u8,
32246    trans: u8,
32247    m: i32,
32248    n: i32,
32249    k: i32,
32250    nb: i32,
32251    v: &[c64],
32252    ldv: i32,
32253    t: &[c64],
32254    ldt: i32,
32255    c: &mut [c64],
32256    ldc: i32,
32257    work: &mut [c64],
32258    info: &mut i32,
32259) {
32260    ffi::zgemqrt_(
32261        &(side as c_char),
32262        &(trans as c_char),
32263        &m,
32264        &n,
32265        &k,
32266        &nb,
32267        v.as_ptr() as *const _,
32268        &ldv,
32269        t.as_ptr() as *const _,
32270        &ldt,
32271        c.as_mut_ptr() as *mut _,
32272        &ldc,
32273        work.as_mut_ptr() as *mut _,
32274        info,
32275    )
32276}
32277
32278#[inline]
32279pub unsafe fn sgeqrt(
32280    m: i32,
32281    n: i32,
32282    nb: i32,
32283    a: &mut [f32],
32284    lda: i32,
32285    t: &mut [f32],
32286    ldt: i32,
32287    work: &mut [f32],
32288    info: &mut i32,
32289) {
32290    ffi::sgeqrt_(
32291        &m,
32292        &n,
32293        &nb,
32294        a.as_mut_ptr(),
32295        &lda,
32296        t.as_mut_ptr(),
32297        &ldt,
32298        work.as_mut_ptr(),
32299        info,
32300    )
32301}
32302
32303#[inline]
32304pub unsafe fn dgeqrt(
32305    m: i32,
32306    n: i32,
32307    nb: i32,
32308    a: &mut [f64],
32309    lda: i32,
32310    t: &mut [f64],
32311    ldt: i32,
32312    work: &mut [f64],
32313    info: &mut i32,
32314) {
32315    ffi::dgeqrt_(
32316        &m,
32317        &n,
32318        &nb,
32319        a.as_mut_ptr(),
32320        &lda,
32321        t.as_mut_ptr(),
32322        &ldt,
32323        work.as_mut_ptr(),
32324        info,
32325    )
32326}
32327
32328#[inline]
32329pub unsafe fn cgeqrt(
32330    m: i32,
32331    n: i32,
32332    nb: i32,
32333    a: &mut [c32],
32334    lda: i32,
32335    t: &mut [c32],
32336    ldt: i32,
32337    work: &mut [c32],
32338    info: &mut i32,
32339) {
32340    ffi::cgeqrt_(
32341        &m,
32342        &n,
32343        &nb,
32344        a.as_mut_ptr() as *mut _,
32345        &lda,
32346        t.as_mut_ptr() as *mut _,
32347        &ldt,
32348        work.as_mut_ptr() as *mut _,
32349        info,
32350    )
32351}
32352
32353#[inline]
32354pub unsafe fn zgeqrt(
32355    m: i32,
32356    n: i32,
32357    nb: i32,
32358    a: &mut [c64],
32359    lda: i32,
32360    t: &mut [c64],
32361    ldt: i32,
32362    work: &mut [c64],
32363    info: &mut i32,
32364) {
32365    ffi::zgeqrt_(
32366        &m,
32367        &n,
32368        &nb,
32369        a.as_mut_ptr() as *mut _,
32370        &lda,
32371        t.as_mut_ptr() as *mut _,
32372        &ldt,
32373        work.as_mut_ptr() as *mut _,
32374        info,
32375    )
32376}
32377
32378#[inline]
32379pub unsafe fn sgeqrt2(
32380    m: i32,
32381    n: i32,
32382    a: &mut [f32],
32383    lda: i32,
32384    t: &mut [f32],
32385    ldt: i32,
32386    info: &mut i32,
32387) {
32388    ffi::sgeqrt2_(&m, &n, a.as_mut_ptr(), &lda, t.as_mut_ptr(), &ldt, info)
32389}
32390
32391#[inline]
32392pub unsafe fn dgeqrt2(
32393    m: i32,
32394    n: i32,
32395    a: &mut [f64],
32396    lda: i32,
32397    t: &mut [f64],
32398    ldt: i32,
32399    info: &mut i32,
32400) {
32401    ffi::dgeqrt2_(&m, &n, a.as_mut_ptr(), &lda, t.as_mut_ptr(), &ldt, info)
32402}
32403
32404#[inline]
32405pub unsafe fn cgeqrt2(
32406    m: i32,
32407    n: i32,
32408    a: &mut [c32],
32409    lda: i32,
32410    t: &mut [c32],
32411    ldt: i32,
32412    info: &mut i32,
32413) {
32414    ffi::cgeqrt2_(
32415        &m,
32416        &n,
32417        a.as_mut_ptr() as *mut _,
32418        &lda,
32419        t.as_mut_ptr() as *mut _,
32420        &ldt,
32421        info,
32422    )
32423}
32424
32425#[inline]
32426pub unsafe fn zgeqrt2(
32427    m: i32,
32428    n: i32,
32429    a: &mut [c64],
32430    lda: i32,
32431    t: &mut [c64],
32432    ldt: i32,
32433    info: &mut i32,
32434) {
32435    ffi::zgeqrt2_(
32436        &m,
32437        &n,
32438        a.as_mut_ptr() as *mut _,
32439        &lda,
32440        t.as_mut_ptr() as *mut _,
32441        &ldt,
32442        info,
32443    )
32444}
32445
32446#[inline]
32447pub unsafe fn sgeqrt3(
32448    m: i32,
32449    n: i32,
32450    a: &mut [f32],
32451    lda: i32,
32452    t: &mut [f32],
32453    ldt: i32,
32454    info: &mut i32,
32455) {
32456    ffi::sgeqrt3_(&m, &n, a.as_mut_ptr(), &lda, t.as_mut_ptr(), &ldt, info)
32457}
32458
32459#[inline]
32460pub unsafe fn dgeqrt3(
32461    m: i32,
32462    n: i32,
32463    a: &mut [f64],
32464    lda: i32,
32465    t: &mut [f64],
32466    ldt: i32,
32467    info: &mut i32,
32468) {
32469    ffi::dgeqrt3_(&m, &n, a.as_mut_ptr(), &lda, t.as_mut_ptr(), &ldt, info)
32470}
32471
32472#[inline]
32473pub unsafe fn cgeqrt3(
32474    m: i32,
32475    n: i32,
32476    a: &mut [c32],
32477    lda: i32,
32478    t: &mut [c32],
32479    ldt: i32,
32480    info: &mut i32,
32481) {
32482    ffi::cgeqrt3_(
32483        &m,
32484        &n,
32485        a.as_mut_ptr() as *mut _,
32486        &lda,
32487        t.as_mut_ptr() as *mut _,
32488        &ldt,
32489        info,
32490    )
32491}
32492
32493#[inline]
32494pub unsafe fn zgeqrt3(
32495    m: i32,
32496    n: i32,
32497    a: &mut [c64],
32498    lda: i32,
32499    t: &mut [c64],
32500    ldt: i32,
32501    info: &mut i32,
32502) {
32503    ffi::zgeqrt3_(
32504        &m,
32505        &n,
32506        a.as_mut_ptr() as *mut _,
32507        &lda,
32508        t.as_mut_ptr() as *mut _,
32509        &ldt,
32510        info,
32511    )
32512}
32513
32514#[inline]
32515pub unsafe fn stpmqrt(
32516    side: u8,
32517    trans: u8,
32518    m: i32,
32519    n: i32,
32520    k: i32,
32521    l: i32,
32522    nb: i32,
32523    v: &[f32],
32524    ldv: i32,
32525    t: &[f32],
32526    ldt: i32,
32527    a: &mut [f32],
32528    lda: i32,
32529    b: &mut [f32],
32530    ldb: i32,
32531    work: &mut [f32],
32532    info: &mut i32,
32533) {
32534    ffi::stpmqrt_(
32535        &(side as c_char),
32536        &(trans as c_char),
32537        &m,
32538        &n,
32539        &k,
32540        &l,
32541        &nb,
32542        v.as_ptr(),
32543        &ldv,
32544        t.as_ptr(),
32545        &ldt,
32546        a.as_mut_ptr(),
32547        &lda,
32548        b.as_mut_ptr(),
32549        &ldb,
32550        work.as_mut_ptr(),
32551        info,
32552    )
32553}
32554
32555#[inline]
32556pub unsafe fn dtpmqrt(
32557    side: u8,
32558    trans: u8,
32559    m: i32,
32560    n: i32,
32561    k: i32,
32562    l: i32,
32563    nb: i32,
32564    v: &[f64],
32565    ldv: i32,
32566    t: &[f64],
32567    ldt: i32,
32568    a: &mut [f64],
32569    lda: i32,
32570    b: &mut [f64],
32571    ldb: i32,
32572    work: &mut [f64],
32573    info: &mut i32,
32574) {
32575    ffi::dtpmqrt_(
32576        &(side as c_char),
32577        &(trans as c_char),
32578        &m,
32579        &n,
32580        &k,
32581        &l,
32582        &nb,
32583        v.as_ptr(),
32584        &ldv,
32585        t.as_ptr(),
32586        &ldt,
32587        a.as_mut_ptr(),
32588        &lda,
32589        b.as_mut_ptr(),
32590        &ldb,
32591        work.as_mut_ptr(),
32592        info,
32593    )
32594}
32595
32596#[inline]
32597pub unsafe fn ctpmqrt(
32598    side: u8,
32599    trans: u8,
32600    m: i32,
32601    n: i32,
32602    k: i32,
32603    l: i32,
32604    nb: i32,
32605    v: &[c32],
32606    ldv: i32,
32607    t: &[c32],
32608    ldt: i32,
32609    a: &mut [c32],
32610    lda: i32,
32611    b: &mut [c32],
32612    ldb: i32,
32613    work: &mut [c32],
32614    info: &mut i32,
32615) {
32616    ffi::ctpmqrt_(
32617        &(side as c_char),
32618        &(trans as c_char),
32619        &m,
32620        &n,
32621        &k,
32622        &l,
32623        &nb,
32624        v.as_ptr() as *const _,
32625        &ldv,
32626        t.as_ptr() as *const _,
32627        &ldt,
32628        a.as_mut_ptr() as *mut _,
32629        &lda,
32630        b.as_mut_ptr() as *mut _,
32631        &ldb,
32632        work.as_mut_ptr() as *mut _,
32633        info,
32634    )
32635}
32636
32637#[inline]
32638pub unsafe fn ztpmqrt(
32639    side: u8,
32640    trans: u8,
32641    m: i32,
32642    n: i32,
32643    k: i32,
32644    l: i32,
32645    nb: i32,
32646    v: &[c64],
32647    ldv: i32,
32648    t: &[c64],
32649    ldt: i32,
32650    a: &mut [c64],
32651    lda: i32,
32652    b: &mut [c64],
32653    ldb: i32,
32654    work: &mut [c64],
32655    info: &mut i32,
32656) {
32657    ffi::ztpmqrt_(
32658        &(side as c_char),
32659        &(trans as c_char),
32660        &m,
32661        &n,
32662        &k,
32663        &l,
32664        &nb,
32665        v.as_ptr() as *const _,
32666        &ldv,
32667        t.as_ptr() as *const _,
32668        &ldt,
32669        a.as_mut_ptr() as *mut _,
32670        &lda,
32671        b.as_mut_ptr() as *mut _,
32672        &ldb,
32673        work.as_mut_ptr() as *mut _,
32674        info,
32675    )
32676}
32677
32678#[inline]
32679pub unsafe fn stpqrt(
32680    m: i32,
32681    n: i32,
32682    l: i32,
32683    nb: i32,
32684    a: &mut [f32],
32685    lda: i32,
32686    b: &mut [f32],
32687    ldb: i32,
32688    t: &mut [f32],
32689    ldt: i32,
32690    work: &mut [f32],
32691    info: &mut i32,
32692) {
32693    ffi::stpqrt_(
32694        &m,
32695        &n,
32696        &l,
32697        &nb,
32698        a.as_mut_ptr(),
32699        &lda,
32700        b.as_mut_ptr(),
32701        &ldb,
32702        t.as_mut_ptr(),
32703        &ldt,
32704        work.as_mut_ptr(),
32705        info,
32706    )
32707}
32708
32709#[inline]
32710pub unsafe fn dtpqrt(
32711    m: i32,
32712    n: i32,
32713    l: i32,
32714    nb: i32,
32715    a: &mut [f64],
32716    lda: i32,
32717    b: &mut [f64],
32718    ldb: i32,
32719    t: &mut [f64],
32720    ldt: i32,
32721    work: &mut [f64],
32722    info: &mut i32,
32723) {
32724    ffi::dtpqrt_(
32725        &m,
32726        &n,
32727        &l,
32728        &nb,
32729        a.as_mut_ptr(),
32730        &lda,
32731        b.as_mut_ptr(),
32732        &ldb,
32733        t.as_mut_ptr(),
32734        &ldt,
32735        work.as_mut_ptr(),
32736        info,
32737    )
32738}
32739
32740#[inline]
32741pub unsafe fn ctpqrt(
32742    m: i32,
32743    n: i32,
32744    l: i32,
32745    nb: i32,
32746    a: &mut [c32],
32747    lda: i32,
32748    b: &mut [c32],
32749    ldb: i32,
32750    t: &mut [c32],
32751    ldt: i32,
32752    work: &mut [c32],
32753    info: &mut i32,
32754) {
32755    ffi::ctpqrt_(
32756        &m,
32757        &n,
32758        &l,
32759        &nb,
32760        a.as_mut_ptr() as *mut _,
32761        &lda,
32762        b.as_mut_ptr() as *mut _,
32763        &ldb,
32764        t.as_mut_ptr() as *mut _,
32765        &ldt,
32766        work.as_mut_ptr() as *mut _,
32767        info,
32768    )
32769}
32770
32771#[inline]
32772pub unsafe fn ztpqrt(
32773    m: i32,
32774    n: i32,
32775    l: i32,
32776    nb: i32,
32777    a: &mut [c64],
32778    lda: i32,
32779    b: &mut [c64],
32780    ldb: i32,
32781    t: &mut [c64],
32782    ldt: i32,
32783    work: &mut [c64],
32784    info: &mut i32,
32785) {
32786    ffi::ztpqrt_(
32787        &m,
32788        &n,
32789        &l,
32790        &nb,
32791        a.as_mut_ptr() as *mut _,
32792        &lda,
32793        b.as_mut_ptr() as *mut _,
32794        &ldb,
32795        t.as_mut_ptr() as *mut _,
32796        &ldt,
32797        work.as_mut_ptr() as *mut _,
32798        info,
32799    )
32800}
32801
32802#[inline]
32803pub unsafe fn stpqrt2(
32804    m: i32,
32805    n: i32,
32806    l: i32,
32807    a: &mut [f32],
32808    lda: i32,
32809    b: &mut [f32],
32810    ldb: i32,
32811    t: &mut [f32],
32812    ldt: i32,
32813    info: &mut i32,
32814) {
32815    ffi::stpqrt2_(
32816        &m,
32817        &n,
32818        &l,
32819        a.as_mut_ptr(),
32820        &lda,
32821        b.as_mut_ptr(),
32822        &ldb,
32823        t.as_mut_ptr(),
32824        &ldt,
32825        info,
32826    )
32827}
32828
32829#[inline]
32830pub unsafe fn dtpqrt2(
32831    m: i32,
32832    n: i32,
32833    l: i32,
32834    a: &mut [f64],
32835    lda: i32,
32836    b: &mut [f64],
32837    ldb: i32,
32838    t: &mut [f64],
32839    ldt: i32,
32840    info: &mut i32,
32841) {
32842    ffi::dtpqrt2_(
32843        &m,
32844        &n,
32845        &l,
32846        a.as_mut_ptr(),
32847        &lda,
32848        b.as_mut_ptr(),
32849        &ldb,
32850        t.as_mut_ptr(),
32851        &ldt,
32852        info,
32853    )
32854}
32855
32856#[inline]
32857pub unsafe fn ctpqrt2(
32858    m: i32,
32859    n: i32,
32860    l: i32,
32861    a: &mut [c32],
32862    lda: i32,
32863    b: &mut [c32],
32864    ldb: i32,
32865    t: &mut [c32],
32866    ldt: i32,
32867    info: &mut i32,
32868) {
32869    ffi::ctpqrt2_(
32870        &m,
32871        &n,
32872        &l,
32873        a.as_mut_ptr() as *mut _,
32874        &lda,
32875        b.as_mut_ptr() as *mut _,
32876        &ldb,
32877        t.as_mut_ptr() as *mut _,
32878        &ldt,
32879        info,
32880    )
32881}
32882
32883#[inline]
32884pub unsafe fn ztpqrt2(
32885    m: i32,
32886    n: i32,
32887    l: i32,
32888    a: &mut [c64],
32889    lda: i32,
32890    b: &mut [c64],
32891    ldb: i32,
32892    t: &mut [c64],
32893    ldt: i32,
32894    info: &mut i32,
32895) {
32896    ffi::ztpqrt2_(
32897        &m,
32898        &n,
32899        &l,
32900        a.as_mut_ptr() as *mut _,
32901        &lda,
32902        b.as_mut_ptr() as *mut _,
32903        &ldb,
32904        t.as_mut_ptr() as *mut _,
32905        &ldt,
32906        info,
32907    )
32908}
32909
32910#[inline]
32911pub unsafe fn stprfb(
32912    side: u8,
32913    trans: u8,
32914    direct: u8,
32915    storev: u8,
32916    m: i32,
32917    n: i32,
32918    k: i32,
32919    l: i32,
32920    v: &[f32],
32921    ldv: i32,
32922    t: &[f32],
32923    ldt: i32,
32924    a: &mut [f32],
32925    lda: i32,
32926    b: &mut [f32],
32927    ldb: i32,
32928    work: &[f32],
32929    ldwork: i32,
32930) {
32931    ffi::stprfb_(
32932        &(side as c_char),
32933        &(trans as c_char),
32934        &(direct as c_char),
32935        &(storev as c_char),
32936        &m,
32937        &n,
32938        &k,
32939        &l,
32940        v.as_ptr(),
32941        &ldv,
32942        t.as_ptr(),
32943        &ldt,
32944        a.as_mut_ptr(),
32945        &lda,
32946        b.as_mut_ptr(),
32947        &ldb,
32948        work.as_ptr(),
32949        &ldwork,
32950    )
32951}
32952
32953#[inline]
32954pub unsafe fn dtprfb(
32955    side: u8,
32956    trans: u8,
32957    direct: u8,
32958    storev: u8,
32959    m: i32,
32960    n: i32,
32961    k: i32,
32962    l: i32,
32963    v: &[f64],
32964    ldv: i32,
32965    t: &[f64],
32966    ldt: i32,
32967    a: &mut [f64],
32968    lda: i32,
32969    b: &mut [f64],
32970    ldb: i32,
32971    work: &[f64],
32972    ldwork: i32,
32973) {
32974    ffi::dtprfb_(
32975        &(side as c_char),
32976        &(trans as c_char),
32977        &(direct as c_char),
32978        &(storev as c_char),
32979        &m,
32980        &n,
32981        &k,
32982        &l,
32983        v.as_ptr(),
32984        &ldv,
32985        t.as_ptr(),
32986        &ldt,
32987        a.as_mut_ptr(),
32988        &lda,
32989        b.as_mut_ptr(),
32990        &ldb,
32991        work.as_ptr(),
32992        &ldwork,
32993    )
32994}
32995
32996#[inline]
32997pub unsafe fn ctprfb(
32998    side: u8,
32999    trans: u8,
33000    direct: u8,
33001    storev: u8,
33002    m: i32,
33003    n: i32,
33004    k: i32,
33005    l: i32,
33006    v: &[c32],
33007    ldv: i32,
33008    t: &[c32],
33009    ldt: i32,
33010    a: &mut [c32],
33011    lda: i32,
33012    b: &mut [c32],
33013    ldb: i32,
33014    work: &mut [c32],
33015    ldwork: i32,
33016) {
33017    ffi::ctprfb_(
33018        &(side as c_char),
33019        &(trans as c_char),
33020        &(direct as c_char),
33021        &(storev as c_char),
33022        &m,
33023        &n,
33024        &k,
33025        &l,
33026        v.as_ptr() as *const _,
33027        &ldv,
33028        t.as_ptr() as *const _,
33029        &ldt,
33030        a.as_mut_ptr() as *mut _,
33031        &lda,
33032        b.as_mut_ptr() as *mut _,
33033        &ldb,
33034        work.as_mut_ptr() as *mut _,
33035        &ldwork,
33036    )
33037}
33038
33039#[inline]
33040pub unsafe fn ztprfb(
33041    side: u8,
33042    trans: u8,
33043    direct: u8,
33044    storev: u8,
33045    m: i32,
33046    n: i32,
33047    k: i32,
33048    l: i32,
33049    v: &[c64],
33050    ldv: i32,
33051    t: &[c64],
33052    ldt: i32,
33053    a: &mut [c64],
33054    lda: i32,
33055    b: &mut [c64],
33056    ldb: i32,
33057    work: &mut [c64],
33058    ldwork: i32,
33059) {
33060    ffi::ztprfb_(
33061        &(side as c_char),
33062        &(trans as c_char),
33063        &(direct as c_char),
33064        &(storev as c_char),
33065        &m,
33066        &n,
33067        &k,
33068        &l,
33069        v.as_ptr() as *const _,
33070        &ldv,
33071        t.as_ptr() as *const _,
33072        &ldt,
33073        a.as_mut_ptr() as *mut _,
33074        &lda,
33075        b.as_mut_ptr() as *mut _,
33076        &ldb,
33077        work.as_mut_ptr() as *mut _,
33078        &ldwork,
33079    )
33080}
33081
33082#[inline]
33083pub unsafe fn ssysv_rook(
33084    uplo: u8,
33085    n: i32,
33086    nrhs: i32,
33087    a: &mut [f32],
33088    lda: i32,
33089    ipiv: &mut [i32],
33090    b: &mut [f32],
33091    ldb: i32,
33092    work: &mut [f32],
33093    lwork: i32,
33094    info: &mut i32,
33095) {
33096    ffi::ssysv_rook_(
33097        &(uplo as c_char),
33098        &n,
33099        &nrhs,
33100        a.as_mut_ptr(),
33101        &lda,
33102        ipiv.as_mut_ptr(),
33103        b.as_mut_ptr(),
33104        &ldb,
33105        work.as_mut_ptr(),
33106        &lwork,
33107        info,
33108    )
33109}
33110
33111#[inline]
33112pub unsafe fn dsysv_rook(
33113    uplo: u8,
33114    n: i32,
33115    nrhs: i32,
33116    a: &mut [f64],
33117    lda: i32,
33118    ipiv: &mut [i32],
33119    b: &mut [f64],
33120    ldb: i32,
33121    work: &mut [f64],
33122    lwork: i32,
33123    info: &mut i32,
33124) {
33125    ffi::dsysv_rook_(
33126        &(uplo as c_char),
33127        &n,
33128        &nrhs,
33129        a.as_mut_ptr(),
33130        &lda,
33131        ipiv.as_mut_ptr(),
33132        b.as_mut_ptr(),
33133        &ldb,
33134        work.as_mut_ptr(),
33135        &lwork,
33136        info,
33137    )
33138}
33139
33140#[inline]
33141pub unsafe fn csysv_rook(
33142    uplo: u8,
33143    n: i32,
33144    nrhs: i32,
33145    a: &mut [c32],
33146    lda: i32,
33147    ipiv: &mut [i32],
33148    b: &mut [c32],
33149    ldb: i32,
33150    work: &mut [c32],
33151    lwork: i32,
33152    info: &mut i32,
33153) {
33154    ffi::csysv_rook_(
33155        &(uplo as c_char),
33156        &n,
33157        &nrhs,
33158        a.as_mut_ptr() as *mut _,
33159        &lda,
33160        ipiv.as_mut_ptr(),
33161        b.as_mut_ptr() as *mut _,
33162        &ldb,
33163        work.as_mut_ptr() as *mut _,
33164        &lwork,
33165        info,
33166    )
33167}
33168
33169#[inline]
33170pub unsafe fn zsysv_rook(
33171    uplo: u8,
33172    n: i32,
33173    nrhs: i32,
33174    a: &mut [c64],
33175    lda: i32,
33176    ipiv: &mut [i32],
33177    b: &mut [c64],
33178    ldb: i32,
33179    work: &mut [c64],
33180    lwork: i32,
33181    info: &mut i32,
33182) {
33183    ffi::zsysv_rook_(
33184        &(uplo as c_char),
33185        &n,
33186        &nrhs,
33187        a.as_mut_ptr() as *mut _,
33188        &lda,
33189        ipiv.as_mut_ptr(),
33190        b.as_mut_ptr() as *mut _,
33191        &ldb,
33192        work.as_mut_ptr() as *mut _,
33193        &lwork,
33194        info,
33195    )
33196}
33197
33198#[inline]
33199pub unsafe fn ssytrf_rook(
33200    uplo: u8,
33201    n: i32,
33202    a: &mut [f32],
33203    lda: i32,
33204    ipiv: &mut [i32],
33205    work: &mut [f32],
33206    lwork: i32,
33207    info: &mut i32,
33208) {
33209    ffi::ssytrf_rook_(
33210        &(uplo as c_char),
33211        &n,
33212        a.as_mut_ptr(),
33213        &lda,
33214        ipiv.as_mut_ptr(),
33215        work.as_mut_ptr(),
33216        &lwork,
33217        info,
33218    )
33219}
33220
33221#[inline]
33222pub unsafe fn dsytrf_rook(
33223    uplo: u8,
33224    n: i32,
33225    a: &mut [f64],
33226    lda: i32,
33227    ipiv: &mut [i32],
33228    work: &mut [f64],
33229    lwork: i32,
33230    info: &mut i32,
33231) {
33232    ffi::dsytrf_rook_(
33233        &(uplo as c_char),
33234        &n,
33235        a.as_mut_ptr(),
33236        &lda,
33237        ipiv.as_mut_ptr(),
33238        work.as_mut_ptr(),
33239        &lwork,
33240        info,
33241    )
33242}
33243
33244#[inline]
33245pub unsafe fn csytrf_rook(
33246    uplo: u8,
33247    n: i32,
33248    a: &mut [c32],
33249    lda: i32,
33250    ipiv: &mut [i32],
33251    work: &mut [c32],
33252    lwork: i32,
33253    info: &mut i32,
33254) {
33255    ffi::csytrf_rook_(
33256        &(uplo as c_char),
33257        &n,
33258        a.as_mut_ptr() as *mut _,
33259        &lda,
33260        ipiv.as_mut_ptr(),
33261        work.as_mut_ptr() as *mut _,
33262        &lwork,
33263        info,
33264    )
33265}
33266
33267#[inline]
33268pub unsafe fn zsytrf_rook(
33269    uplo: u8,
33270    n: i32,
33271    a: &mut [c64],
33272    lda: i32,
33273    ipiv: &mut [i32],
33274    work: &mut [c64],
33275    lwork: i32,
33276    info: &mut i32,
33277) {
33278    ffi::zsytrf_rook_(
33279        &(uplo as c_char),
33280        &n,
33281        a.as_mut_ptr() as *mut _,
33282        &lda,
33283        ipiv.as_mut_ptr(),
33284        work.as_mut_ptr() as *mut _,
33285        &lwork,
33286        info,
33287    )
33288}
33289
33290#[inline]
33291pub unsafe fn ssytrs_rook(
33292    uplo: u8,
33293    n: i32,
33294    nrhs: i32,
33295    a: &[f32],
33296    lda: i32,
33297    ipiv: &[i32],
33298    b: &mut [f32],
33299    ldb: i32,
33300    info: &mut i32,
33301) {
33302    ffi::ssytrs_rook_(
33303        &(uplo as c_char),
33304        &n,
33305        &nrhs,
33306        a.as_ptr(),
33307        &lda,
33308        ipiv.as_ptr(),
33309        b.as_mut_ptr(),
33310        &ldb,
33311        info,
33312    )
33313}
33314
33315#[inline]
33316pub unsafe fn dsytrs_rook(
33317    uplo: u8,
33318    n: i32,
33319    nrhs: i32,
33320    a: &[f64],
33321    lda: i32,
33322    ipiv: &[i32],
33323    b: &mut [f64],
33324    ldb: i32,
33325    info: &mut i32,
33326) {
33327    ffi::dsytrs_rook_(
33328        &(uplo as c_char),
33329        &n,
33330        &nrhs,
33331        a.as_ptr(),
33332        &lda,
33333        ipiv.as_ptr(),
33334        b.as_mut_ptr(),
33335        &ldb,
33336        info,
33337    )
33338}
33339
33340#[inline]
33341pub unsafe fn csytrs_rook(
33342    uplo: u8,
33343    n: i32,
33344    nrhs: i32,
33345    a: &[c32],
33346    lda: i32,
33347    ipiv: &[i32],
33348    b: &mut [c32],
33349    ldb: i32,
33350    info: &mut i32,
33351) {
33352    ffi::csytrs_rook_(
33353        &(uplo as c_char),
33354        &n,
33355        &nrhs,
33356        a.as_ptr() as *const _,
33357        &lda,
33358        ipiv.as_ptr(),
33359        b.as_mut_ptr() as *mut _,
33360        &ldb,
33361        info,
33362    )
33363}
33364
33365#[inline]
33366pub unsafe fn zsytrs_rook(
33367    uplo: u8,
33368    n: i32,
33369    nrhs: i32,
33370    a: &[c64],
33371    lda: i32,
33372    ipiv: &[i32],
33373    b: &mut [c64],
33374    ldb: i32,
33375    info: &mut i32,
33376) {
33377    ffi::zsytrs_rook_(
33378        &(uplo as c_char),
33379        &n,
33380        &nrhs,
33381        a.as_ptr() as *const _,
33382        &lda,
33383        ipiv.as_ptr(),
33384        b.as_mut_ptr() as *mut _,
33385        &ldb,
33386        info,
33387    )
33388}
33389
33390#[inline]
33391pub unsafe fn chetrf_rook(
33392    uplo: u8,
33393    n: i32,
33394    a: &mut [c32],
33395    lda: i32,
33396    ipiv: &mut [i32],
33397    work: &mut [c32],
33398    lwork: i32,
33399    info: &mut i32,
33400) {
33401    ffi::chetrf_rook_(
33402        &(uplo as c_char),
33403        &n,
33404        a.as_mut_ptr() as *mut _,
33405        &lda,
33406        ipiv.as_mut_ptr(),
33407        work.as_mut_ptr() as *mut _,
33408        &lwork,
33409        info,
33410    )
33411}
33412
33413#[inline]
33414pub unsafe fn zhetrf_rook(
33415    uplo: u8,
33416    n: i32,
33417    a: &mut [c64],
33418    lda: i32,
33419    ipiv: &mut [i32],
33420    work: &mut [c64],
33421    lwork: i32,
33422    info: &mut i32,
33423) {
33424    ffi::zhetrf_rook_(
33425        &(uplo as c_char),
33426        &n,
33427        a.as_mut_ptr() as *mut _,
33428        &lda,
33429        ipiv.as_mut_ptr(),
33430        work.as_mut_ptr() as *mut _,
33431        &lwork,
33432        info,
33433    )
33434}
33435
33436#[inline]
33437pub unsafe fn chetrs_rook(
33438    uplo: u8,
33439    n: i32,
33440    nrhs: i32,
33441    a: &[c32],
33442    lda: i32,
33443    ipiv: &[i32],
33444    b: &mut [c32],
33445    ldb: i32,
33446    info: &mut i32,
33447) {
33448    ffi::chetrs_rook_(
33449        &(uplo as c_char),
33450        &n,
33451        &nrhs,
33452        a.as_ptr() as *const _,
33453        &lda,
33454        ipiv.as_ptr(),
33455        b.as_mut_ptr() as *mut _,
33456        &ldb,
33457        info,
33458    )
33459}
33460
33461#[inline]
33462pub unsafe fn zhetrs_rook(
33463    uplo: u8,
33464    n: i32,
33465    nrhs: i32,
33466    a: &[c64],
33467    lda: i32,
33468    ipiv: &[i32],
33469    b: &mut [c64],
33470    ldb: i32,
33471    info: &mut i32,
33472) {
33473    ffi::zhetrs_rook_(
33474        &(uplo as c_char),
33475        &n,
33476        &nrhs,
33477        a.as_ptr() as *const _,
33478        &lda,
33479        ipiv.as_ptr(),
33480        b.as_mut_ptr() as *mut _,
33481        &ldb,
33482        info,
33483    )
33484}
33485
33486#[inline]
33487pub unsafe fn csyr(uplo: u8, n: i32, alpha: c32, x: &[c32], incx: i32, a: &mut [c32], lda: i32) {
33488    ffi::csyr_(
33489        &(uplo as c_char),
33490        &n,
33491        &alpha as *const _ as *const _,
33492        x.as_ptr() as *const _,
33493        &incx,
33494        a.as_mut_ptr() as *mut _,
33495        &lda,
33496    )
33497}
33498
33499#[inline]
33500pub unsafe fn zsyr(uplo: u8, n: i32, alpha: c64, x: &[c64], incx: i32, a: &mut [c64], lda: i32) {
33501    ffi::zsyr_(
33502        &(uplo as c_char),
33503        &n,
33504        &alpha as *const _ as *const _,
33505        x.as_ptr() as *const _,
33506        &incx,
33507        a.as_mut_ptr() as *mut _,
33508        &lda,
33509    )
33510}
33511
33512#[inline]
33513pub unsafe fn ilaver(vers_major: &mut i32, vers_minor: &mut i32, vers_patch: &mut i32) {
33514    ffi::ilaver_(vers_major, vers_minor, vers_patch)
33515}
lapack/lib.rs

lapack/
lib.rs
