ops-mel 0.7.1

Mélodium core operations library
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

use melodium_core::*;
use melodium_macro::{check, mel_function, mel_treatment};

/// Return whether `a` is equal to `b`
#[mel_function]
pub fn equal(a: i16, b: i16) -> bool {
    a == b
}

/// Return whether `a` is different `b`
#[mel_function]
pub fn not_equal(a: i16, b: i16) -> bool {
    a != b
}

/// Determine whether `a` is equal to `b`
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output result Stream<bool>
)]
pub async fn equal() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(result.send_one_bool(a == b).await)
    }
}

/// Determine whether `a` is different from `b`
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output result Stream<bool>
)]
pub async fn not_equal() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(result.send_one_bool(a != b).await)
    }
}

/// Elevates `base` from `exponent`
#[mel_function]
pub fn pow(base: i16, exponent: i16) -> i16 {
    base.pow(exponent as u32)
}

/// Tells whether `a` is greater or equal to `b`.
#[mel_function]
pub fn ge(a: i16, b: i16) -> bool {
    a >= b
}

/// Tells whether `a` is lower or equal to `b`.
#[mel_function]
pub fn le(a: i16, b: i16) -> bool {
    a <= b
}

/// Elevates values from a stream of `i16` to the power of another one.
///
/// Values passed through `base` are elevated to the power of `exponent`.
#[mel_treatment(
    input base Stream<i16>
    input exponent Stream<i16>
    output power Stream<i16>
)]
pub async fn pow() {
    while let (Ok(base), Ok(exp)) = (base.recv_one_i16().await, exponent.recv_one_i16().await) {
        check!(power.send_one_i16(base.pow(exp as u32)).await)
    }
}

/// Determine whether `a` is lower or equal to `b`
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output is Stream<bool>
)]
pub async fn lower_equal() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(is.send_one_bool(a <= b).await)
    }
}

/// Determine whether `a` is greater or equal to `b`
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output is Stream<bool>
)]
pub async fn greater_equal() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(is.send_one_bool(a >= b).await)
    }
}

/// Add `a` and `b`
#[mel_function]
pub fn add(a: i16, b: i16) -> i16 {
    a + b
}

/// Divide `dividend` by `divisor`
#[mel_function]
pub fn div(dividend: i16, divisor: i16) -> i16 {
    dividend / divisor
}

/// Multiply `a` by `b`
#[mel_function]
pub fn mult(a: i16, b: i16) -> i16 {
    a * b
}

/// Get the remainder of `dividend` by `divisor`
#[mel_function]
pub fn rem(dividend: i16, divisor: i16) -> i16 {
    dividend % divisor
}

/// Substract `b` from `a`
#[mel_function]
pub fn sub(a: i16, b: i16) -> i16 {
    a - b
}

/// Tells whether `a` is strictly greater than `b`.
#[mel_function]
pub fn gt(a: i16, b: i16) -> bool {
    a > b
}

/// Tells whether `a` is strictly lower than `b`.
#[mel_function]
pub fn lt(a: i16, b: i16) -> bool {
    a < b
}

/// Compares and gives the minimum of two values.
#[mel_function]
pub fn min(a: i16, b: i16) -> i16 {
    a.min(b)
}

/// Compares and gives the maximum of two values.
#[mel_function]
pub fn max(a: i16, b: i16) -> i16 {
    a.max(b)
}

/// Add values from two streams of `i16`.
///
/// Values passed through `a` & `b` are added and send in sum.
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output sum Stream<i16>
)]
pub async fn add() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(sum.send_one_i16(a + b).await)
    }
}

/// Divide values from two streams of `i16`.
///
/// Every `a` number passed through the stream is divided by `b` counterpart.
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output quotient Stream<i16>
)]
pub async fn div() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(quotient.send_one_i16(a / b).await)
    }
}

/// Multiply values from two streams of `i16`.
///
/// Every `a` number passed through the stream is multiplied by `b` counterpart.
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output product Stream<i16>
)]
pub async fn mult() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(product.send_one_i16(a * b).await)
    }
}

/// Give the remainder of the division from two streams of `i16`.
///
/// Every `a` number passed through the stream is divided by `b` and the remainder is outputted.
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output remainder Stream<i16>
)]
pub async fn rem() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(remainder.send_one_i16(a % b).await)
    }
}

/// Substract values from two streams of `i16`.
///
/// Every `a` number passed through the stream get `b` substracted.
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output diff Stream<i16>
)]
pub async fn sub() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(diff.send_one_i16(a - b).await)
    }
}

/// Compares and gives the minimum of two values.
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output min Stream<i16>
)]
pub async fn min() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(min.send_one_i16(a.min(b)).await)
    }
}

/// Compares and gives the maximum of two values.
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output max Stream<i16>
)]
pub async fn max() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(max.send_one_i16(a.max(b)).await)
    }
}

/// Determine whether `a` is strictly lower than `b`
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output is Stream<bool>
)]
pub async fn lower_than() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(is.send_one_bool(a < b).await)
    }
}

/// Determine whether `a` is strictly greater than `b`
#[mel_treatment(
    input a Stream<i16>
    input b Stream<i16>
    output is Stream<bool>
)]
pub async fn greater_than() {
    while let (Ok(a), Ok(b)) = (a.recv_one_i16().await, b.recv_one_i16().await) {
        check!(is.send_one_bool(a > b).await)
    }
}

/// Get absolute value
#[mel_function]
pub fn abs(value: i16) -> i16 {
    value.abs()
}

/// Get the absolute values from a stream of `i16`.
#[mel_treatment(
    input value Stream<i16>
    output abs Stream<i16>
)]
pub async fn abs() {
    while let Ok(values) = value.recv_i16().await {
        check!(
            abs.send_i16(values.into_iter().map(|v| v.abs()).collect())
                .await
        )
    }
}