mathru 0.16.2

Fundamental algorithms for scientific computing in Rust
Documentation 
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

use crate::algebra::abstr::Complex;
use crate::algebra::abstr::MatrixMultiply;
use matrixmultiply::{cgemm, dgemm, sgemm, zgemm, CGemmOption};

macro_rules! matrix_multiply_impl (
    ($T: ty, $xgemm: path, $cgemm: path)
    => (
        impl MatrixMultiply for $T
       	{
       		fn xgemm(
                m: usize,
                k: usize,
                n: usize,
                alpha: Self,
                a: *const Self,
                rsa: isize,
                csa: isize,
                b: *const Self,
                rsb: isize,
                csb: isize,
                beta: Self,
                c: *mut Self,
                rsc: isize,
                csc: isize
            )
			{
				unsafe
				{
					$xgemm(
						m,
                        k,
						n,
						alpha,
						a,
                        rsa,
                        csa,
						b,
						rsb,
                        csb,
						beta,
						c,
						rsc,
                        csc
						)
				}
			}
        }

        impl MatrixMultiply for Complex<$T>
       	{
       		fn xgemm(
                m: usize,
                k: usize,
                n: usize,
                alpha: Self,
                a: *const Self,
                rsa: isize,
                csa: isize,
                b: *const Self,
                rsb: isize,
                csb: isize,
                beta: Self,
                c: *mut Self,
                rsc: isize,
                csc: isize
            )
			{
				unsafe
				{
					$cgemm(
                        CGemmOption::Standard,
                        CGemmOption::Standard,
						m,
                        k,
						n,
						*(&alpha as *const _ as *const _),
						a as *const _ as *const _ ,
                        rsa,
                        csa,
						b as *const _ as *const _ ,
						rsb,
                        csb,
						*(&beta as *const _ as *const _),
						c as *mut _ as *mut _ ,
						rsc,
                        csc
						)
				}
			}
        }
    )
);

matrix_multiply_impl!(f32, sgemm, cgemm);
matrix_multiply_impl!(f64, dgemm, zgemm);