linxal 0.6.0

Linear Algebra package with rust-ndarray interface
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use super::ffi;
use libc::c_char;
use lapack::{c32, c64};

#[inline]
pub fn slaror(side: u8, init: u8, m: i32, n: i32, a: &mut [f32], lda: i32, iseed: &mut [i32],
              x: &mut [f32], info: &mut i32) {

    unsafe {
        ffi::slaror_(&(side as c_char), &(init as c_char), &m, &n, a.as_mut_ptr(), &lda,
                     iseed.as_mut_ptr(), x.as_mut_ptr(), info)
    }
}

#[inline]
pub fn dlaror(side: u8, init: u8, m: i32, n: i32, a: &mut [f64], lda: i32, iseed: &mut [i32],
              x: &mut [f64], info: &mut i32) {

    unsafe {
        ffi::dlaror_(&(side as c_char), &(init as c_char), &m, &n, a.as_mut_ptr(), &lda,
                     iseed.as_mut_ptr(), x.as_mut_ptr(), info)
    }
}

#[inline]
pub fn claror(side: u8, init: u8, m: i32, n: i32, a: &mut [c32], lda: i32, iseed: &mut [i32],
              x: &mut [c32], info: &mut i32) {

    unsafe {
        ffi::claror_(&(side as c_char), &(init as c_char), &m, &n, a.as_mut_ptr() as *mut _, &lda,
                     iseed.as_mut_ptr(), x.as_mut_ptr() as *mut _, info)
    }
}

#[inline]
pub fn zlaror(side: u8, init: u8, m: i32, n: i32, a: &mut [c64], lda: i32, iseed: &mut [i32],
              x: &mut [c64], info: &mut i32) {

    unsafe {
        ffi::zlaror_(&(side as c_char), &(init as c_char), &m, &n, a.as_mut_ptr() as *mut _, &lda,
                     iseed.as_mut_ptr(), x.as_mut_ptr() as *mut _, info)
    }
}

#[inline]
pub fn slatmt(m: i32, n: i32, dist: u8, iseed: &mut [i32],
              sym: u8, d: &mut [f32], mode: i32,
              cond: f32, dmax: f32, rank: i32, kl: i32, ku: i32,
              pack: u8, a: &mut [f32], lda: i32,
              work: &mut [f32]) -> i32 {
    let mut info = 0;
    unsafe {
        ffi::slatmt_(&m, &n, &(dist as c_char), iseed.as_mut_ptr(),
                    &(sym as c_char), d.as_mut_ptr(), &mode,
                    &cond, &dmax, &rank, &kl, &ku,
                    &(pack as c_char), a.as_mut_ptr(), &lda,
                    work.as_mut_ptr(), &mut info);
    }
    info
}

#[inline]
pub fn dlatmt(m: i32, n: i32, dist: u8, iseed: &mut [i32],
              sym: u8, d: &mut [f64], mode: i32,
              cond: f64, dmax: f64, rank: i32, kl: i32, ku: i32,
              pack: u8, a: &mut [f64], lda: i32,
              work: &mut [f64]) -> i32 {
    let mut info = 0;
    unsafe {
        ffi::dlatmt_(&m, &n, &(dist as c_char), iseed.as_mut_ptr(),
                    &(sym as c_char), d.as_mut_ptr(), &mode,
                    &cond, &dmax, &rank, &kl, &ku,
                    &(pack as c_char), a.as_mut_ptr(), &lda,
                    work.as_mut_ptr(), &mut info);
    }
    info
}

#[inline]
pub fn clatmt(m: i32, n: i32, dist: u8, iseed: &mut [i32],
              sym: u8, d: &mut [f32], mode: i32,
              cond: f32, dmax: f32, rank: i32, kl: i32, ku: i32,
              pack: u8, a: &mut [c32], lda: i32,
              work: &mut [c32]) -> i32 {
    let mut info = 0;
    unsafe {
        ffi::clatmt_(&m, &n, &(dist as c_char), iseed.as_mut_ptr(),
                    &(sym as c_char), d.as_mut_ptr(), &mode,
                    &cond, &dmax, &rank, &kl, &ku,
                    &(pack as c_char), a.as_mut_ptr() as *mut _, &lda,
                    work.as_mut_ptr() as *mut _, &mut info);
    }
    info
}


#[inline]
pub fn zlatmt(m: i32, n: i32, dist: u8, iseed: &mut [i32],
              sym: u8, d: &mut [f64], mode: i32,
              cond: f64, dmax: f64, rank: i32, kl: i32, ku: i32,
              pack: u8, a: &mut [c64], lda: i32,
              work: &mut [c64]) -> i32 {
    let mut info = 0;
    unsafe {
        ffi::zlatmt_(&m, &n, &(dist as c_char), iseed.as_mut_ptr(),
                    &(sym as c_char), d.as_mut_ptr(), &mode,
                    &cond, &dmax, &rank, &kl, &ku,
                    &(pack as c_char), a.as_mut_ptr() as *mut _, &lda,
                    work.as_mut_ptr() as *mut _, &mut info);
    }
    info
}