c-api-tools 0.1.0

Tools for the creation of C API bindings.
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Useful conversion types.

/// Representation of scalar numeric type information
/// as runtime parameter.
#[derive(Debug, Clone, Copy, PartialEq)]
#[repr(u8)]
pub enum DType {
    /// Float 32
    F32,
    /// Float 64
    F64,
    /// Complex 32
    C32,
    /// Complex 64
    C64,
    /// Unsigned int 8
    U8,
    /// Unsigned int 32
    U32,
    /// Unsigned int 64
    U64,
    /// Int 8
    I8,
    /// Int 32
    I32,
    /// Int 64
    I64,
    /// Undefined type
    Undefined,
}

impl DType {
    /// Return true of type is real.
    pub fn is_real(&self) -> bool {
        matches!(
            self,
            DType::F32
                | DType::F64
                | DType::U8
                | DType::U32
                | DType::U64
                | DType::I8
                | DType::I32
                | DType::I64,
        )
    }

    /// Return true if type is complex.
    pub fn is_complex(&self) -> bool {
        matches!(self, DType::C32 | DType::C64)
    }

    /// Return the associated real type.
    pub fn real_type(&self) -> DType {
        match self {
            DType::C32 => DType::F32,
            DType::C64 => DType::F64,
            _ => *self,
        }
    }

    /// Return the associated complex type.
    ///
    /// If there is no associated complex type `DType::Undefined` is returned.
    pub fn complex_type(&self) -> DType {
        match self {
            DType::F32 => DType::C32,
            DType::F64 => DType::C64,
            _ => DType::Undefined,
        }
    }
}

/// Runtime numeric type information.
pub trait DTypeIdentifier {
    /// Return runtime numeric type information.
    fn dtype() -> DType;
}

impl DTypeIdentifier for f32 {
    fn dtype() -> DType {
        DType::F32
    }
}

impl DTypeIdentifier for f64 {
    fn dtype() -> DType {
        DType::F64
    }
}

impl DTypeIdentifier for num::complex::Complex<f32> {
    fn dtype() -> DType {
        DType::C32
    }
}

impl DTypeIdentifier for num::complex::Complex<f64> {
    fn dtype() -> DType {
        DType::C64
    }
}

impl DTypeIdentifier for u8 {
    fn dtype() -> DType {
        DType::U8
    }
}

impl DTypeIdentifier for u32 {
    fn dtype() -> DType {
        DType::U32
    }
}

impl DTypeIdentifier for u64 {
    fn dtype() -> DType {
        DType::U64
    }
}

impl DTypeIdentifier for i8 {
    fn dtype() -> DType {
        DType::I8
    }
}

impl DTypeIdentifier for i32 {
    fn dtype() -> DType {
        DType::I32
    }
}

impl DTypeIdentifier for i64 {
    fn dtype() -> DType {
        DType::I64
    }
}