runmat-builtins 0.6.2

RunMat built-in functions and standard library components
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
139
140
141
142
143
144
145
146
147
148
149

use serde::Serialize;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum BuiltinIntegerClass {
    Int8,
    Int16,
    Int32,
    Int64,
    Uint8,
    Uint16,
    Uint32,
    Uint64,
}

pub const ALL_INTEGER_CLASSES: [BuiltinIntegerClass; 8] = [
    BuiltinIntegerClass::Int8,
    BuiltinIntegerClass::Int16,
    BuiltinIntegerClass::Int32,
    BuiltinIntegerClass::Int64,
    BuiltinIntegerClass::Uint8,
    BuiltinIntegerClass::Uint16,
    BuiltinIntegerClass::Uint32,
    BuiltinIntegerClass::Uint64,
];

pub const SIGNED_INTEGER_CLASSES: [BuiltinIntegerClass; 4] = [
    BuiltinIntegerClass::Int8,
    BuiltinIntegerClass::Int16,
    BuiltinIntegerClass::Int32,
    BuiltinIntegerClass::Int64,
];

pub const INTEGER_CLASSES_THROUGH_16_BITS: [BuiltinIntegerClass; 4] = [
    BuiltinIntegerClass::Int8,
    BuiltinIntegerClass::Int16,
    BuiltinIntegerClass::Uint8,
    BuiltinIntegerClass::Uint16,
];

pub const INTEGER_CLASSES_THROUGH_32_BITS: [BuiltinIntegerClass; 6] = [
    BuiltinIntegerClass::Int8,
    BuiltinIntegerClass::Int16,
    BuiltinIntegerClass::Int32,
    BuiltinIntegerClass::Uint8,
    BuiltinIntegerClass::Uint16,
    BuiltinIntegerClass::Uint32,
];

pub const UNSIGNED_8_16_CLASSES: [BuiltinIntegerClass; 2] =
    [BuiltinIntegerClass::Uint8, BuiltinIntegerClass::Uint16];

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum BuiltinIntegerScalarDoubleRule {
    NotApplicable,
    Allowed,
    AllowedExceptWith64BitInteger,
    Rejected,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum BuiltinIntegerInputAvailability {
    Documented,
    RunMatOnly,
    Rejected,
}

#[derive(Debug, Clone, Serialize)]
pub struct BuiltinIntegerInputCapability {
    pub name: &'static str,
    pub classes: &'static [BuiltinIntegerClass],
    pub availability: BuiltinIntegerInputAvailability,
    pub scalar_double: BuiltinIntegerScalarDoubleRule,
    pub notes: &'static str,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum BuiltinIntegerComputationDomain {
    ExactInteger,
    FloatingPoint,
    Predicate,
    Structural,
    FunctionSpecific,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum BuiltinIntegerOutputClassRule {
    PreserveInput,
    PreserveNondoubleInput,
    Double,
    Logical,
    OptionDependent,
    NotApplicable,
    FunctionSpecific,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum BuiltinIntegerOverflowRule {
    Saturate,
    Error,
    NotApplicable,
    EvidenceOpen,
    FunctionSpecific,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum BuiltinIntegerBackendRule {
    HostOnly,
    HostAndGpu,
    GatherFallback,
    GpuRestricted,
    FunctionSpecific,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum BuiltinIntegerOverloadKind {
    ScalarOnly,
    ElementwiseShapePreserving,
    SameSizeOrScalar,
    BroadcastCompatible,
    StructuralParameter,
    Multiple,
    FunctionSpecific,
}

#[derive(Debug, Clone, Serialize)]
pub struct BuiltinIntegerCapabilityDescriptor {
    pub form: &'static str,
    pub inputs: &'static [BuiltinIntegerInputCapability],
    pub computation_domain: BuiltinIntegerComputationDomain,
    pub output_class: BuiltinIntegerOutputClassRule,
    pub overflow: BuiltinIntegerOverflowRule,
    pub backend: BuiltinIntegerBackendRule,
    pub overload: BuiltinIntegerOverloadKind,
    pub notes: &'static str,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub enum BuiltinIntegerAuditKind {
    AliasOf,
    NotApplicable,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct BuiltinIntegerAuditDescriptor {
    pub kind: BuiltinIntegerAuditKind,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub canonical_builtin: Option<&'static str>,
    pub notes: &'static str,
}