1 /*
2 SuperCollider real time audio synthesis system
3 Copyright (c) 2002 James McCartney. All rights reserved.
4 http://www.audiosynth.com
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21
22 #include "SC_PlugIn.h"
23
24 #include <boost/align/is_aligned.hpp>
25
26 #ifdef _MSC_VER
27 // hypotf is c99, but not c++
28 # define hypotf _hypotf
29 #endif
30
31 #ifdef NOVA_SIMD
32 # include "simd_binary_arithmetic.hpp"
33 # include "simd_math.hpp"
34 # include "simd_memory.hpp"
35
36
37 # include "function_attributes.h"
38 using nova::slope_argument;
39
40 # define NOVA_BINARY_WRAPPER(SCNAME, NOVANAME) \
41 FLATTEN void SCNAME##_aa_nova(BinaryOpUGen* unit, int inNumSamples) { \
42 nova::NOVANAME##_vec_simd(OUT(0), IN(0), IN(1), inNumSamples); \
43 } \
44 \
45 FLATTEN void SCNAME##_aa_nova_64(BinaryOpUGen* unit, int inNumSamples) { \
46 nova::NOVANAME##_vec_simd<64>(OUT(0), IN(0), IN(1)); \
47 } \
48 \
49 FLATTEN void SCNAME##_ia_nova(BinaryOpUGen* unit, int inNumSamples) { \
50 float xa = ZIN0(0); \
51 \
52 nova::NOVANAME##_vec_simd(OUT(0), xa, IN(1), inNumSamples); \
53 unit->mPrevA = xa; \
54 } \
55 \
56 FLATTEN void SCNAME##_ia_nova_64(BinaryOpUGen* unit, int inNumSamples) { \
57 float xa = ZIN0(0); \
58 \
59 nova::NOVANAME##_vec_simd<64>(OUT(0), xa, IN(1)); \
60 unit->mPrevA = xa; \
61 } \
62 \
63 FLATTEN void SCNAME##_ai_nova(BinaryOpUGen* unit, int inNumSamples) { \
64 float xb = ZIN0(1); \
65 \
66 nova::NOVANAME##_vec_simd(OUT(0), IN(0), xb, inNumSamples); \
67 unit->mPrevB = xb; \
68 } \
69 \
70 FLATTEN void SCNAME##_ai_nova_64(BinaryOpUGen* unit, int inNumSamples) { \
71 float xb = ZIN0(1); \
72 \
73 nova::NOVANAME##_vec_simd<64>(OUT(0), IN(0), xb); \
74 unit->mPrevB = xb; \
75 }
76
77 # define NOVA_BINARY_WRAPPER_K(SCNAME, NOVANAME) \
78 FLATTEN void SCNAME##_aa_nova(BinaryOpUGen* unit, int inNumSamples) { \
79 nova::NOVANAME##_vec_simd(OUT(0), IN(0), IN(1), inNumSamples); \
80 } \
81 \
82 FLATTEN void SCNAME##_aa_nova_64(BinaryOpUGen* unit, int inNumSamples) { \
83 nova::NOVANAME##_vec_simd<64>(OUT(0), IN(0), IN(1)); \
84 } \
85 \
86 FLATTEN void SCNAME##_ia_nova(BinaryOpUGen* unit, int inNumSamples) { \
87 float xa = ZIN0(0); \
88 \
89 nova::NOVANAME##_vec_simd(OUT(0), xa, IN(1), inNumSamples); \
90 unit->mPrevA = xa; \
91 } \
92 \
93 FLATTEN void SCNAME##_ia_nova_64(BinaryOpUGen* unit, int inNumSamples) { \
94 float xa = ZIN0(0); \
95 \
96 nova::NOVANAME##_vec_simd<64>(OUT(0), xa, IN(1)); \
97 unit->mPrevA = xa; \
98 } \
99 \
100 FLATTEN void SCNAME##_ai_nova(BinaryOpUGen* unit, int inNumSamples) { \
101 float xb = ZIN0(1); \
102 \
103 nova::NOVANAME##_vec_simd(OUT(0), IN(0), xb, inNumSamples); \
104 unit->mPrevB = xb; \
105 } \
106 \
107 FLATTEN void SCNAME##_ai_nova_64(BinaryOpUGen* unit, int inNumSamples) { \
108 float xb = ZIN0(1); \
109 \
110 nova::NOVANAME##_vec_simd<64>(OUT(0), IN(0), xb); \
111 unit->mPrevB = xb; \
112 } \
113 \
114 FLATTEN void SCNAME##_ak_nova(BinaryOpUGen* unit, int inNumSamples) { \
115 float xb = unit->mPrevB; \
116 float next_b = ZIN0(1); \
117 \
118 if (xb == next_b) { \
119 nova::NOVANAME##_vec_simd(OUT(0), IN(0), xb, inNumSamples); \
120 } else { \
121 float slope = CALCSLOPE(next_b, xb); \
122 nova::NOVANAME##_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples); \
123 unit->mPrevB = next_b; \
124 } \
125 } \
126 \
127 FLATTEN void SCNAME##_ak_nova_64(BinaryOpUGen* unit, int inNumSamples) { \
128 float xb = unit->mPrevB; \
129 float next_b = ZIN0(1); \
130 \
131 if (xb == next_b) { \
132 nova::NOVANAME##_vec_simd<64>(OUT(0), IN(0), xb); \
133 } else { \
134 float slope = CALCSLOPE(next_b, xb); \
135 nova::NOVANAME##_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples); \
136 unit->mPrevB = next_b; \
137 } \
138 } \
139 \
140 FLATTEN void SCNAME##_ka_nova(BinaryOpUGen* unit, int inNumSamples) { \
141 float xa = unit->mPrevA; \
142 float next_a = ZIN0(0); \
143 \
144 if (xa == next_a) { \
145 nova::NOVANAME##_vec_simd(OUT(0), xa, IN(1), inNumSamples); \
146 } else { \
147 float slope = CALCSLOPE(next_a, xa); \
148 nova::NOVANAME##_vec_simd(OUT(0), slope_argument(xa, slope), IN(1), inNumSamples); \
149 unit->mPrevA = next_a; \
150 } \
151 } \
152 FLATTEN void SCNAME##_ka_nova_64(BinaryOpUGen* unit, int inNumSamples) { \
153 float xa = unit->mPrevA; \
154 float next_a = ZIN0(0); \
155 \
156 if (xa == next_a) { \
157 nova::NOVANAME##_vec_simd<64>(OUT(0), xa, IN(1)); \
158 } else { \
159 float slope = CALCSLOPE(next_a, xa); \
160 nova::NOVANAME##_vec_simd(OUT(0), slope_argument(xa, slope), IN(1), inNumSamples); \
161 unit->mPrevA = next_a; \
162 } \
163 }
164
165
166 # define DEFINE_TEMPLATE_FUNCTOR(NAME) \
167 struct NAME##_functor { \
168 template <typename FloatType> inline FloatType operator()(FloatType a, FloatType b) const { \
169 return NAME(a, b); \
170 } \
171 \
172 template <typename FloatType> \
173 inline nova::vec<FloatType> operator()(nova::vec<FloatType> a, nova::vec<FloatType> b) const { \
174 return NAME(a, b); \
175 } \
176 };
177
178 DEFINE_TEMPLATE_FUNCTOR(sc_ring1)
179 DEFINE_TEMPLATE_FUNCTOR(sc_ring2)
180 DEFINE_TEMPLATE_FUNCTOR(sc_ring3)
181 DEFINE_TEMPLATE_FUNCTOR(sc_ring4)
182
183 DEFINE_TEMPLATE_FUNCTOR(sc_difsqr)
184 DEFINE_TEMPLATE_FUNCTOR(sc_sumsqr)
185 DEFINE_TEMPLATE_FUNCTOR(sc_sqrsum)
186 DEFINE_TEMPLATE_FUNCTOR(sc_sqrdif)
187
188 namespace nova {
189 NOVA_SIMD_DEFINE_BINARY_WRAPPER(sc_ring1, sc_ring1_functor)
190 NOVA_SIMD_DEFINE_BINARY_WRAPPER(sc_ring2, sc_ring2_functor)
191 NOVA_SIMD_DEFINE_BINARY_WRAPPER(sc_ring3, sc_ring3_functor)
192 NOVA_SIMD_DEFINE_BINARY_WRAPPER(sc_ring4, sc_ring4_functor)
193
194 NOVA_SIMD_DEFINE_BINARY_WRAPPER(sc_difsqr, sc_difsqr_functor)
195 NOVA_SIMD_DEFINE_BINARY_WRAPPER(sc_sumsqr, sc_sumsqr_functor)
196 NOVA_SIMD_DEFINE_BINARY_WRAPPER(sc_sqrsum, sc_sqrsum_functor)
197 NOVA_SIMD_DEFINE_BINARY_WRAPPER(sc_sqrdif, sc_sqrdif_functor)
198 }
199
200 #endif
201
202 using namespace std; // for math functions
203
204 static InterfaceTable* ft;
205
206 //////////////////////////////////////////////////////////////////////////////////////////////////
207
208
209 /* special binary math operators */
210 enum {
211 opAdd,
212 opSub,
213 opMul,
214 opIDiv,
215 opFDiv,
216 opMod,
217 opEQ,
218 opNE,
219 opLT,
220 opGT,
221 opLE,
222 opGE,
223 // opIdentical,
224 // opNotIdentical,
225
226 opMin,
227 opMax,
228 opBitAnd,
229 opBitOr,
230 opBitXor,
231 opLCM,
232 opGCD,
233 opRound,
234 opRoundUp,
235 opTrunc,
236 opAtan2,
237 opHypot,
238 opHypotx,
239 opPow,
240 opShiftLeft, //
241 opShiftRight, //
242 opUnsignedShift, //
243 opFill, //
244 opRing1, // a * (b + 1) == a * b + a
245 opRing2, // a * b + a + b
246 opRing3, // a*a*b
247 opRing4, // a*a*b - a*b*b
248 opDifSqr, // a*a - b*b
249 opSumSqr, // a*a + b*b
250 opSqrSum, // (a + b)^2
251 opSqrDif, // (a - b)^2
252 opAbsDif, // |a - b|
253 opThresh,
254 opAMClip,
255 opScaleNeg,
256 opClip2,
257 opExcess,
258 opFold2,
259 opWrap2,
260 opFirstArg,
261 opRandRange,
262 opExpRandRange,
263
264 opNumBinarySelectors
265 };
266
267
sc_andt(float a,float b)268 inline float sc_andt(float a, float b) { return int(a) & int(b); }
269
sc_ort(float a,float b)270 inline float sc_ort(float a, float b) { return int(a) | int(b); }
271
sc_xort(float a,float b)272 inline float sc_xort(float a, float b) { return int(a) ^ int(b); }
273
sc_rst(float a,float b)274 inline float sc_rst(float a, float b) { return int(a) >> int(b); }
275
sc_lst(float a,float b)276 inline float sc_lst(float a, float b) { return int(a) << int(b); }
277
278 struct BinaryOpUGen : public Unit {
279 float mPrevA, mPrevB;
280 };
281
282 typedef void (*BinaryOpFunc)(BinaryOpUGen* unit, int inNumSamples);
283
284 extern "C" {
285
286 void BinaryOpUGen_Ctor(BinaryOpUGen* unit);
287
288 // void zero_d(BinaryOpUGen *unit, int inNumSamples);
289 void zero_1(BinaryOpUGen* unit, int inNumSamples);
290 void zero_aa(BinaryOpUGen* unit, int inNumSamples);
291 void firstarg_d(BinaryOpUGen* unit, int inNumSamples);
292 void firstarg_1(BinaryOpUGen* unit, int inNumSamples);
293 void firstarg_aa(BinaryOpUGen* unit, int inNumSamples);
294 void secondarg_d(BinaryOpUGen* unit, int inNumSamples);
295 void secondarg_1(BinaryOpUGen* unit, int inNumSamples);
296 void secondarg_aa(BinaryOpUGen* unit, int inNumSamples);
297 void add_d(BinaryOpUGen* unit, int inNumSamples);
298 void add_1(BinaryOpUGen* unit, int inNumSamples);
299 void add_aa(BinaryOpUGen* unit, int inNumSamples);
300 void add_ak(BinaryOpUGen* unit, int inNumSamples);
301 void add_ka(BinaryOpUGen* unit, int inNumSamples);
302 void add_ai(BinaryOpUGen* unit, int inNumSamples);
303 void add_ia(BinaryOpUGen* unit, int inNumSamples);
304 void sub_d(BinaryOpUGen* unit, int inNumSamples);
305 void sub_1(BinaryOpUGen* unit, int inNumSamples);
306 void sub_aa(BinaryOpUGen* unit, int inNumSamples);
307 void sub_ak(BinaryOpUGen* unit, int inNumSamples);
308 void sub_ka(BinaryOpUGen* unit, int inNumSamples);
309 void sub_ai(BinaryOpUGen* unit, int inNumSamples);
310 void sub_ia(BinaryOpUGen* unit, int inNumSamples);
311 void mul_d(BinaryOpUGen* unit, int inNumSamples);
312 void mul_1(BinaryOpUGen* unit, int inNumSamples);
313 void mul_aa(BinaryOpUGen* unit, int inNumSamples);
314 void mul_ak(BinaryOpUGen* unit, int inNumSamples);
315 void mul_ka(BinaryOpUGen* unit, int inNumSamples);
316 void mul_ai(BinaryOpUGen* unit, int inNumSamples);
317 void mul_ia(BinaryOpUGen* unit, int inNumSamples);
318 void div_d(BinaryOpUGen* unit, int inNumSamples);
319 void div_1(BinaryOpUGen* unit, int inNumSamples);
320 void div_aa(BinaryOpUGen* unit, int inNumSamples);
321 void div_ak(BinaryOpUGen* unit, int inNumSamples);
322 void div_ka(BinaryOpUGen* unit, int inNumSamples);
323 void div_ai(BinaryOpUGen* unit, int inNumSamples);
324 void div_ia(BinaryOpUGen* unit, int inNumSamples);
325 void mod_d(BinaryOpUGen* unit, int inNumSamples);
326 void mod_1(BinaryOpUGen* unit, int inNumSamples);
327 void mod_aa(BinaryOpUGen* unit, int inNumSamples);
328 void mod_ak(BinaryOpUGen* unit, int inNumSamples);
329 void mod_ka(BinaryOpUGen* unit, int inNumSamples);
330 void mod_ai(BinaryOpUGen* unit, int inNumSamples);
331 void mod_ia(BinaryOpUGen* unit, int inNumSamples);
332 void max_d(BinaryOpUGen* unit, int inNumSamples);
333 void max_1(BinaryOpUGen* unit, int inNumSamples);
334 void max_aa(BinaryOpUGen* unit, int inNumSamples);
335 void max_ak(BinaryOpUGen* unit, int inNumSamples);
336 void max_ka(BinaryOpUGen* unit, int inNumSamples);
337 void max_ai(BinaryOpUGen* unit, int inNumSamples);
338 void max_ia(BinaryOpUGen* unit, int inNumSamples);
339 void min_d(BinaryOpUGen* unit, int inNumSamples);
340 void min_1(BinaryOpUGen* unit, int inNumSamples);
341 void min_aa(BinaryOpUGen* unit, int inNumSamples);
342 void min_ak(BinaryOpUGen* unit, int inNumSamples);
343 void min_ka(BinaryOpUGen* unit, int inNumSamples);
344 void min_ai(BinaryOpUGen* unit, int inNumSamples);
345 void min_ia(BinaryOpUGen* unit, int inNumSamples);
346
347 void and_d(BinaryOpUGen* unit, int inNumSamples);
348 void and_1(BinaryOpUGen* unit, int inNumSamples);
349 void and_aa(BinaryOpUGen* unit, int inNumSamples);
350 void and_ak(BinaryOpUGen* unit, int inNumSamples);
351 void and_ka(BinaryOpUGen* unit, int inNumSamples);
352 void and_ai(BinaryOpUGen* unit, int inNumSamples);
353 void and_ia(BinaryOpUGen* unit, int inNumSamples);
354
355 void or_d(BinaryOpUGen* unit, int inNumSamples);
356 void or_1(BinaryOpUGen* unit, int inNumSamples);
357 void or_aa(BinaryOpUGen* unit, int inNumSamples);
358 void or_ak(BinaryOpUGen* unit, int inNumSamples);
359 void or_ka(BinaryOpUGen* unit, int inNumSamples);
360 void or_ai(BinaryOpUGen* unit, int inNumSamples);
361 void or_ia(BinaryOpUGen* unit, int inNumSamples);
362
363 void xor_d(BinaryOpUGen* unit, int inNumSamples);
364 void xor_1(BinaryOpUGen* unit, int inNumSamples);
365 void xor_aa(BinaryOpUGen* unit, int inNumSamples);
366 void xor_ak(BinaryOpUGen* unit, int inNumSamples);
367 void xor_ka(BinaryOpUGen* unit, int inNumSamples);
368 void xor_ai(BinaryOpUGen* unit, int inNumSamples);
369 void xor_ia(BinaryOpUGen* unit, int inNumSamples);
370
371 void amclip_d(BinaryOpUGen* unit, int inNumSamples);
372 void amclip_1(BinaryOpUGen* unit, int inNumSamples);
373 void amclip_aa(BinaryOpUGen* unit, int inNumSamples);
374 void amclip_ak(BinaryOpUGen* unit, int inNumSamples);
375 void amclip_ka(BinaryOpUGen* unit, int inNumSamples);
376 void amclip_ai(BinaryOpUGen* unit, int inNumSamples);
377 void amclip_ia(BinaryOpUGen* unit, int inNumSamples);
378 void scaleneg_d(BinaryOpUGen* unit, int inNumSamples);
379 void scaleneg_1(BinaryOpUGen* unit, int inNumSamples);
380 void scaleneg_aa(BinaryOpUGen* unit, int inNumSamples);
381 void scaleneg_ak(BinaryOpUGen* unit, int inNumSamples);
382 void scaleneg_ka(BinaryOpUGen* unit, int inNumSamples);
383 void scaleneg_ai(BinaryOpUGen* unit, int inNumSamples);
384 void scaleneg_ia(BinaryOpUGen* unit, int inNumSamples);
385 void pow_d(BinaryOpUGen* unit, int inNumSamples);
386 void pow_1(BinaryOpUGen* unit, int inNumSamples);
387 void pow_aa(BinaryOpUGen* unit, int inNumSamples);
388 void pow_ak(BinaryOpUGen* unit, int inNumSamples);
389 void pow_ka(BinaryOpUGen* unit, int inNumSamples);
390 void pow_ai(BinaryOpUGen* unit, int inNumSamples);
391 void pow_ia(BinaryOpUGen* unit, int inNumSamples);
392 void ring1_d(BinaryOpUGen* unit, int inNumSamples);
393 void ring1_1(BinaryOpUGen* unit, int inNumSamples);
394 void ring1_aa(BinaryOpUGen* unit, int inNumSamples);
395 void ring1_ak(BinaryOpUGen* unit, int inNumSamples);
396 void ring1_ka(BinaryOpUGen* unit, int inNumSamples);
397 void ring1_ai(BinaryOpUGen* unit, int inNumSamples);
398 void ring1_ia(BinaryOpUGen* unit, int inNumSamples);
399 void ring2_d(BinaryOpUGen* unit, int inNumSamples);
400 void ring2_1(BinaryOpUGen* unit, int inNumSamples);
401 void ring2_aa(BinaryOpUGen* unit, int inNumSamples);
402 void ring2_ak(BinaryOpUGen* unit, int inNumSamples);
403 void ring2_ka(BinaryOpUGen* unit, int inNumSamples);
404 void ring2_ai(BinaryOpUGen* unit, int inNumSamples);
405 void ring2_ia(BinaryOpUGen* unit, int inNumSamples);
406 void ring3_d(BinaryOpUGen* unit, int inNumSamples);
407 void ring3_1(BinaryOpUGen* unit, int inNumSamples);
408 void ring3_aa(BinaryOpUGen* unit, int inNumSamples);
409 void ring3_ak(BinaryOpUGen* unit, int inNumSamples);
410 void ring3_ka(BinaryOpUGen* unit, int inNumSamples);
411 void ring3_ai(BinaryOpUGen* unit, int inNumSamples);
412 void ring3_ia(BinaryOpUGen* unit, int inNumSamples);
413 void ring4_d(BinaryOpUGen* unit, int inNumSamples);
414 void ring4_1(BinaryOpUGen* unit, int inNumSamples);
415 void ring4_aa(BinaryOpUGen* unit, int inNumSamples);
416 void ring4_ak(BinaryOpUGen* unit, int inNumSamples);
417 void ring4_ka(BinaryOpUGen* unit, int inNumSamples);
418 void ring4_ai(BinaryOpUGen* unit, int inNumSamples);
419 void ring4_ia(BinaryOpUGen* unit, int inNumSamples);
420 void thresh_d(BinaryOpUGen* unit, int inNumSamples);
421 void thresh_1(BinaryOpUGen* unit, int inNumSamples);
422 void thresh_aa(BinaryOpUGen* unit, int inNumSamples);
423 void thresh_ak(BinaryOpUGen* unit, int inNumSamples);
424 void thresh_ka(BinaryOpUGen* unit, int inNumSamples);
425 void thresh_ai(BinaryOpUGen* unit, int inNumSamples);
426 void thresh_ia(BinaryOpUGen* unit, int inNumSamples);
427 void clip2_d(BinaryOpUGen* unit, int inNumSamples);
428 void clip2_1(BinaryOpUGen* unit, int inNumSamples);
429 void clip2_aa(BinaryOpUGen* unit, int inNumSamples);
430 void clip2_ak(BinaryOpUGen* unit, int inNumSamples);
431 void clip2_ka(BinaryOpUGen* unit, int inNumSamples);
432 void clip2_ai(BinaryOpUGen* unit, int inNumSamples);
433 void clip2_ia(BinaryOpUGen* unit, int inNumSamples);
434 void fold2_d(BinaryOpUGen* unit, int inNumSamples);
435 void fold2_1(BinaryOpUGen* unit, int inNumSamples);
436 void fold2_aa(BinaryOpUGen* unit, int inNumSamples);
437 void fold2_ak(BinaryOpUGen* unit, int inNumSamples);
438 void fold2_ka(BinaryOpUGen* unit, int inNumSamples);
439 void fold2_ai(BinaryOpUGen* unit, int inNumSamples);
440 void fold2_ia(BinaryOpUGen* unit, int inNumSamples);
441 void wrap2_d(BinaryOpUGen* unit, int inNumSamples);
442 void wrap2_1(BinaryOpUGen* unit, int inNumSamples);
443 void wrap2_aa(BinaryOpUGen* unit, int inNumSamples);
444 void wrap2_ak(BinaryOpUGen* unit, int inNumSamples);
445 void wrap2_ka(BinaryOpUGen* unit, int inNumSamples);
446 void wrap2_ai(BinaryOpUGen* unit, int inNumSamples);
447 void wrap2_ia(BinaryOpUGen* unit, int inNumSamples);
448 void excess_d(BinaryOpUGen* unit, int inNumSamples);
449 void excess_1(BinaryOpUGen* unit, int inNumSamples);
450 void excess_aa(BinaryOpUGen* unit, int inNumSamples);
451 void excess_ak(BinaryOpUGen* unit, int inNumSamples);
452 void excess_ka(BinaryOpUGen* unit, int inNumSamples);
453 void excess_ai(BinaryOpUGen* unit, int inNumSamples);
454 void excess_ia(BinaryOpUGen* unit, int inNumSamples);
455 void rrand_d(BinaryOpUGen* unit, int inNumSamples);
456 void rrand_1(BinaryOpUGen* unit, int inNumSamples);
457 void rrand_aa(BinaryOpUGen* unit, int inNumSamples);
458 void rrand_ak(BinaryOpUGen* unit, int inNumSamples);
459 void rrand_ka(BinaryOpUGen* unit, int inNumSamples);
460 void rrand_ai(BinaryOpUGen* unit, int inNumSamples);
461 void rrand_ia(BinaryOpUGen* unit, int inNumSamples);
462 void exprand_d(BinaryOpUGen* unit, int inNumSamples);
463 void exprand_1(BinaryOpUGen* unit, int inNumSamples);
464 void exprand_aa(BinaryOpUGen* unit, int inNumSamples);
465 void exprand_ak(BinaryOpUGen* unit, int inNumSamples);
466 void exprand_ka(BinaryOpUGen* unit, int inNumSamples);
467 void exprand_ai(BinaryOpUGen* unit, int inNumSamples);
468 void exprand_ia(BinaryOpUGen* unit, int inNumSamples);
469 void lt_d(BinaryOpUGen* unit, int inNumSamples);
470 void lt_1(BinaryOpUGen* unit, int inNumSamples);
471 void lt_aa(BinaryOpUGen* unit, int inNumSamples);
472 void lt_ak(BinaryOpUGen* unit, int inNumSamples);
473 void lt_ka(BinaryOpUGen* unit, int inNumSamples);
474 void lt_ai(BinaryOpUGen* unit, int inNumSamples);
475 void lt_ia(BinaryOpUGen* unit, int inNumSamples);
476 void le_d(BinaryOpUGen* unit, int inNumSamples);
477 void le_1(BinaryOpUGen* unit, int inNumSamples);
478 void le_aa(BinaryOpUGen* unit, int inNumSamples);
479 void le_ak(BinaryOpUGen* unit, int inNumSamples);
480 void le_ka(BinaryOpUGen* unit, int inNumSamples);
481 void le_ai(BinaryOpUGen* unit, int inNumSamples);
482 void le_ia(BinaryOpUGen* unit, int inNumSamples);
483 void lcm_d(BinaryOpUGen* unit, int inNumSamples);
484 void lcm_1(BinaryOpUGen* unit, int inNumSamples);
485 void lcm_aa(BinaryOpUGen* unit, int inNumSamples);
486 void lcm_ak(BinaryOpUGen* unit, int inNumSamples);
487 void lcm_ka(BinaryOpUGen* unit, int inNumSamples);
488 void lcm_ai(BinaryOpUGen* unit, int inNumSamples);
489 void lcm_ia(BinaryOpUGen* unit, int inNumSamples);
490 void gcd_d(BinaryOpUGen* unit, int inNumSamples);
491 void gcd_1(BinaryOpUGen* unit, int inNumSamples);
492 void gcd_aa(BinaryOpUGen* unit, int inNumSamples);
493 void gcd_ak(BinaryOpUGen* unit, int inNumSamples);
494 void gcd_ka(BinaryOpUGen* unit, int inNumSamples);
495 void gcd_ai(BinaryOpUGen* unit, int inNumSamples);
496 void gcd_ia(BinaryOpUGen* unit, int inNumSamples);
497 void gt_d(BinaryOpUGen* unit, int inNumSamples);
498 void gt_1(BinaryOpUGen* unit, int inNumSamples);
499 void gt_aa(BinaryOpUGen* unit, int inNumSamples);
500 void gt_ak(BinaryOpUGen* unit, int inNumSamples);
501 void gt_ka(BinaryOpUGen* unit, int inNumSamples);
502 void gt_ai(BinaryOpUGen* unit, int inNumSamples);
503 void gt_ia(BinaryOpUGen* unit, int inNumSamples);
504 void ge_d(BinaryOpUGen* unit, int inNumSamples);
505 void ge_1(BinaryOpUGen* unit, int inNumSamples);
506 void ge_aa(BinaryOpUGen* unit, int inNumSamples);
507 void ge_ak(BinaryOpUGen* unit, int inNumSamples);
508 void ge_ka(BinaryOpUGen* unit, int inNumSamples);
509 void ge_ai(BinaryOpUGen* unit, int inNumSamples);
510 void ge_ia(BinaryOpUGen* unit, int inNumSamples);
511 void eq_d(BinaryOpUGen* unit, int inNumSamples);
512 void eq_1(BinaryOpUGen* unit, int inNumSamples);
513 void eq_aa(BinaryOpUGen* unit, int inNumSamples);
514 void eq_ak(BinaryOpUGen* unit, int inNumSamples);
515 void eq_ka(BinaryOpUGen* unit, int inNumSamples);
516 void eq_ai(BinaryOpUGen* unit, int inNumSamples);
517 void eq_ia(BinaryOpUGen* unit, int inNumSamples);
518 void neq_d(BinaryOpUGen* unit, int inNumSamples);
519 void neq_1(BinaryOpUGen* unit, int inNumSamples);
520 void neq_aa(BinaryOpUGen* unit, int inNumSamples);
521 void neq_ak(BinaryOpUGen* unit, int inNumSamples);
522 void neq_ka(BinaryOpUGen* unit, int inNumSamples);
523 void neq_ai(BinaryOpUGen* unit, int inNumSamples);
524 void neq_ia(BinaryOpUGen* unit, int inNumSamples);
525 void sumsqr_d(BinaryOpUGen* unit, int inNumSamples);
526 void sumsqr_1(BinaryOpUGen* unit, int inNumSamples);
527 void sumsqr_aa(BinaryOpUGen* unit, int inNumSamples);
528 void sumsqr_ak(BinaryOpUGen* unit, int inNumSamples);
529 void sumsqr_ka(BinaryOpUGen* unit, int inNumSamples);
530 void sumsqr_ai(BinaryOpUGen* unit, int inNumSamples);
531 void sumsqr_ia(BinaryOpUGen* unit, int inNumSamples);
532 void difsqr_d(BinaryOpUGen* unit, int inNumSamples);
533 void difsqr_1(BinaryOpUGen* unit, int inNumSamples);
534 void difsqr_aa(BinaryOpUGen* unit, int inNumSamples);
535 void difsqr_ak(BinaryOpUGen* unit, int inNumSamples);
536 void difsqr_ka(BinaryOpUGen* unit, int inNumSamples);
537 void difsqr_ai(BinaryOpUGen* unit, int inNumSamples);
538 void difsqr_ia(BinaryOpUGen* unit, int inNumSamples);
539 void sqrsum_d(BinaryOpUGen* unit, int inNumSamples);
540 void sqrsum_1(BinaryOpUGen* unit, int inNumSamples);
541 void sqrsum_aa(BinaryOpUGen* unit, int inNumSamples);
542 void sqrsum_ak(BinaryOpUGen* unit, int inNumSamples);
543 void sqrsum_ka(BinaryOpUGen* unit, int inNumSamples);
544 void sqrsum_ai(BinaryOpUGen* unit, int inNumSamples);
545 void sqrsum_ia(BinaryOpUGen* unit, int inNumSamples);
546 void sqrdif_d(BinaryOpUGen* unit, int inNumSamples);
547 void sqrdif_1(BinaryOpUGen* unit, int inNumSamples);
548 void sqrdif_aa(BinaryOpUGen* unit, int inNumSamples);
549 void sqrdif_ak(BinaryOpUGen* unit, int inNumSamples);
550 void sqrdif_ka(BinaryOpUGen* unit, int inNumSamples);
551 void sqrdif_ai(BinaryOpUGen* unit, int inNumSamples);
552 void sqrdif_ia(BinaryOpUGen* unit, int inNumSamples);
553 void absdif_d(BinaryOpUGen* unit, int inNumSamples);
554 void absdif_1(BinaryOpUGen* unit, int inNumSamples);
555 void absdif_aa(BinaryOpUGen* unit, int inNumSamples);
556 void absdif_ak(BinaryOpUGen* unit, int inNumSamples);
557 void absdif_ka(BinaryOpUGen* unit, int inNumSamples);
558 void absdif_ai(BinaryOpUGen* unit, int inNumSamples);
559 void absdif_ia(BinaryOpUGen* unit, int inNumSamples);
560 void round_d(BinaryOpUGen* unit, int inNumSamples);
561 void round_1(BinaryOpUGen* unit, int inNumSamples);
562 void round_aa(BinaryOpUGen* unit, int inNumSamples);
563 void round_ak(BinaryOpUGen* unit, int inNumSamples);
564 void round_ka(BinaryOpUGen* unit, int inNumSamples);
565 void round_ai(BinaryOpUGen* unit, int inNumSamples);
566 void round_ia(BinaryOpUGen* unit, int inNumSamples);
567 void roundUp_d(BinaryOpUGen* unit, int inNumSamples);
568 void roundUp_1(BinaryOpUGen* unit, int inNumSamples);
569 void roundUp_aa(BinaryOpUGen* unit, int inNumSamples);
570 void roundUp_ak(BinaryOpUGen* unit, int inNumSamples);
571 void roundUp_ka(BinaryOpUGen* unit, int inNumSamples);
572 void roundUp_ai(BinaryOpUGen* unit, int inNumSamples);
573 void roundUp_ia(BinaryOpUGen* unit, int inNumSamples);
574 void trunc_d(BinaryOpUGen* unit, int inNumSamples);
575 void trunc_1(BinaryOpUGen* unit, int inNumSamples);
576 void trunc_aa(BinaryOpUGen* unit, int inNumSamples);
577 void trunc_ak(BinaryOpUGen* unit, int inNumSamples);
578 void trunc_ka(BinaryOpUGen* unit, int inNumSamples);
579 void trunc_ai(BinaryOpUGen* unit, int inNumSamples);
580 void trunc_ia(BinaryOpUGen* unit, int inNumSamples);
581 void atan2_d(BinaryOpUGen* unit, int inNumSamples);
582 void atan2_1(BinaryOpUGen* unit, int inNumSamples);
583 void atan2_aa(BinaryOpUGen* unit, int inNumSamples);
584 void atan2_ak(BinaryOpUGen* unit, int inNumSamples);
585 void atan2_ka(BinaryOpUGen* unit, int inNumSamples);
586 void atan2_ai(BinaryOpUGen* unit, int inNumSamples);
587 void atan2_ia(BinaryOpUGen* unit, int inNumSamples);
588 void hypot_d(BinaryOpUGen* unit, int inNumSamples);
589 void hypot_1(BinaryOpUGen* unit, int inNumSamples);
590 void hypot_aa(BinaryOpUGen* unit, int inNumSamples);
591 void hypot_ak(BinaryOpUGen* unit, int inNumSamples);
592 void hypot_ka(BinaryOpUGen* unit, int inNumSamples);
593 void hypot_ai(BinaryOpUGen* unit, int inNumSamples);
594 void hypot_ia(BinaryOpUGen* unit, int inNumSamples);
595 void hypotx_d(BinaryOpUGen* unit, int inNumSamples);
596 void hypotx_1(BinaryOpUGen* unit, int inNumSamples);
597 void hypotx_aa(BinaryOpUGen* unit, int inNumSamples);
598 void hypotx_ak(BinaryOpUGen* unit, int inNumSamples);
599 void hypotx_ka(BinaryOpUGen* unit, int inNumSamples);
600 void hypotx_ai(BinaryOpUGen* unit, int inNumSamples);
601 void hypotx_ia(BinaryOpUGen* unit, int inNumSamples);
602 }
603
604 ////////////////////////////////////////////////////////////////////////////////////////////////////////
605
606 static bool ChooseOperatorFunc(BinaryOpUGen* unit);
607
BinaryOpUGen_Ctor(BinaryOpUGen * unit)608 void BinaryOpUGen_Ctor(BinaryOpUGen* unit) {
609 unit->mPrevA = ZIN0(0);
610 unit->mPrevB = ZIN0(1);
611 bool initialized = ChooseOperatorFunc(unit);
612 if (unit->mCalcRate == calc_DemandRate) {
613 OUT0(0) = 0.f;
614 } else {
615 if (!initialized)
616 (unit->mCalcFunc)(unit, 1);
617 }
618 }
619
620 /*
621 void zero_d(BinaryOpUGen *unit, int inNumSamples)
622 {
623 if (inNumSamples) {
624 float a = DEMANDINPUT_A(0, inNumSamples);
625 float b = DEMANDINPUT_A(1, inNumSamples);
626 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : 0.f;
627 } else {
628 RESETINPUT(0);
629 RESETINPUT(1);
630 }
631 }
632 */
633
firstarg_d(BinaryOpUGen * unit,int inNumSamples)634 void firstarg_d(BinaryOpUGen* unit, int inNumSamples) {
635 if (inNumSamples) {
636 float a = DEMANDINPUT_A(0, inNumSamples);
637 float b = DEMANDINPUT_A(1, inNumSamples);
638 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a;
639 } else {
640 RESETINPUT(0);
641 RESETINPUT(1);
642 }
643 }
644
secondarg_d(BinaryOpUGen * unit,int inNumSamples)645 void secondarg_d(BinaryOpUGen* unit, int inNumSamples) {
646 if (inNumSamples) {
647 float a = DEMANDINPUT_A(0, inNumSamples);
648 float b = DEMANDINPUT_A(1, inNumSamples);
649 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : b;
650 } else {
651 RESETINPUT(0);
652 RESETINPUT(1);
653 }
654 }
655
add_d(BinaryOpUGen * unit,int inNumSamples)656 void add_d(BinaryOpUGen* unit, int inNumSamples) {
657 if (inNumSamples) {
658 float a = DEMANDINPUT_A(0, inNumSamples);
659 float b = DEMANDINPUT_A(1, inNumSamples);
660 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a + b;
661 } else {
662 RESETINPUT(0);
663 RESETINPUT(1);
664 }
665 }
666
sub_d(BinaryOpUGen * unit,int inNumSamples)667 void sub_d(BinaryOpUGen* unit, int inNumSamples) {
668 if (inNumSamples) {
669 float a = DEMANDINPUT_A(0, inNumSamples);
670 float b = DEMANDINPUT_A(1, inNumSamples);
671 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a - b;
672 } else {
673 RESETINPUT(0);
674 RESETINPUT(1);
675 }
676 }
677
mul_d(BinaryOpUGen * unit,int inNumSamples)678 void mul_d(BinaryOpUGen* unit, int inNumSamples) {
679 if (inNumSamples) {
680 float a = DEMANDINPUT_A(0, inNumSamples);
681 float b = DEMANDINPUT_A(1, inNumSamples);
682 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a * b;
683 } else {
684 RESETINPUT(0);
685 RESETINPUT(1);
686 }
687 }
688
div_d(BinaryOpUGen * unit,int inNumSamples)689 void div_d(BinaryOpUGen* unit, int inNumSamples) {
690 if (inNumSamples) {
691 float a = DEMANDINPUT_A(0, inNumSamples);
692 float b = DEMANDINPUT_A(1, inNumSamples);
693 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a / b;
694 } else {
695 RESETINPUT(0);
696 RESETINPUT(1);
697 }
698 }
699
idiv_d(BinaryOpUGen * unit,int inNumSamples)700 void idiv_d(BinaryOpUGen* unit, int inNumSamples) {
701 if (inNumSamples) {
702 float a = DEMANDINPUT_A(0, inNumSamples);
703 float b = DEMANDINPUT_A(1, inNumSamples);
704 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : floor(a / b);
705 } else {
706 RESETINPUT(0);
707 RESETINPUT(1);
708 }
709 }
710
mod_d(BinaryOpUGen * unit,int inNumSamples)711 void mod_d(BinaryOpUGen* unit, int inNumSamples) {
712 if (inNumSamples) {
713 float a = DEMANDINPUT_A(0, inNumSamples);
714 float b = DEMANDINPUT_A(1, inNumSamples);
715 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_mod(a, b);
716 } else {
717 RESETINPUT(0);
718 RESETINPUT(1);
719 }
720 }
721
max_d(BinaryOpUGen * unit,int inNumSamples)722 void max_d(BinaryOpUGen* unit, int inNumSamples) {
723 if (inNumSamples) {
724 float a = DEMANDINPUT_A(0, inNumSamples);
725 float b = DEMANDINPUT_A(1, inNumSamples);
726 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_max(a, b);
727 } else {
728 RESETINPUT(0);
729 RESETINPUT(1);
730 }
731 }
732
min_d(BinaryOpUGen * unit,int inNumSamples)733 void min_d(BinaryOpUGen* unit, int inNumSamples) {
734 if (inNumSamples) {
735 float a = DEMANDINPUT_A(0, inNumSamples);
736 float b = DEMANDINPUT_A(1, inNumSamples);
737 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_min(a, b);
738 } else {
739 RESETINPUT(0);
740 RESETINPUT(1);
741 }
742 }
743
and_d(BinaryOpUGen * unit,int inNumSamples)744 void and_d(BinaryOpUGen* unit, int inNumSamples) {
745 if (inNumSamples) {
746 float a = DEMANDINPUT_A(0, inNumSamples);
747 float b = DEMANDINPUT_A(1, inNumSamples);
748 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_andt(a, b);
749 } else {
750 RESETINPUT(0);
751 RESETINPUT(1);
752 }
753 }
754
or_d(BinaryOpUGen * unit,int inNumSamples)755 void or_d(BinaryOpUGen* unit, int inNumSamples) {
756 if (inNumSamples) {
757 float a = DEMANDINPUT_A(0, inNumSamples);
758 float b = DEMANDINPUT_A(1, inNumSamples);
759 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_ort(a, b);
760 } else {
761 RESETINPUT(0);
762 RESETINPUT(1);
763 }
764 }
765
xor_d(BinaryOpUGen * unit,int inNumSamples)766 void xor_d(BinaryOpUGen* unit, int inNumSamples) {
767 if (inNumSamples) {
768 float a = DEMANDINPUT_A(0, inNumSamples);
769 float b = DEMANDINPUT_A(1, inNumSamples);
770 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_xort(a, b);
771 } else {
772 RESETINPUT(0);
773 RESETINPUT(1);
774 }
775 }
776
rightShift_d(BinaryOpUGen * unit,int inNumSamples)777 void rightShift_d(BinaryOpUGen* unit, int inNumSamples) {
778 if (inNumSamples) {
779 float a = DEMANDINPUT_A(0, inNumSamples);
780 float b = DEMANDINPUT_A(1, inNumSamples);
781 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_rst(a, b);
782 } else {
783 RESETINPUT(0);
784 RESETINPUT(1);
785 }
786 }
787
leftShift_d(BinaryOpUGen * unit,int inNumSamples)788 void leftShift_d(BinaryOpUGen* unit, int inNumSamples) {
789 if (inNumSamples) {
790 float a = DEMANDINPUT_A(0, inNumSamples);
791 float b = DEMANDINPUT_A(1, inNumSamples);
792 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_lst(a, b);
793 } else {
794 RESETINPUT(0);
795 RESETINPUT(1);
796 }
797 }
798
lcm_d(BinaryOpUGen * unit,int inNumSamples)799 void lcm_d(BinaryOpUGen* unit, int inNumSamples) {
800 if (inNumSamples) {
801 float a = DEMANDINPUT_A(0, inNumSamples);
802 float b = DEMANDINPUT_A(1, inNumSamples);
803 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_lcm(a, b);
804 } else {
805 RESETINPUT(0);
806 RESETINPUT(1);
807 }
808 }
809
gcd_d(BinaryOpUGen * unit,int inNumSamples)810 void gcd_d(BinaryOpUGen* unit, int inNumSamples) {
811 if (inNumSamples) {
812 float a = DEMANDINPUT_A(0, inNumSamples);
813 float b = DEMANDINPUT_A(1, inNumSamples);
814 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_gcd(a, b);
815 } else {
816 RESETINPUT(0);
817 RESETINPUT(1);
818 }
819 }
820
amclip_d(BinaryOpUGen * unit,int inNumSamples)821 void amclip_d(BinaryOpUGen* unit, int inNumSamples) {
822 if (inNumSamples) {
823 float a = DEMANDINPUT_A(0, inNumSamples);
824 float b = DEMANDINPUT_A(1, inNumSamples);
825 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_amclip(a, b);
826 } else {
827 RESETINPUT(0);
828 RESETINPUT(1);
829 }
830 }
831
scaleneg_d(BinaryOpUGen * unit,int inNumSamples)832 void scaleneg_d(BinaryOpUGen* unit, int inNumSamples) {
833 if (inNumSamples) {
834 float a = DEMANDINPUT_A(0, inNumSamples);
835 float b = DEMANDINPUT_A(1, inNumSamples);
836 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_scaleneg(a, b);
837 } else {
838 RESETINPUT(0);
839 RESETINPUT(1);
840 }
841 }
842
pow_d(BinaryOpUGen * unit,int inNumSamples)843 void pow_d(BinaryOpUGen* unit, int inNumSamples) {
844 if (inNumSamples) {
845 float a = DEMANDINPUT_A(0, inNumSamples);
846 float b = DEMANDINPUT_A(1, inNumSamples);
847 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : (a < 0.f ? -pow(-a, b) : pow(a, b));
848 } else {
849 RESETINPUT(0);
850 RESETINPUT(1);
851 }
852 }
853
ring1_d(BinaryOpUGen * unit,int inNumSamples)854 void ring1_d(BinaryOpUGen* unit, int inNumSamples) {
855 if (inNumSamples) {
856 float a = DEMANDINPUT_A(0, inNumSamples);
857 float b = DEMANDINPUT_A(1, inNumSamples);
858 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a * b + a;
859 } else {
860 RESETINPUT(0);
861 RESETINPUT(1);
862 }
863 }
864
ring2_d(BinaryOpUGen * unit,int inNumSamples)865 void ring2_d(BinaryOpUGen* unit, int inNumSamples) {
866 if (inNumSamples) {
867 float a = DEMANDINPUT_A(0, inNumSamples);
868 float b = DEMANDINPUT_A(1, inNumSamples);
869 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a * b + a + b;
870 } else {
871 RESETINPUT(0);
872 RESETINPUT(1);
873 }
874 }
875
ring3_d(BinaryOpUGen * unit,int inNumSamples)876 void ring3_d(BinaryOpUGen* unit, int inNumSamples) {
877 if (inNumSamples) {
878 float a = DEMANDINPUT_A(0, inNumSamples);
879 float b = DEMANDINPUT_A(1, inNumSamples);
880 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a * a * b;
881 } else {
882 RESETINPUT(0);
883 RESETINPUT(1);
884 }
885 }
886
ring4_d(BinaryOpUGen * unit,int inNumSamples)887 void ring4_d(BinaryOpUGen* unit, int inNumSamples) {
888 if (inNumSamples) {
889 float a = DEMANDINPUT_A(0, inNumSamples);
890 float b = DEMANDINPUT_A(1, inNumSamples);
891 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a * a * b - a * b * b;
892 } else {
893 RESETINPUT(0);
894 RESETINPUT(1);
895 }
896 }
897
thresh_d(BinaryOpUGen * unit,int inNumSamples)898 void thresh_d(BinaryOpUGen* unit, int inNumSamples) {
899 if (inNumSamples) {
900 float a = DEMANDINPUT_A(0, inNumSamples);
901 float b = DEMANDINPUT_A(1, inNumSamples);
902 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_thresh(a, b);
903 } else {
904 RESETINPUT(0);
905 RESETINPUT(1);
906 }
907 }
908
clip2_d(BinaryOpUGen * unit,int inNumSamples)909 void clip2_d(BinaryOpUGen* unit, int inNumSamples) {
910 if (inNumSamples) {
911 float a = DEMANDINPUT_A(0, inNumSamples);
912 float b = DEMANDINPUT_A(1, inNumSamples);
913 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_clip2(a, b);
914 } else {
915 RESETINPUT(0);
916 RESETINPUT(1);
917 }
918 }
919
excess_d(BinaryOpUGen * unit,int inNumSamples)920 void excess_d(BinaryOpUGen* unit, int inNumSamples) {
921 if (inNumSamples) {
922 float a = DEMANDINPUT_A(0, inNumSamples);
923 float b = DEMANDINPUT_A(1, inNumSamples);
924 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_excess(a, b);
925 } else {
926 RESETINPUT(0);
927 RESETINPUT(1);
928 }
929 }
930
lt_d(BinaryOpUGen * unit,int inNumSamples)931 void lt_d(BinaryOpUGen* unit, int inNumSamples) {
932 if (inNumSamples) {
933 float a = DEMANDINPUT_A(0, inNumSamples);
934 float b = DEMANDINPUT_A(1, inNumSamples);
935 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : (a < b ? 1.f : 0.f);
936 } else {
937 RESETINPUT(0);
938 RESETINPUT(1);
939 }
940 }
941
gt_d(BinaryOpUGen * unit,int inNumSamples)942 void gt_d(BinaryOpUGen* unit, int inNumSamples) {
943 if (inNumSamples) {
944 float a = DEMANDINPUT_A(0, inNumSamples);
945 float b = DEMANDINPUT_A(1, inNumSamples);
946 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : (a > b ? 1.f : 0.f);
947 } else {
948 RESETINPUT(0);
949 RESETINPUT(1);
950 }
951 }
952
le_d(BinaryOpUGen * unit,int inNumSamples)953 void le_d(BinaryOpUGen* unit, int inNumSamples) {
954 if (inNumSamples) {
955 float a = DEMANDINPUT_A(0, inNumSamples);
956 float b = DEMANDINPUT_A(1, inNumSamples);
957 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : (a <= b ? 1.f : 0.f);
958 } else {
959 RESETINPUT(0);
960 RESETINPUT(1);
961 }
962 }
963
ge_d(BinaryOpUGen * unit,int inNumSamples)964 void ge_d(BinaryOpUGen* unit, int inNumSamples) {
965 if (inNumSamples) {
966 float a = DEMANDINPUT_A(0, inNumSamples);
967 float b = DEMANDINPUT_A(1, inNumSamples);
968 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : (a >= b ? 1.f : 0.f);
969 } else {
970 RESETINPUT(0);
971 RESETINPUT(1);
972 }
973 }
974
eq_d(BinaryOpUGen * unit,int inNumSamples)975 void eq_d(BinaryOpUGen* unit, int inNumSamples) {
976 if (inNumSamples) {
977 float a = DEMANDINPUT_A(0, inNumSamples);
978 float b = DEMANDINPUT_A(1, inNumSamples);
979 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : (a == b ? 1.f : 0.f);
980 } else {
981 RESETINPUT(0);
982 RESETINPUT(1);
983 }
984 }
985
neq_d(BinaryOpUGen * unit,int inNumSamples)986 void neq_d(BinaryOpUGen* unit, int inNumSamples) {
987 if (inNumSamples) {
988 float a = DEMANDINPUT_A(0, inNumSamples);
989 float b = DEMANDINPUT_A(1, inNumSamples);
990 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : (a != b ? 1.f : 0.f);
991 } else {
992 RESETINPUT(0);
993 RESETINPUT(1);
994 }
995 }
996
997
sumsqr_d(BinaryOpUGen * unit,int inNumSamples)998 void sumsqr_d(BinaryOpUGen* unit, int inNumSamples) {
999 if (inNumSamples) {
1000 float a = DEMANDINPUT_A(0, inNumSamples);
1001 float b = DEMANDINPUT_A(1, inNumSamples);
1002 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a * a + b * b;
1003 } else {
1004 RESETINPUT(0);
1005 RESETINPUT(1);
1006 }
1007 }
1008
difsqr_d(BinaryOpUGen * unit,int inNumSamples)1009 void difsqr_d(BinaryOpUGen* unit, int inNumSamples) {
1010 if (inNumSamples) {
1011 float a = DEMANDINPUT_A(0, inNumSamples);
1012 float b = DEMANDINPUT_A(1, inNumSamples);
1013 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : a * a - b * b;
1014 } else {
1015 RESETINPUT(0);
1016 RESETINPUT(1);
1017 }
1018 }
1019
sqrsum_d(BinaryOpUGen * unit,int inNumSamples)1020 void sqrsum_d(BinaryOpUGen* unit, int inNumSamples) {
1021 if (inNumSamples) {
1022 float a = DEMANDINPUT_A(0, inNumSamples);
1023 float b = DEMANDINPUT_A(1, inNumSamples);
1024 float z;
1025 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : (z = a + b, z * z);
1026 } else {
1027 RESETINPUT(0);
1028 RESETINPUT(1);
1029 }
1030 }
1031
sqrdif_d(BinaryOpUGen * unit,int inNumSamples)1032 void sqrdif_d(BinaryOpUGen* unit, int inNumSamples) {
1033 if (inNumSamples) {
1034 float a = DEMANDINPUT_A(0, inNumSamples);
1035 float b = DEMANDINPUT_A(1, inNumSamples);
1036 float z;
1037 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : (z = a - b, z * z);
1038 } else {
1039 RESETINPUT(0);
1040 RESETINPUT(1);
1041 }
1042 }
1043
absdif_d(BinaryOpUGen * unit,int inNumSamples)1044 void absdif_d(BinaryOpUGen* unit, int inNumSamples) {
1045 if (inNumSamples) {
1046 float a = DEMANDINPUT_A(0, inNumSamples);
1047 float b = DEMANDINPUT_A(1, inNumSamples);
1048 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : fabs(a - b);
1049 } else {
1050 RESETINPUT(0);
1051 RESETINPUT(1);
1052 }
1053 }
1054
round_d(BinaryOpUGen * unit,int inNumSamples)1055 void round_d(BinaryOpUGen* unit, int inNumSamples) {
1056 if (inNumSamples) {
1057 float a = DEMANDINPUT_A(0, inNumSamples);
1058 float b = DEMANDINPUT_A(1, inNumSamples);
1059 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_round(a, b);
1060 } else {
1061 RESETINPUT(0);
1062 RESETINPUT(1);
1063 }
1064 }
1065
roundUp_d(BinaryOpUGen * unit,int inNumSamples)1066 void roundUp_d(BinaryOpUGen* unit, int inNumSamples) {
1067 if (inNumSamples) {
1068 float a = DEMANDINPUT_A(0, inNumSamples);
1069 float b = DEMANDINPUT_A(1, inNumSamples);
1070 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_roundUp(a, b);
1071 } else {
1072 RESETINPUT(0);
1073 RESETINPUT(1);
1074 }
1075 }
1076
trunc_d(BinaryOpUGen * unit,int inNumSamples)1077 void trunc_d(BinaryOpUGen* unit, int inNumSamples) {
1078 if (inNumSamples) {
1079 float a = DEMANDINPUT_A(0, inNumSamples);
1080 float b = DEMANDINPUT_A(1, inNumSamples);
1081 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_trunc(a, b);
1082 } else {
1083 RESETINPUT(0);
1084 RESETINPUT(1);
1085 }
1086 }
1087
fold2_d(BinaryOpUGen * unit,int inNumSamples)1088 void fold2_d(BinaryOpUGen* unit, int inNumSamples) {
1089 if (inNumSamples) {
1090 float a = DEMANDINPUT_A(0, inNumSamples);
1091 float b = DEMANDINPUT_A(1, inNumSamples);
1092 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_fold2(a, b);
1093 } else {
1094 RESETINPUT(0);
1095 RESETINPUT(1);
1096 }
1097 }
1098
wrap2_d(BinaryOpUGen * unit,int inNumSamples)1099 void wrap2_d(BinaryOpUGen* unit, int inNumSamples) {
1100 if (inNumSamples) {
1101 float a = DEMANDINPUT_A(0, inNumSamples);
1102 float b = DEMANDINPUT_A(1, inNumSamples);
1103 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_wrap2(a, b);
1104 } else {
1105 RESETINPUT(0);
1106 RESETINPUT(1);
1107 }
1108 }
1109
atan2_d(BinaryOpUGen * unit,int inNumSamples)1110 void atan2_d(BinaryOpUGen* unit, int inNumSamples) {
1111 if (inNumSamples) {
1112 float a = DEMANDINPUT_A(0, inNumSamples);
1113 float b = DEMANDINPUT_A(1, inNumSamples);
1114 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : atan2(a, b);
1115 } else {
1116 RESETINPUT(0);
1117 RESETINPUT(1);
1118 }
1119 }
1120
hypot_d(BinaryOpUGen * unit,int inNumSamples)1121 void hypot_d(BinaryOpUGen* unit, int inNumSamples) {
1122 if (inNumSamples) {
1123 float a = DEMANDINPUT_A(0, inNumSamples);
1124 float b = DEMANDINPUT_A(1, inNumSamples);
1125 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : hypot(a, b);
1126 } else {
1127 RESETINPUT(0);
1128 RESETINPUT(1);
1129 }
1130 }
1131
hypotx_d(BinaryOpUGen * unit,int inNumSamples)1132 void hypotx_d(BinaryOpUGen* unit, int inNumSamples) {
1133 if (inNumSamples) {
1134 float a = DEMANDINPUT_A(0, inNumSamples);
1135 float b = DEMANDINPUT_A(1, inNumSamples);
1136 OUT0(0) = sc_isnan(a) || sc_isnan(b) ? NAN : sc_hypotx(a, b);
1137 } else {
1138 RESETINPUT(0);
1139 RESETINPUT(1);
1140 }
1141 }
1142
rrand_d(BinaryOpUGen * unit,int inNumSamples)1143 void rrand_d(BinaryOpUGen* unit, int inNumSamples) {
1144 if (inNumSamples) {
1145 float xa = DEMANDINPUT_A(0, inNumSamples);
1146 float xb = DEMANDINPUT_A(1, inNumSamples);
1147 RGen& rgen = *unit->mParent->mRGen;
1148 OUT0(0) = sc_isnan(xa) || sc_isnan(xb)
1149 ? NAN
1150 : xb > xa ? xa + rgen.frand() * (xb - xa) : (xb + rgen.frand() * (xa - xb));
1151 } else {
1152 RESETINPUT(0);
1153 RESETINPUT(1);
1154 }
1155 }
1156
exprand_d(BinaryOpUGen * unit,int inNumSamples)1157 void exprand_d(BinaryOpUGen* unit, int inNumSamples) {
1158 if (inNumSamples) {
1159 float xa = DEMANDINPUT_A(0, inNumSamples);
1160 float xb = DEMANDINPUT_A(1, inNumSamples);
1161 RGen& rgen = *unit->mParent->mRGen;
1162 OUT0(0) = sc_isnan(xa) || sc_isnan(xb) ? NAN : xb > xa ? rgen.exprandrng(xa, xb) : rgen.exprandrng(xb, xa);
1163 } else {
1164 RESETINPUT(0);
1165 RESETINPUT(1);
1166 }
1167 }
1168
1169
zero_1(BinaryOpUGen * unit,int inNumSamples)1170 void zero_1(BinaryOpUGen* unit, int inNumSamples) { ZOUT0(0) = 0.f; }
1171
firstarg_1(BinaryOpUGen * unit,int inNumSamples)1172 void firstarg_1(BinaryOpUGen* unit, int inNumSamples) { ZOUT0(0) = ZIN0(0); }
1173
secondarg_1(BinaryOpUGen * unit,int inNumSamples)1174 void secondarg_1(BinaryOpUGen* unit, int inNumSamples) { ZOUT0(0) = ZIN0(1); }
1175
add_1(BinaryOpUGen * unit,int inNumSamples)1176 void add_1(BinaryOpUGen* unit, int inNumSamples) { ZOUT0(0) = ZIN0(0) + ZIN0(1); }
1177
sub_1(BinaryOpUGen * unit,int inNumSamples)1178 void sub_1(BinaryOpUGen* unit, int inNumSamples) { ZOUT0(0) = ZIN0(0) - ZIN0(1); }
1179
mul_1(BinaryOpUGen * unit,int inNumSamples)1180 void mul_1(BinaryOpUGen* unit, int inNumSamples) { ZOUT0(0) = ZIN0(0) * ZIN0(1); }
1181
div_1(BinaryOpUGen * unit,int inNumSamples)1182 void div_1(BinaryOpUGen* unit, int inNumSamples) { ZOUT0(0) = ZIN0(0) / ZIN0(1); }
1183
idiv_1(BinaryOpUGen * unit,int inNumSamples)1184 void idiv_1(BinaryOpUGen* unit, int inNumSamples) { ZOUT0(0) = floor(ZIN0(0) / ZIN0(1)); }
1185
mod_1(BinaryOpUGen * unit,int inNumSamples)1186 void mod_1(BinaryOpUGen* unit, int inNumSamples) {
1187 float xa = ZIN0(0);
1188 float xb = ZIN0(1);
1189 ZOUT0(0) = sc_mod(xa, xb);
1190 }
1191
max_1(BinaryOpUGen * unit,int inNumSamples)1192 void max_1(BinaryOpUGen* unit, int inNumSamples) {
1193 float xa = ZIN0(0);
1194 float xb = ZIN0(1);
1195 ZOUT0(0) = sc_max(xa, xb);
1196 }
1197
min_1(BinaryOpUGen * unit,int inNumSamples)1198 void min_1(BinaryOpUGen* unit, int inNumSamples) {
1199 float xa = ZIN0(0);
1200 float xb = ZIN0(1);
1201 ZOUT0(0) = sc_min(xa, xb);
1202 }
1203
and_1(BinaryOpUGen * unit,int inNumSamples)1204 void and_1(BinaryOpUGen* unit, int inNumSamples) {
1205 float xa = ZIN0(0);
1206 float xb = ZIN0(1);
1207 ZOUT0(0) = sc_andt(xa, xb);
1208 }
1209
or_1(BinaryOpUGen * unit,int inNumSamples)1210 void or_1(BinaryOpUGen* unit, int inNumSamples) {
1211 float xa = ZIN0(0);
1212 float xb = ZIN0(1);
1213 ZOUT0(0) = sc_ort(xa, xb);
1214 }
1215
xor_1(BinaryOpUGen * unit,int inNumSamples)1216 void xor_1(BinaryOpUGen* unit, int inNumSamples) {
1217 float xa = ZIN0(0);
1218 float xb = ZIN0(1);
1219 ZOUT0(0) = sc_xort(xa, xb);
1220 }
1221
rightShift_1(BinaryOpUGen * unit,int inNumSamples)1222 void rightShift_1(BinaryOpUGen* unit, int inNumSamples) {
1223 float xa = ZIN0(0);
1224 float xb = ZIN0(1);
1225 ZOUT0(0) = sc_rst(xa, xb);
1226 }
1227
leftShift_1(BinaryOpUGen * unit,int inNumSamples)1228 void leftShift_1(BinaryOpUGen* unit, int inNumSamples) {
1229 float xa = ZIN0(0);
1230 float xb = ZIN0(1);
1231 ZOUT0(0) = sc_lst(xa, xb);
1232 }
1233
lcm_1(BinaryOpUGen * unit,int inNumSamples)1234 void lcm_1(BinaryOpUGen* unit, int inNumSamples) {
1235 float xa = ZIN0(0);
1236 float xb = ZIN0(1);
1237 ZOUT0(0) = sc_lcm(xa, xb);
1238 }
1239
gcd_1(BinaryOpUGen * unit,int inNumSamples)1240 void gcd_1(BinaryOpUGen* unit, int inNumSamples) {
1241 float xa = ZIN0(0);
1242 float xb = ZIN0(1);
1243 ZOUT0(0) = sc_gcd(xa, xb);
1244 }
1245
amclip_1(BinaryOpUGen * unit,int inNumSamples)1246 void amclip_1(BinaryOpUGen* unit, int inNumSamples) {
1247 float xa = ZIN0(0);
1248 float xb = ZIN0(1);
1249 ZOUT0(0) = sc_amclip(xa, xb);
1250 }
1251
scaleneg_1(BinaryOpUGen * unit,int inNumSamples)1252 void scaleneg_1(BinaryOpUGen* unit, int inNumSamples) {
1253 float xa = ZIN0(0);
1254 float xb = ZIN0(1);
1255 ZOUT0(0) = xa >= 0.f ? xa : xa * xb;
1256 }
1257
pow_1(BinaryOpUGen * unit,int inNumSamples)1258 void pow_1(BinaryOpUGen* unit, int inNumSamples) {
1259 float xa = ZIN0(0);
1260 float xb = ZIN0(1);
1261 ZOUT0(0) = xa >= 0.f ? pow(xa, xb) : -pow(-xa, xb);
1262 }
1263
1264
ring1_1(BinaryOpUGen * unit,int inNumSamples)1265 void ring1_1(BinaryOpUGen* unit, int inNumSamples) {
1266 float xa = ZIN0(0);
1267 float xb = ZIN0(1);
1268 ZOUT0(0) = xa * xb + xa;
1269 }
1270
ring2_1(BinaryOpUGen * unit,int inNumSamples)1271 void ring2_1(BinaryOpUGen* unit, int inNumSamples) {
1272 float xa = ZIN0(0);
1273 float xb = ZIN0(1);
1274 ZOUT0(0) = xa * xb + xa + xb;
1275 }
1276
ring3_1(BinaryOpUGen * unit,int inNumSamples)1277 void ring3_1(BinaryOpUGen* unit, int inNumSamples) {
1278 float xa = ZIN0(0);
1279 float xb = ZIN0(1);
1280 ZOUT0(0) = xa * xa * xb;
1281 }
1282
ring4_1(BinaryOpUGen * unit,int inNumSamples)1283 void ring4_1(BinaryOpUGen* unit, int inNumSamples) {
1284 float xa = ZIN0(0);
1285 float xb = ZIN0(1);
1286 ZOUT0(0) = xa * xa * xb - xa * xb * xb;
1287 }
1288
thresh_1(BinaryOpUGen * unit,int inNumSamples)1289 void thresh_1(BinaryOpUGen* unit, int inNumSamples) {
1290 float xa = ZIN0(0);
1291 float xb = ZIN0(1);
1292 ZOUT0(0) = xa < xb ? 0.f : xa;
1293 }
1294
clip2_1(BinaryOpUGen * unit,int inNumSamples)1295 void clip2_1(BinaryOpUGen* unit, int inNumSamples) {
1296 float xa = ZIN0(0);
1297 float xb = ZIN0(1);
1298 ZOUT0(0) = xa > xb ? xb : (xa < -xb ? -xb : xa);
1299 }
1300
excess_1(BinaryOpUGen * unit,int inNumSamples)1301 void excess_1(BinaryOpUGen* unit, int inNumSamples) {
1302 float xa = ZIN0(0);
1303 float xb = ZIN0(1);
1304 ZOUT0(0) = xa > xb ? xa - xb : (xa < -xb ? xa + xb : 0.f);
1305 }
1306
lt_1(BinaryOpUGen * unit,int inNumSamples)1307 void lt_1(BinaryOpUGen* unit, int inNumSamples) {
1308 float xa = ZIN0(0);
1309 float xb = ZIN0(1);
1310 ZOUT0(0) = xa < xb ? 1.f : 0.f;
1311 }
1312
le_1(BinaryOpUGen * unit,int inNumSamples)1313 void le_1(BinaryOpUGen* unit, int inNumSamples) {
1314 float xa = ZIN0(0);
1315 float xb = ZIN0(1);
1316 ZOUT0(0) = xa <= xb ? 1.f : 0.f;
1317 }
1318
gt_1(BinaryOpUGen * unit,int inNumSamples)1319 void gt_1(BinaryOpUGen* unit, int inNumSamples) {
1320 float xa = ZIN0(0);
1321 float xb = ZIN0(1);
1322 ZOUT0(0) = xa > xb ? 1.f : 0.f;
1323 }
1324
ge_1(BinaryOpUGen * unit,int inNumSamples)1325 void ge_1(BinaryOpUGen* unit, int inNumSamples) {
1326 float xa = ZIN0(0);
1327 float xb = ZIN0(1);
1328 ZOUT0(0) = xa >= xb ? 1.f : 0.f;
1329 }
1330
eq_1(BinaryOpUGen * unit,int inNumSamples)1331 void eq_1(BinaryOpUGen* unit, int inNumSamples) {
1332 float xa = ZIN0(0);
1333 float xb = ZIN0(1);
1334 ZOUT0(0) = xa == xb ? 1.f : 0.f;
1335 }
1336
neq_1(BinaryOpUGen * unit,int inNumSamples)1337 void neq_1(BinaryOpUGen* unit, int inNumSamples) {
1338 float xa = ZIN0(0);
1339 float xb = ZIN0(1);
1340 ZOUT0(0) = xa != xb ? 1.f : 0.f;
1341 }
1342
1343
sumsqr_1(BinaryOpUGen * unit,int inNumSamples)1344 void sumsqr_1(BinaryOpUGen* unit, int inNumSamples) {
1345 float xa = ZIN0(0);
1346 float xb = ZIN0(1);
1347 ZOUT0(0) = xa * xa + xb * xb;
1348 }
1349
difsqr_1(BinaryOpUGen * unit,int inNumSamples)1350 void difsqr_1(BinaryOpUGen* unit, int inNumSamples) {
1351 float xa = ZIN0(0);
1352 float xb = ZIN0(1);
1353 ZOUT0(0) = xa * xa - xb * xb;
1354 }
1355
sqrsum_1(BinaryOpUGen * unit,int inNumSamples)1356 void sqrsum_1(BinaryOpUGen* unit, int inNumSamples) {
1357 float xa = ZIN0(0);
1358 float xb = ZIN0(1);
1359 float sum = xa + xb;
1360 ZOUT0(0) = sum * sum;
1361 }
1362
sqrdif_1(BinaryOpUGen * unit,int inNumSamples)1363 void sqrdif_1(BinaryOpUGen* unit, int inNumSamples) {
1364 float xa = ZIN0(0);
1365 float xb = ZIN0(1);
1366 float dif = xa - xb;
1367 ZOUT0(0) = dif * dif;
1368 }
1369
absdif_1(BinaryOpUGen * unit,int inNumSamples)1370 void absdif_1(BinaryOpUGen* unit, int inNumSamples) {
1371 float xa = ZIN0(0);
1372 float xb = ZIN0(1);
1373 ZOUT0(0) = fabs(xa - xb);
1374 }
1375
round_1(BinaryOpUGen * unit,int inNumSamples)1376 void round_1(BinaryOpUGen* unit, int inNumSamples) {
1377 float xa = ZIN0(0);
1378 float xb = ZIN0(1);
1379 ZOUT0(0) = sc_round(xa, xb);
1380 }
1381
roundUp_1(BinaryOpUGen * unit,int inNumSamples)1382 void roundUp_1(BinaryOpUGen* unit, int inNumSamples) {
1383 float xa = ZIN0(0);
1384 float xb = ZIN0(1);
1385 ZOUT0(0) = sc_roundUp(xa, xb);
1386 }
1387
trunc_1(BinaryOpUGen * unit,int inNumSamples)1388 void trunc_1(BinaryOpUGen* unit, int inNumSamples) {
1389 float xa = ZIN0(0);
1390 float xb = ZIN0(1);
1391 ZOUT0(0) = sc_trunc(xa, xb);
1392 }
1393
fold2_1(BinaryOpUGen * unit,int inNumSamples)1394 void fold2_1(BinaryOpUGen* unit, int inNumSamples) {
1395 float xa = ZIN0(0);
1396 float xb = ZIN0(1);
1397 ZOUT0(0) = sc_fold(xa, -xb, xb);
1398 }
1399
wrap2_1(BinaryOpUGen * unit,int inNumSamples)1400 void wrap2_1(BinaryOpUGen* unit, int inNumSamples) {
1401 float xa = ZIN0(0);
1402 float xb = ZIN0(1);
1403 ZOUT0(0) = sc_wrap(xa, -xb, xb);
1404 }
1405
atan2_1(BinaryOpUGen * unit,int inNumSamples)1406 void atan2_1(BinaryOpUGen* unit, int inNumSamples) {
1407 float xa = ZIN0(0);
1408 float xb = ZIN0(1);
1409 ZOUT0(0) = atan2(xa, xb);
1410 }
1411
hypot_1(BinaryOpUGen * unit,int inNumSamples)1412 void hypot_1(BinaryOpUGen* unit, int inNumSamples) {
1413 float xa = ZIN0(0);
1414 float xb = ZIN0(1);
1415 ZOUT0(0) = hypot(xa, xb);
1416 }
1417
hypotx_1(BinaryOpUGen * unit,int inNumSamples)1418 void hypotx_1(BinaryOpUGen* unit, int inNumSamples) {
1419 float xa = ZIN0(0);
1420 float xb = ZIN0(1);
1421 ZOUT0(0) = sc_hypotx(xa, xb);
1422 }
1423
rrand_1(BinaryOpUGen * unit,int inNumSamples)1424 void rrand_1(BinaryOpUGen* unit, int inNumSamples) {
1425 float xa = ZIN0(0);
1426 float xb = ZIN0(1);
1427 RGen& rgen = *unit->mParent->mRGen;
1428 ZOUT0(0) = xb > xa ? xa + rgen.frand() * (xb - xa) : (xb + rgen.frand() * (xa - xb));
1429 }
1430
exprand_1(BinaryOpUGen * unit,int inNumSamples)1431 void exprand_1(BinaryOpUGen* unit, int inNumSamples) {
1432 float xa = ZIN0(0);
1433 float xb = ZIN0(1);
1434 RGen& rgen = *unit->mParent->mRGen;
1435 ZOUT0(0) = xb > xa ? rgen.exprandrng(xa, xb) : rgen.exprandrng(xb, xa);
1436 }
1437
zero_aa(BinaryOpUGen * unit,int inNumSamples)1438 void zero_aa(BinaryOpUGen* unit, int inNumSamples) {
1439 float* out = ZOUT(0);
1440
1441 ZClear(inNumSamples, out);
1442 }
1443
firstarg_aa(BinaryOpUGen * unit,int inNumSamples)1444 void firstarg_aa(BinaryOpUGen* unit, int inNumSamples) {
1445 float* out = ZOUT(0);
1446 float* a = ZIN(0);
1447
1448 ZCopy(inNumSamples, out, a);
1449 }
1450
1451 #ifdef NOVA_SIMD
firstarg_aa_nova(BinaryOpUGen * unit,int inNumSamples)1452 FLATTEN void firstarg_aa_nova(BinaryOpUGen* unit, int inNumSamples) { nova::copyvec_simd(OUT(0), IN(0), inNumSamples); }
1453 #endif
1454
secondarg_aa(BinaryOpUGen * unit,int inNumSamples)1455 void secondarg_aa(BinaryOpUGen* unit, int inNumSamples) {
1456 float* out = ZOUT(0);
1457 float* b = ZIN(1);
1458
1459 ZCopy(inNumSamples, out, b);
1460 }
1461
1462 #ifdef NOVA_SIMD
secondarg_aa_nova(BinaryOpUGen * unit,int inNumSamples)1463 FLATTEN void secondarg_aa_nova(BinaryOpUGen* unit, int inNumSamples) {
1464 nova::copyvec_simd(OUT(0), IN(1), inNumSamples);
1465 }
1466 #endif
1467
add_aa(BinaryOpUGen * unit,int inNumSamples)1468 void add_aa(BinaryOpUGen* unit, int inNumSamples) {
1469 float* out = ZOUT(0);
1470 float* a = ZIN(0);
1471 float* b = ZIN(1);
1472
1473 LOOP1(inNumSamples, ZXP(out) = ZXP(a) + ZXP(b););
1474 }
1475
add_ak(BinaryOpUGen * unit,int inNumSamples)1476 void add_ak(BinaryOpUGen* unit, int inNumSamples) {
1477 float* out = ZOUT(0);
1478 float* a = ZIN(0);
1479 float xb = unit->mPrevB;
1480 float next_b = ZIN0(1);
1481
1482 if (xb == next_b) {
1483 if (xb == 0.f) {
1484 ZCopy(inNumSamples, out, a);
1485 } else {
1486 float* out = ZOUT(0);
1487 float* a = ZIN(0);
1488 LOOP1(inNumSamples, ZXP(out) = ZXP(a) + xb;);
1489 }
1490 } else {
1491 float slope = CALCSLOPE(next_b, xb);
1492 LOOP1(inNumSamples, ZXP(out) = ZXP(a) + xb; xb += slope;);
1493 unit->mPrevB = xb;
1494 }
1495 }
1496
1497
add_ka(BinaryOpUGen * unit,int inNumSamples)1498 void add_ka(BinaryOpUGen* unit, int inNumSamples) {
1499 float* out = ZOUT(0);
1500 float xa = unit->mPrevA;
1501 float* b = ZIN(1);
1502 float next_a = ZIN0(0);
1503
1504 if (xa == next_a) {
1505 if (xa == 0.f) {
1506 ZCopy(inNumSamples, out, b);
1507 } else {
1508 LOOP1(inNumSamples, ZXP(out) = xa + ZXP(b););
1509 }
1510 } else {
1511 float slope = CALCSLOPE(next_a, xa);
1512 LOOP1(inNumSamples, ZXP(out) = xa + ZXP(b); xa += slope;);
1513 unit->mPrevA = xa;
1514 }
1515 }
1516
add_ia(BinaryOpUGen * unit,int inNumSamples)1517 void add_ia(BinaryOpUGen* unit, int inNumSamples) {
1518 float* out = ZOUT(0);
1519 float xa = ZIN0(0);
1520 float* b = ZIN(1);
1521
1522 LOOP1(inNumSamples, ZXP(out) = xa + ZXP(b););
1523 unit->mPrevA = xa;
1524 }
1525
add_ai(BinaryOpUGen * unit,int inNumSamples)1526 void add_ai(BinaryOpUGen* unit, int inNumSamples) {
1527 float* out = ZOUT(0);
1528 float* a = ZIN(0);
1529 float xb = ZIN0(1);
1530
1531 LOOP1(inNumSamples, ZXP(out) = ZXP(a) + xb;);
1532 unit->mPrevB = xb;
1533 }
1534
1535 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER(add,plus)1536 NOVA_BINARY_WRAPPER(add, plus)
1537
1538 FLATTEN void add_ak_nova(BinaryOpUGen* unit, int inNumSamples) {
1539 float xb = unit->mPrevB;
1540 float next_b = ZIN0(1);
1541
1542 if (xb == next_b) {
1543 if (xb == 0.f)
1544 nova::copyvec_simd(OUT(0), IN(0), inNumSamples);
1545 else
1546 nova::plus_vec_simd(OUT(0), IN(0), xb, inNumSamples);
1547 } else {
1548 float slope = CALCSLOPE(next_b, xb);
1549 nova::plus_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples);
1550 unit->mPrevB = next_b;
1551 }
1552 }
1553
add_ak_nova_64(BinaryOpUGen * unit,int inNumSamples)1554 FLATTEN void add_ak_nova_64(BinaryOpUGen* unit, int inNumSamples) {
1555 float xb = unit->mPrevB;
1556 float next_b = ZIN0(1);
1557
1558 if (xb == next_b) {
1559 if (xb == 0.f)
1560 nova::copyvec_simd<64>(OUT(0), IN(0));
1561 else
1562 nova::plus_vec_simd<64>(OUT(0), IN(0), xb);
1563 } else {
1564 float slope = CALCSLOPE(next_b, xb);
1565 nova::plus_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples);
1566 unit->mPrevB = next_b;
1567 }
1568 }
1569
1570
add_ka_nova(BinaryOpUGen * unit,int inNumSamples)1571 FLATTEN void add_ka_nova(BinaryOpUGen* unit, int inNumSamples) {
1572 float xa = unit->mPrevA;
1573 float next_a = ZIN0(0);
1574
1575 if (xa == next_a) {
1576 if (xa == 0.f)
1577 nova::copyvec_simd(OUT(0), IN(1), inNumSamples);
1578 else
1579 nova::plus_vec_simd(OUT(0), IN(1), xa, inNumSamples);
1580 } else {
1581 float slope = CALCSLOPE(next_a, xa);
1582 nova::plus_vec_simd(OUT(0), IN(1), slope_argument(xa, slope), inNumSamples);
1583 unit->mPrevA = next_a;
1584 }
1585 }
1586
add_ka_nova_64(BinaryOpUGen * unit,int inNumSamples)1587 FLATTEN void add_ka_nova_64(BinaryOpUGen* unit, int inNumSamples) {
1588 float xa = unit->mPrevA;
1589 float next_a = ZIN0(0);
1590
1591 if (xa == next_a) {
1592 if (xa == 0.f)
1593 nova::copyvec_simd<64>(OUT(0), IN(1));
1594 else
1595 nova::plus_vec_simd<64>(OUT(0), IN(1), xa);
1596 } else {
1597 float slope = CALCSLOPE(next_a, xa);
1598 nova::plus_vec_simd(OUT(0), IN(1), slope_argument(xa, slope), inNumSamples);
1599 unit->mPrevA = next_a;
1600 }
1601 }
1602
1603 #endif
1604
1605
1606 /////////////////////////
1607
1608
sub_aa(BinaryOpUGen * unit,int inNumSamples)1609 void sub_aa(BinaryOpUGen* unit, int inNumSamples) {
1610 float* out = ZOUT(0);
1611 float* a = ZIN(0);
1612 float* b = ZIN(1);
1613
1614 LOOP1(inNumSamples, ZXP(out) = ZXP(a) - ZXP(b););
1615 }
1616
sub_ak(BinaryOpUGen * unit,int inNumSamples)1617 void sub_ak(BinaryOpUGen* unit, int inNumSamples) {
1618 float* out = ZOUT(0);
1619 float* a = ZIN(0);
1620 float xb = unit->mPrevB;
1621 float next_b = ZIN0(1);
1622
1623 if (xb == next_b) {
1624 if (xb == 0.f) {
1625 ZCopy(inNumSamples, out, a);
1626 } else {
1627 LOOP1(inNumSamples, ZXP(out) = ZXP(a) - xb;);
1628 }
1629 } else {
1630 float slope = CALCSLOPE(next_b, xb);
1631 LOOP1(inNumSamples, ZXP(out) = ZXP(a) - xb; xb += slope;);
1632 unit->mPrevB = xb;
1633 }
1634 }
1635
sub_ka(BinaryOpUGen * unit,int inNumSamples)1636 void sub_ka(BinaryOpUGen* unit, int inNumSamples) {
1637 float* out = ZOUT(0);
1638 float xa = unit->mPrevA;
1639 float* b = ZIN(1);
1640 float next_a = ZIN0(0);
1641
1642 if (xa == next_a) {
1643 if (xa == 0.f) {
1644 ZCopy(inNumSamples, out, b);
1645 } else {
1646 LOOP1(inNumSamples, ZXP(out) = xa - ZXP(b););
1647 }
1648 } else {
1649 float slope = CALCSLOPE(next_a, xa);
1650 LOOP1(inNumSamples, ZXP(out) = xa - ZXP(b); xa += slope;);
1651 unit->mPrevA = xa;
1652 }
1653 }
1654
1655
sub_ia(BinaryOpUGen * unit,int inNumSamples)1656 void sub_ia(BinaryOpUGen* unit, int inNumSamples) {
1657 float* out = ZOUT(0);
1658 float xa = ZIN0(0);
1659 float* b = ZIN(1);
1660
1661 LOOP1(inNumSamples, ZXP(out) = xa - ZXP(b););
1662 unit->mPrevA = xa;
1663 }
1664
sub_ai(BinaryOpUGen * unit,int inNumSamples)1665 void sub_ai(BinaryOpUGen* unit, int inNumSamples) {
1666 float* out = ZOUT(0);
1667 float* a = ZIN(0);
1668 float xb = ZIN0(1);
1669
1670 LOOP1(inNumSamples, ZXP(out) = ZXP(a) - xb;);
1671 unit->mPrevB = xb;
1672 }
1673
1674 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER(sub,minus)1675 NOVA_BINARY_WRAPPER(sub, minus)
1676
1677 FLATTEN void sub_ak_nova(BinaryOpUGen* unit, int inNumSamples) {
1678 float xb = unit->mPrevB;
1679 float next_b = ZIN0(1);
1680
1681 if (xb == next_b) {
1682 if (xb == 0.f)
1683 nova::copyvec_simd(OUT(0), IN(0), inNumSamples);
1684 else
1685 nova::minus_vec_simd(OUT(0), IN(0), xb, inNumSamples);
1686 } else {
1687 float slope = CALCSLOPE(next_b, xb);
1688 nova::minus_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples);
1689 unit->mPrevB = next_b;
1690 }
1691 }
1692
sub_ak_nova_64(BinaryOpUGen * unit,int inNumSamples)1693 FLATTEN void sub_ak_nova_64(BinaryOpUGen* unit, int inNumSamples) {
1694 float xb = unit->mPrevB;
1695 float next_b = ZIN0(1);
1696
1697 if (xb == next_b) {
1698 if (xb == 0.f)
1699 nova::copyvec_aa_simd<64>(OUT(0), IN(0));
1700 else
1701 nova::minus_vec_simd<64>(OUT(0), IN(0), xb);
1702 } else {
1703 float slope = CALCSLOPE(next_b, xb);
1704 nova::minus_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples);
1705 unit->mPrevB = next_b;
1706 }
1707 }
1708
sub_ka_nova(BinaryOpUGen * unit,int inNumSamples)1709 FLATTEN void sub_ka_nova(BinaryOpUGen* unit, int inNumSamples) {
1710 float xa = unit->mPrevA;
1711 float next_a = ZIN0(0);
1712
1713 if (xa == next_a) {
1714 nova::minus_vec_simd(OUT(0), xa, IN(1), inNumSamples);
1715 } else {
1716 float slope = CALCSLOPE(next_a, xa);
1717 nova::minus_vec_simd(OUT(0), slope_argument(xa, slope), IN(1), inNumSamples);
1718 unit->mPrevA = next_a;
1719 }
1720 }
1721
sub_ka_nova_64(BinaryOpUGen * unit,int inNumSamples)1722 FLATTEN void sub_ka_nova_64(BinaryOpUGen* unit, int inNumSamples) {
1723 float xa = unit->mPrevA;
1724 float next_a = ZIN0(0);
1725
1726 if (xa == next_a) {
1727 nova::minus_vec_simd<64>(OUT(0), xa, IN(1));
1728 } else {
1729 float slope = CALCSLOPE(next_a, xa);
1730 nova::minus_vec_simd(OUT(0), slope_argument(xa, slope), IN(1), inNumSamples);
1731 unit->mPrevA = next_a;
1732 }
1733 }
1734
1735 #endif
1736
1737
mul_aa(BinaryOpUGen * unit,int inNumSamples)1738 void mul_aa(BinaryOpUGen* unit, int inNumSamples) {
1739 float* out = ZOUT(0);
1740 float* a = ZIN(0);
1741 float* b = ZIN(1);
1742
1743 LOOP1(inNumSamples, ZXP(out) = ZXP(a) * ZXP(b););
1744 }
1745
mul_ak(BinaryOpUGen * unit,int inNumSamples)1746 void mul_ak(BinaryOpUGen* unit, int inNumSamples) {
1747 float* out = ZOUT(0);
1748 float* a = ZIN(0);
1749 float xb = unit->mPrevB;
1750 float next_b = ZIN0(1);
1751
1752 if (xb == next_b) {
1753 if (xb == 0.f) {
1754 ZClear(inNumSamples, out);
1755 } else if (xb == 1.f) {
1756 ZCopy(inNumSamples, out, a);
1757 } else {
1758 LOOP1(inNumSamples, ZXP(out) = ZXP(a) * xb;);
1759 }
1760 } else {
1761 float slope = CALCSLOPE(next_b, xb);
1762 LOOP1(inNumSamples, ZXP(out) = ZXP(a) * xb; xb += slope;);
1763 unit->mPrevB = xb;
1764 }
1765 }
1766
mul_ka(BinaryOpUGen * unit,int inNumSamples)1767 void mul_ka(BinaryOpUGen* unit, int inNumSamples) {
1768 float* out = ZOUT(0);
1769 float xa = unit->mPrevA;
1770 float* b = ZIN(1);
1771 float next_a = ZIN0(0);
1772
1773 if (xa == next_a) {
1774 if (xa == 0.f) {
1775 ZClear(inNumSamples, out);
1776 } else if (xa == 1.f) {
1777 ZCopy(inNumSamples, out, b);
1778 } else {
1779 LOOP1(inNumSamples, ZXP(out) = xa * ZXP(b););
1780 }
1781 } else {
1782 float slope = CALCSLOPE(next_a, xa);
1783 LOOP1(inNumSamples, ZXP(out) = xa * ZXP(b); xa += slope;);
1784 unit->mPrevA = xa;
1785 }
1786 }
1787
1788
mul_ai(BinaryOpUGen * unit,int inNumSamples)1789 void mul_ai(BinaryOpUGen* unit, int inNumSamples) {
1790 float* out = ZOUT(0);
1791 float* a = ZIN(0);
1792 float xb = ZIN0(1);
1793
1794 LOOP1(inNumSamples, ZXP(out) = ZXP(a) * xb;);
1795 unit->mPrevB = xb;
1796 }
1797
mul_ia(BinaryOpUGen * unit,int inNumSamples)1798 void mul_ia(BinaryOpUGen* unit, int inNumSamples) {
1799 float* out = ZOUT(0);
1800 float xa = ZIN0(0);
1801 float* b = ZIN(1);
1802
1803 LOOP1(inNumSamples, ZXP(out) = xa * ZXP(b););
1804 unit->mPrevA = xa;
1805 }
1806
1807 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER(mul,times)1808 NOVA_BINARY_WRAPPER(mul, times)
1809
1810 FLATTEN void mul_ka_nova(BinaryOpUGen* unit, int inNumSamples) {
1811 float xa = unit->mPrevA;
1812 float next_a = ZIN0(0);
1813
1814 if (xa == next_a) {
1815 if (xa == 0.f)
1816 nova::zerovec_simd(OUT(0), inNumSamples);
1817 else if (xa == 1.f)
1818 nova::copyvec_simd(OUT(0), IN(1), inNumSamples);
1819 else
1820 nova::times_vec_simd(OUT(0), IN(1), xa, inNumSamples);
1821 } else {
1822 float slope = CALCSLOPE(next_a, xa);
1823 unit->mPrevA = next_a;
1824
1825 nova::times_vec_simd(OUT(0), IN(1), slope_argument(xa, slope), inNumSamples);
1826 }
1827 }
1828
mul_ka_nova_64(BinaryOpUGen * unit,int inNumSamples)1829 FLATTEN void mul_ka_nova_64(BinaryOpUGen* unit, int inNumSamples) {
1830 float xa = unit->mPrevA;
1831 float next_a = ZIN0(0);
1832
1833 if (xa == next_a) {
1834 if (xa == 0.f)
1835 nova::zerovec_simd<64>(OUT(0));
1836 else if (xa == 1.f)
1837 nova::copyvec_simd<64>(OUT(0), IN(1));
1838 else
1839 nova::times_vec_simd<64>(OUT(0), IN(1), xa);
1840 } else {
1841 float slope = CALCSLOPE(next_a, xa);
1842 unit->mPrevA = next_a;
1843
1844 nova::times_vec_simd(OUT(0), IN(1), slope_argument(xa, slope), inNumSamples);
1845 }
1846 }
1847
mul_ak_nova(BinaryOpUGen * unit,int inNumSamples)1848 FLATTEN void mul_ak_nova(BinaryOpUGen* unit, int inNumSamples) {
1849 float xb = unit->mPrevB;
1850 float next_b = ZIN0(1);
1851
1852 if (xb == next_b) {
1853 if (xb == 0.f)
1854 nova::zerovec_simd(OUT(0), inNumSamples);
1855 else if (xb == 1.f)
1856 nova::copyvec_simd(OUT(0), IN(0), inNumSamples);
1857 else
1858 nova::times_vec_simd(OUT(0), IN(0), xb, inNumSamples);
1859 } else {
1860 float slope = CALCSLOPE(next_b, xb);
1861 unit->mPrevB = next_b;
1862
1863 nova::times_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples);
1864 }
1865 }
1866
mul_ak_nova_64(BinaryOpUGen * unit,int inNumSamples)1867 FLATTEN void mul_ak_nova_64(BinaryOpUGen* unit, int inNumSamples) {
1868 float xb = unit->mPrevB;
1869 float next_b = ZIN0(1);
1870
1871 if (xb == next_b) {
1872 if (xb == 0.f)
1873 nova::zerovec_simd<64>(OUT(0));
1874 else if (xb == 1.f)
1875 nova::copyvec_simd<64>(OUT(0), IN(0));
1876 else
1877 nova::times_vec_simd<64>(OUT(0), IN(0), xb);
1878 } else {
1879 float slope = CALCSLOPE(next_b, xb);
1880 unit->mPrevB = next_b;
1881
1882 nova::times_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples);
1883 }
1884 }
1885
1886 #endif
1887
1888
div_aa(BinaryOpUGen * unit,int inNumSamples)1889 void div_aa(BinaryOpUGen* unit, int inNumSamples) {
1890 float* out = ZOUT(0);
1891 float* a = ZIN(0);
1892 float* b = ZIN(1);
1893
1894 LOOP1(inNumSamples, ZXP(out) = ZXP(a) / ZXP(b););
1895 }
1896
div_ak(BinaryOpUGen * unit,int inNumSamples)1897 void div_ak(BinaryOpUGen* unit, int inNumSamples) {
1898 float* out = ZOUT(0);
1899 float* a = ZIN(0);
1900 float xb = unit->mPrevB;
1901 float next_b = ZIN0(1);
1902
1903 if (xb == next_b) {
1904 if (xb == 0.f) {
1905 ZClear(inNumSamples, out);
1906 } else if (xb == 1.f) {
1907 ZCopy(inNumSamples, out, a);
1908 } else {
1909 float recip = 1.f / xb;
1910 LOOP1(inNumSamples, ZXP(out) = ZXP(a) * recip;);
1911 }
1912 } else {
1913 float slope = CALCSLOPE(next_b, xb);
1914 LOOP1(inNumSamples, ZXP(out) = ZXP(a) / xb; xb += slope;);
1915 unit->mPrevB = xb;
1916 }
1917 }
1918
div_ka(BinaryOpUGen * unit,int inNumSamples)1919 void div_ka(BinaryOpUGen* unit, int inNumSamples) {
1920 float* out = ZOUT(0);
1921 float xa = unit->mPrevA;
1922 float* b = ZIN(1);
1923 float next_a = ZIN0(0);
1924
1925 if (xa == next_a) {
1926 if (xa == 0.f) {
1927 ZClear(inNumSamples, out);
1928 } else {
1929 LOOP1(inNumSamples, ZXP(out) = xa / ZXP(b););
1930 }
1931 } else {
1932 float slope = CALCSLOPE(next_a, xa);
1933 LOOP1(inNumSamples, ZXP(out) = xa / ZXP(b); xa += slope;);
1934 unit->mPrevA = xa;
1935 }
1936 }
1937
div_ia(BinaryOpUGen * unit,int inNumSamples)1938 void div_ia(BinaryOpUGen* unit, int inNumSamples) {
1939 float* out = ZOUT(0);
1940 float xa = ZIN0(0);
1941 float* b = ZIN(1);
1942
1943 LOOP1(inNumSamples, ZXP(out) = xa / ZXP(b););
1944 unit->mPrevA = xa;
1945 }
1946
1947
div_ai(BinaryOpUGen * unit,int inNumSamples)1948 void div_ai(BinaryOpUGen* unit, int inNumSamples) {
1949 float* out = ZOUT(0);
1950 float* a = ZIN(0);
1951 float xb = ZIN0(1);
1952
1953 float rxb = 1.f / xb;
1954 LOOP1(inNumSamples, ZXP(out) = ZXP(a) * rxb;);
1955 unit->mPrevB = xb;
1956 }
1957
1958 #ifdef NOVA_SIMD
div_aa_nova(BinaryOpUGen * unit,int inNumSamples)1959 FLATTEN void div_aa_nova(BinaryOpUGen* unit, int inNumSamples) {
1960 nova::over_vec_simd(OUT(0), IN(0), IN(1), inNumSamples);
1961 }
1962
div_ia_nova(BinaryOpUGen * unit,int inNumSamples)1963 FLATTEN void div_ia_nova(BinaryOpUGen* unit, int inNumSamples) {
1964 float xa = ZIN0(0);
1965
1966 nova::over_vec_simd(OUT(0), xa, IN(1), inNumSamples);
1967 unit->mPrevA = xa;
1968 }
1969
div_ai_nova(BinaryOpUGen * unit,int inNumSamples)1970 FLATTEN void div_ai_nova(BinaryOpUGen* unit, int inNumSamples) {
1971 float xb = ZIN0(1);
1972
1973 nova::times_vec_simd(OUT(0), IN(0), sc_reciprocal(xb), inNumSamples);
1974 unit->mPrevB = xb;
1975 }
1976
div_ak_nova(BinaryOpUGen * unit,int inNumSamples)1977 FLATTEN void div_ak_nova(BinaryOpUGen* unit, int inNumSamples) {
1978 float xb = unit->mPrevB;
1979 float next_b = ZIN0(1);
1980
1981 if (xb == next_b) {
1982 if (xb == 0.f)
1983 nova::zerovec_simd(OUT(0), inNumSamples);
1984 else if (xb == 1.f)
1985 nova::copyvec_simd(OUT(0), IN(0), inNumSamples);
1986 else {
1987 float recip = 1.f / xb;
1988 nova::times_vec_simd(OUT(0), IN(0), recip, inNumSamples);
1989 }
1990 } else {
1991 float slope = CALCSLOPE(next_b, xb);
1992 nova::over_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples);
1993 unit->mPrevB = next_b;
1994 }
1995 }
1996
div_ka_nova(BinaryOpUGen * unit,int inNumSamples)1997 FLATTEN void div_ka_nova(BinaryOpUGen* unit, int inNumSamples) {
1998 float xa = unit->mPrevA;
1999 float next_a = ZIN0(0);
2000
2001 if (xa == next_a) {
2002 if (xa == 0.f)
2003 nova::zerovec_simd(OUT(0), inNumSamples);
2004 else
2005 nova::over_vec_simd(OUT(0), xa, IN(1), inNumSamples);
2006 } else {
2007 float slope = CALCSLOPE(next_a, xa);
2008 nova::over_vec_simd(OUT(0), slope_argument(xa, slope), IN(1), inNumSamples);
2009 unit->mPrevA = next_a;
2010 }
2011 }
2012
2013 #endif
2014
2015
idiv_aa(BinaryOpUGen * unit,int inNumSamples)2016 void idiv_aa(BinaryOpUGen* unit, int inNumSamples) {
2017 float* out = ZOUT(0);
2018 float* a = ZIN(0);
2019 float* b = ZIN(1);
2020
2021 LOOP1(inNumSamples, ZXP(out) = floor(ZXP(a) / ZXP(b)););
2022 }
2023
idiv_ak(BinaryOpUGen * unit,int inNumSamples)2024 void idiv_ak(BinaryOpUGen* unit, int inNumSamples) {
2025 float* out = ZOUT(0);
2026 float* a = ZIN(0);
2027 float xb = unit->mPrevB;
2028 float next_b = ZIN0(1);
2029
2030 if (xb == next_b) {
2031 ZXP(out) = floor(ZXP(a) / xb);
2032 } else {
2033 float slope = CALCSLOPE(next_b, xb);
2034 LOOP1(inNumSamples, ZXP(out) = floor(ZXP(a) / xb); xb += slope;);
2035 unit->mPrevB = xb;
2036 }
2037 }
2038
idiv_ka(BinaryOpUGen * unit,int inNumSamples)2039 void idiv_ka(BinaryOpUGen* unit, int inNumSamples) {
2040 float* out = ZOUT(0);
2041 float xa = unit->mPrevA;
2042 float* b = ZIN(1);
2043 float next_a = ZIN0(0);
2044
2045 if (xa == next_a) {
2046 if (xa == 0.f) {
2047 ZClear(inNumSamples, out);
2048 } else {
2049 LOOP1(inNumSamples, ZXP(out) = floor(xa / ZXP(b)););
2050 }
2051 } else {
2052 float slope = CALCSLOPE(next_a, xa);
2053 LOOP1(inNumSamples, ZXP(out) = floor(xa / ZXP(b)); xa += slope;);
2054 unit->mPrevA = xa;
2055 }
2056 }
2057
idiv_ia(BinaryOpUGen * unit,int inNumSamples)2058 void idiv_ia(BinaryOpUGen* unit, int inNumSamples) {
2059 float* out = ZOUT(0);
2060 float xa = ZIN0(0);
2061 float* b = ZIN(1);
2062
2063 LOOP1(inNumSamples, ZXP(out) = floor(xa / ZXP(b)););
2064 }
2065
2066
idiv_ai(BinaryOpUGen * unit,int inNumSamples)2067 void idiv_ai(BinaryOpUGen* unit, int inNumSamples) {
2068 float* out = ZOUT(0);
2069 float* a = ZIN(0);
2070 float xb = ZIN0(1);
2071
2072 LOOP1(inNumSamples, ZXP(out) = floor(ZXP(a) / xb););
2073 }
2074
2075
mod_aa(BinaryOpUGen * unit,int inNumSamples)2076 void mod_aa(BinaryOpUGen* unit, int inNumSamples) {
2077 float* out = ZOUT(0);
2078 float* a = ZIN(0);
2079 float* b = ZIN(1);
2080
2081 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_mod(xa, xb););
2082 }
2083
mod_ak(BinaryOpUGen * unit,int inNumSamples)2084 void mod_ak(BinaryOpUGen* unit, int inNumSamples) {
2085 float* out = ZOUT(0);
2086 float* a = ZIN(0);
2087 float xb = unit->mPrevB;
2088 float next_b = ZIN0(1);
2089
2090 if (xb == next_b) {
2091 if (xb == 0.f) {
2092 ZCopy(inNumSamples, out, a);
2093 } else {
2094 LOOP1(inNumSamples, ZXP(out) = sc_mod(ZXP(a), xb););
2095 }
2096 } else {
2097 float slope = CALCSLOPE(next_b, xb);
2098 LOOP1(inNumSamples, ZXP(out) = sc_mod(ZXP(a), xb); xb += slope;);
2099 unit->mPrevB = xb;
2100 }
2101 }
2102
mod_ka(BinaryOpUGen * unit,int inNumSamples)2103 void mod_ka(BinaryOpUGen* unit, int inNumSamples) {
2104 float* out = ZOUT(0);
2105 float xa = unit->mPrevA;
2106 float* b = ZIN(1);
2107 float next_a = ZIN0(0);
2108
2109 if (xa == next_a) {
2110 if (xa == 0.f) {
2111 ZClear(inNumSamples, out);
2112 } else {
2113 LOOP1(inNumSamples, ZXP(out) = sc_mod(xa, ZXP(b)););
2114 }
2115 } else {
2116 float slope = CALCSLOPE(next_a, xa);
2117 LOOP1(inNumSamples, ZXP(out) = sc_mod(xa, ZXP(b)); xa += slope;);
2118 unit->mPrevA = xa;
2119 }
2120 }
2121
2122
mod_ia(BinaryOpUGen * unit,int inNumSamples)2123 void mod_ia(BinaryOpUGen* unit, int inNumSamples) {
2124 float* out = ZOUT(0);
2125 float xa = ZIN0(0);
2126 float* b = ZIN(1);
2127
2128 LOOP1(inNumSamples, ZXP(out) = sc_mod(xa, ZXP(b)););
2129 unit->mPrevA = xa;
2130 }
2131
2132
mod_ai(BinaryOpUGen * unit,int inNumSamples)2133 void mod_ai(BinaryOpUGen* unit, int inNumSamples) {
2134 float* out = ZOUT(0);
2135 float* a = ZIN(0);
2136 float xb = ZIN0(1);
2137
2138 LOOP1(inNumSamples, ZXP(out) = sc_mod(ZXP(a), xb););
2139 unit->mPrevB = xb;
2140 }
2141
2142
max_aa(BinaryOpUGen * unit,int inNumSamples)2143 void max_aa(BinaryOpUGen* unit, int inNumSamples) {
2144 float* out = ZOUT(0);
2145 float* a = ZIN(0);
2146 float* b = ZIN(1);
2147
2148 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_max(xa, xb););
2149 }
2150
max_ak(BinaryOpUGen * unit,int inNumSamples)2151 void max_ak(BinaryOpUGen* unit, int inNumSamples) {
2152 float* out = ZOUT(0);
2153 float* a = ZIN(0);
2154 float xb = unit->mPrevB;
2155 float next_b = ZIN0(1);
2156
2157 if (xb == next_b) {
2158 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_max(xa, xb););
2159 } else {
2160 float slope = CALCSLOPE(next_b, xb);
2161 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_max(xa, xb); xb += slope;);
2162 unit->mPrevB = xb;
2163 }
2164 }
2165
max_ka(BinaryOpUGen * unit,int inNumSamples)2166 void max_ka(BinaryOpUGen* unit, int inNumSamples) {
2167 float* out = ZOUT(0);
2168 float xa = unit->mPrevA;
2169 float* b = ZIN(1);
2170 float next_a = ZIN0(0);
2171
2172 if (xa == next_a) {
2173 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_max(xa, xb););
2174 } else {
2175 float slope = CALCSLOPE(next_a, xa);
2176 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_max(xa, xb); xa += slope;);
2177 unit->mPrevA = xa;
2178 }
2179 }
2180
max_ia(BinaryOpUGen * unit,int inNumSamples)2181 void max_ia(BinaryOpUGen* unit, int inNumSamples) {
2182 float* out = ZOUT(0);
2183 float xa = ZIN0(0);
2184 float* b = ZIN(1);
2185
2186 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_max(xa, xb););
2187 unit->mPrevA = xa;
2188 }
2189
2190
max_ai(BinaryOpUGen * unit,int inNumSamples)2191 void max_ai(BinaryOpUGen* unit, int inNumSamples) {
2192 float* out = ZOUT(0);
2193 float* a = ZIN(0);
2194 float xb = ZIN0(1);
2195
2196 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_max(xa, xb););
2197 unit->mPrevB = xb;
2198 }
2199
2200 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(max,max)2201 NOVA_BINARY_WRAPPER_K(max, max)
2202 #endif
2203
2204
2205 void min_aa(BinaryOpUGen* unit, int inNumSamples) {
2206 float* out = ZOUT(0);
2207 float* a = ZIN(0);
2208 float* b = ZIN(1);
2209
2210 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_min(xa, xb););
2211 }
2212
min_ak(BinaryOpUGen * unit,int inNumSamples)2213 void min_ak(BinaryOpUGen* unit, int inNumSamples) {
2214 float* out = ZOUT(0);
2215 float* a = ZIN(0);
2216 float xb = unit->mPrevB;
2217 float next_b = ZIN0(1);
2218
2219 if (xb == next_b) {
2220 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_min(xa, xb););
2221 } else {
2222 float slope = CALCSLOPE(next_b, xb);
2223 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_min(xa, xb); xb += slope;);
2224 unit->mPrevB = xb;
2225 }
2226 }
2227
min_ka(BinaryOpUGen * unit,int inNumSamples)2228 void min_ka(BinaryOpUGen* unit, int inNumSamples) {
2229 float* out = ZOUT(0);
2230 float xa = unit->mPrevA;
2231 float* b = ZIN(1);
2232 float next_a = ZIN0(0);
2233
2234 if (xa == next_a) {
2235 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_min(xa, xb););
2236 } else {
2237 float slope = CALCSLOPE(next_a, xa);
2238 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_min(xa, xb); xa += slope;);
2239 unit->mPrevA = xa;
2240 }
2241 }
2242
min_ia(BinaryOpUGen * unit,int inNumSamples)2243 void min_ia(BinaryOpUGen* unit, int inNumSamples) {
2244 float* out = ZOUT(0);
2245 float xa = ZIN0(0);
2246 float* b = ZIN(1);
2247
2248 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_min(xa, xb););
2249 unit->mPrevA = xa;
2250 }
2251
2252
min_ai(BinaryOpUGen * unit,int inNumSamples)2253 void min_ai(BinaryOpUGen* unit, int inNumSamples) {
2254 float* out = ZOUT(0);
2255 float* a = ZIN(0);
2256 float xb = ZIN0(1);
2257
2258 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_min(xa, xb););
2259 unit->mPrevB = xb;
2260 }
2261
2262
2263 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(min,min)2264 NOVA_BINARY_WRAPPER_K(min, min)
2265 #endif
2266
2267
2268 void and_aa(BinaryOpUGen* unit, int inNumSamples) {
2269 float* out = ZOUT(0);
2270 float* a = ZIN(0);
2271 float* b = ZIN(1);
2272
2273 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_andt(xa, xb););
2274 }
2275
and_ak(BinaryOpUGen * unit,int inNumSamples)2276 void and_ak(BinaryOpUGen* unit, int inNumSamples) {
2277 float* out = ZOUT(0);
2278 float* a = ZIN(0);
2279 float xb = unit->mPrevB;
2280 float next_b = ZIN0(1);
2281
2282 if (xb == next_b) {
2283 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_andt(xa, xb););
2284 } else {
2285 float slope = CALCSLOPE(next_b, xb);
2286 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_andt(xa, xb); xb += slope;);
2287 unit->mPrevB = xb;
2288 }
2289 }
2290
and_ka(BinaryOpUGen * unit,int inNumSamples)2291 void and_ka(BinaryOpUGen* unit, int inNumSamples) {
2292 float* out = ZOUT(0);
2293 float xa = unit->mPrevA;
2294 float* b = ZIN(1);
2295 float next_a = ZIN0(0);
2296
2297 if (xa == next_a) {
2298 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_andt(xa, xb););
2299 } else {
2300 float slope = CALCSLOPE(next_a, xa);
2301 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_andt(xa, xb); xa += slope;);
2302 unit->mPrevA = xa;
2303 }
2304 }
2305
and_ia(BinaryOpUGen * unit,int inNumSamples)2306 void and_ia(BinaryOpUGen* unit, int inNumSamples) {
2307 float* out = ZOUT(0);
2308 float xa = ZIN0(0);
2309 float* b = ZIN(1);
2310
2311 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_andt(xa, xb););
2312 unit->mPrevA = xa;
2313 }
2314
2315
and_ai(BinaryOpUGen * unit,int inNumSamples)2316 void and_ai(BinaryOpUGen* unit, int inNumSamples) {
2317 float* out = ZOUT(0);
2318 float* a = ZIN(0);
2319 float xb = ZIN0(1);
2320
2321 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_andt(xa, xb););
2322 unit->mPrevB = xb;
2323 }
2324
2325
or_aa(BinaryOpUGen * unit,int inNumSamples)2326 void or_aa(BinaryOpUGen* unit, int inNumSamples) {
2327 float* out = ZOUT(0);
2328 float* a = ZIN(0);
2329 float* b = ZIN(1);
2330
2331 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_ort(xa, xb););
2332 }
2333
or_ak(BinaryOpUGen * unit,int inNumSamples)2334 void or_ak(BinaryOpUGen* unit, int inNumSamples) {
2335 float* out = ZOUT(0);
2336 float* a = ZIN(0);
2337 float xb = unit->mPrevB;
2338 float next_b = ZIN0(1);
2339
2340 if (xb == next_b) {
2341 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_ort(xa, xb););
2342 } else {
2343 float slope = CALCSLOPE(next_b, xb);
2344 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_ort(xa, xb); xb += slope;);
2345 unit->mPrevB = xb;
2346 }
2347 }
2348
or_ka(BinaryOpUGen * unit,int inNumSamples)2349 void or_ka(BinaryOpUGen* unit, int inNumSamples) {
2350 float* out = ZOUT(0);
2351 float xa = unit->mPrevA;
2352 float* b = ZIN(1);
2353 float next_a = ZIN0(0);
2354
2355 if (xa == next_a) {
2356 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_ort(xa, xb););
2357 } else {
2358 float slope = CALCSLOPE(next_a, xa);
2359 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_ort(xa, xb); xa += slope;);
2360 unit->mPrevA = xa;
2361 }
2362 }
2363
or_ia(BinaryOpUGen * unit,int inNumSamples)2364 void or_ia(BinaryOpUGen* unit, int inNumSamples) {
2365 float* out = ZOUT(0);
2366 float xa = ZIN0(0);
2367 float* b = ZIN(1);
2368
2369 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_ort(xa, xb););
2370 unit->mPrevA = xa;
2371 }
2372
2373
or_ai(BinaryOpUGen * unit,int inNumSamples)2374 void or_ai(BinaryOpUGen* unit, int inNumSamples) {
2375 float* out = ZOUT(0);
2376 float* a = ZIN(0);
2377 float xb = ZIN0(1);
2378
2379 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_ort(xa, xb););
2380 unit->mPrevB = xb;
2381 }
2382
2383
xor_aa(BinaryOpUGen * unit,int inNumSamples)2384 void xor_aa(BinaryOpUGen* unit, int inNumSamples) {
2385 float* out = ZOUT(0);
2386 float* a = ZIN(0);
2387 float* b = ZIN(1);
2388
2389 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_xort(xa, xb););
2390 }
2391
xor_ak(BinaryOpUGen * unit,int inNumSamples)2392 void xor_ak(BinaryOpUGen* unit, int inNumSamples) {
2393 float* out = ZOUT(0);
2394 float* a = ZIN(0);
2395 float xb = unit->mPrevB;
2396 float next_b = ZIN0(1);
2397
2398 if (xb == next_b) {
2399 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_xort(xa, xb););
2400 } else {
2401 float slope = CALCSLOPE(next_b, xb);
2402 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_xort(xa, xb); xb += slope;);
2403 unit->mPrevB = xb;
2404 }
2405 }
2406
xor_ka(BinaryOpUGen * unit,int inNumSamples)2407 void xor_ka(BinaryOpUGen* unit, int inNumSamples) {
2408 float* out = ZOUT(0);
2409 float xa = unit->mPrevA;
2410 float* b = ZIN(1);
2411 float next_a = ZIN0(0);
2412
2413 if (xa == next_a) {
2414 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_xort(xa, xb););
2415 } else {
2416 float slope = CALCSLOPE(next_a, xa);
2417 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_xort(xa, xb); xa += slope;);
2418 unit->mPrevA = xa;
2419 }
2420 }
2421
xor_ia(BinaryOpUGen * unit,int inNumSamples)2422 void xor_ia(BinaryOpUGen* unit, int inNumSamples) {
2423 float* out = ZOUT(0);
2424 float xa = ZIN0(0);
2425 float* b = ZIN(1);
2426
2427 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_xort(xa, xb););
2428 unit->mPrevA = xa;
2429 }
2430
2431
xor_ai(BinaryOpUGen * unit,int inNumSamples)2432 void xor_ai(BinaryOpUGen* unit, int inNumSamples) {
2433 float* out = ZOUT(0);
2434 float* a = ZIN(0);
2435 float xb = ZIN0(1);
2436
2437 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_xort(xa, xb););
2438 unit->mPrevB = xb;
2439 }
2440
2441
rightShift_aa(BinaryOpUGen * unit,int inNumSamples)2442 void rightShift_aa(BinaryOpUGen* unit, int inNumSamples) {
2443 float* out = ZOUT(0);
2444 float* a = ZIN(0);
2445 float* b = ZIN(1);
2446
2447 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_rst(xa, xb););
2448 }
2449
rightShift_ak(BinaryOpUGen * unit,int inNumSamples)2450 void rightShift_ak(BinaryOpUGen* unit, int inNumSamples) {
2451 float* out = ZOUT(0);
2452 float* a = ZIN(0);
2453 float xb = unit->mPrevB;
2454 float next_b = ZIN0(1);
2455
2456 if (xb == next_b) {
2457 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_rst(xa, xb););
2458 } else {
2459 float slope = CALCSLOPE(next_b, xb);
2460 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_rst(xa, xb); xb += slope;);
2461 unit->mPrevB = xb;
2462 }
2463 }
2464
rightShift_ka(BinaryOpUGen * unit,int inNumSamples)2465 void rightShift_ka(BinaryOpUGen* unit, int inNumSamples) {
2466 float* out = ZOUT(0);
2467 float xa = unit->mPrevA;
2468 float* b = ZIN(1);
2469 float next_a = ZIN0(0);
2470
2471 if (xa == next_a) {
2472 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_rst(xa, xb););
2473 } else {
2474 float slope = CALCSLOPE(next_a, xa);
2475 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_rst(xa, xb); xa += slope;);
2476 unit->mPrevA = xa;
2477 }
2478 }
2479
rightShift_ia(BinaryOpUGen * unit,int inNumSamples)2480 void rightShift_ia(BinaryOpUGen* unit, int inNumSamples) {
2481 float* out = ZOUT(0);
2482 float xa = ZIN0(0);
2483 float* b = ZIN(1);
2484
2485 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_rst(xa, xb););
2486 unit->mPrevA = xa;
2487 }
2488
2489
rightShift_ai(BinaryOpUGen * unit,int inNumSamples)2490 void rightShift_ai(BinaryOpUGen* unit, int inNumSamples) {
2491 float* out = ZOUT(0);
2492 float* a = ZIN(0);
2493 float xb = ZIN0(1);
2494
2495 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_rst(xa, xb););
2496 unit->mPrevB = xb;
2497 }
2498
2499
leftShift_aa(BinaryOpUGen * unit,int inNumSamples)2500 void leftShift_aa(BinaryOpUGen* unit, int inNumSamples) {
2501 float* out = ZOUT(0);
2502 float* a = ZIN(0);
2503 float* b = ZIN(1);
2504
2505 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_lst(xa, xb););
2506 }
2507
leftShift_ak(BinaryOpUGen * unit,int inNumSamples)2508 void leftShift_ak(BinaryOpUGen* unit, int inNumSamples) {
2509 float* out = ZOUT(0);
2510 float* a = ZIN(0);
2511 float xb = unit->mPrevB;
2512 float next_b = ZIN0(1);
2513
2514 if (xb == next_b) {
2515 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_lst(xa, xb););
2516 } else {
2517 float slope = CALCSLOPE(next_b, xb);
2518 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_lst(xa, xb); xb += slope;);
2519 unit->mPrevB = xb;
2520 }
2521 }
2522
leftShift_ka(BinaryOpUGen * unit,int inNumSamples)2523 void leftShift_ka(BinaryOpUGen* unit, int inNumSamples) {
2524 float* out = ZOUT(0);
2525 float xa = unit->mPrevA;
2526 float* b = ZIN(1);
2527 float next_a = ZIN0(0);
2528
2529 if (xa == next_a) {
2530 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_lst(xa, xb););
2531 } else {
2532 float slope = CALCSLOPE(next_a, xa);
2533 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_lst(xa, xb); xa += slope;);
2534 unit->mPrevA = xa;
2535 }
2536 }
2537
leftShift_ia(BinaryOpUGen * unit,int inNumSamples)2538 void leftShift_ia(BinaryOpUGen* unit, int inNumSamples) {
2539 float* out = ZOUT(0);
2540 float xa = ZIN0(0);
2541 float* b = ZIN(1);
2542
2543 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_lst(xa, xb););
2544 unit->mPrevA = xa;
2545 }
2546
2547
leftShift_ai(BinaryOpUGen * unit,int inNumSamples)2548 void leftShift_ai(BinaryOpUGen* unit, int inNumSamples) {
2549 float* out = ZOUT(0);
2550 float* a = ZIN(0);
2551 float xb = ZIN0(1);
2552
2553 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_lst(xa, xb););
2554 unit->mPrevB = xb;
2555 }
2556
2557
lcm_aa(BinaryOpUGen * unit,int inNumSamples)2558 void lcm_aa(BinaryOpUGen* unit, int inNumSamples) {
2559 float* out = ZOUT(0);
2560 float* a = ZIN(0);
2561 float* b = ZIN(1);
2562
2563 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_lcm(xa, xb););
2564 }
2565
lcm_ak(BinaryOpUGen * unit,int inNumSamples)2566 void lcm_ak(BinaryOpUGen* unit, int inNumSamples) {
2567 float* out = ZOUT(0);
2568 float* a = ZIN(0);
2569 float xb = unit->mPrevB;
2570 float next_b = ZIN0(1);
2571
2572 if (xb == next_b) {
2573 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_lcm(xa, xb););
2574 unit->mPrevB = xb;
2575 } else {
2576 float slope = CALCSLOPE(next_b, xb);
2577 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_lcm(xa, xb); xb += slope;);
2578 unit->mPrevB = xb;
2579 }
2580 }
2581
lcm_ka(BinaryOpUGen * unit,int inNumSamples)2582 void lcm_ka(BinaryOpUGen* unit, int inNumSamples) {
2583 float* out = ZOUT(0);
2584 float xa = unit->mPrevA;
2585 float* b = ZIN(1);
2586 float next_a = ZIN0(0);
2587
2588 if (xa == next_a) {
2589 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_lcm(xa, xb););
2590 } else {
2591 float slope = CALCSLOPE(next_a, xa);
2592 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_lcm(xa, xb); xa += slope;);
2593 unit->mPrevA = xa;
2594 }
2595 }
2596
lcm_ia(BinaryOpUGen * unit,int inNumSamples)2597 void lcm_ia(BinaryOpUGen* unit, int inNumSamples) {
2598 float* out = ZOUT(0);
2599 float xa = ZIN0(0);
2600 float* b = ZIN(1);
2601
2602 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_lcm(xa, xb););
2603 unit->mPrevA = xa;
2604 }
2605
2606
lcm_ai(BinaryOpUGen * unit,int inNumSamples)2607 void lcm_ai(BinaryOpUGen* unit, int inNumSamples) {
2608 float* out = ZOUT(0);
2609 float* a = ZIN(0);
2610 float xb = ZIN0(1);
2611
2612 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_lcm(xa, xb););
2613 unit->mPrevB = xb;
2614 }
2615
2616
gcd_aa(BinaryOpUGen * unit,int inNumSamples)2617 void gcd_aa(BinaryOpUGen* unit, int inNumSamples) {
2618 float* out = ZOUT(0);
2619 float* a = ZIN(0);
2620 float* b = ZIN(1);
2621
2622 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_gcd(xa, xb););
2623 }
2624
gcd_ak(BinaryOpUGen * unit,int inNumSamples)2625 void gcd_ak(BinaryOpUGen* unit, int inNumSamples) {
2626 float* out = ZOUT(0);
2627 float* a = ZIN(0);
2628 float xb = unit->mPrevB;
2629 float next_b = ZIN0(1);
2630
2631 if (xb == next_b) {
2632 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_gcd(xa, xb););
2633 unit->mPrevB = xb;
2634 } else {
2635 float slope = CALCSLOPE(next_b, xb);
2636 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_gcd(xa, xb); xb += slope;);
2637 unit->mPrevB = xb;
2638 }
2639 }
2640
gcd_ka(BinaryOpUGen * unit,int inNumSamples)2641 void gcd_ka(BinaryOpUGen* unit, int inNumSamples) {
2642 float* out = ZOUT(0);
2643 float xa = unit->mPrevA;
2644 float* b = ZIN(1);
2645 float next_a = ZIN0(0);
2646
2647 if (xa == next_a) {
2648 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_gcd(xa, xb););
2649 } else {
2650 float slope = CALCSLOPE(next_a, xa);
2651 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_gcd(xa, xb); xa += slope;);
2652 unit->mPrevA = xa;
2653 }
2654 }
2655
gcd_ia(BinaryOpUGen * unit,int inNumSamples)2656 void gcd_ia(BinaryOpUGen* unit, int inNumSamples) {
2657 float* out = ZOUT(0);
2658 float xa = ZIN0(0);
2659 float* b = ZIN(1);
2660
2661 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_gcd(xa, xb););
2662 unit->mPrevA = xa;
2663 }
2664
2665
gcd_ai(BinaryOpUGen * unit,int inNumSamples)2666 void gcd_ai(BinaryOpUGen* unit, int inNumSamples) {
2667 float* out = ZOUT(0);
2668 float* a = ZIN(0);
2669 float xb = ZIN0(1);
2670
2671 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_gcd(xa, xb););
2672 unit->mPrevB = xb;
2673 }
2674
2675
amclip_aa(BinaryOpUGen * unit,int inNumSamples)2676 void amclip_aa(BinaryOpUGen* unit, int inNumSamples) {
2677 float* out = ZOUT(0);
2678 float* a = ZIN(0);
2679 float* b = ZIN(1);
2680
2681 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_amclip(xa, xb););
2682 }
2683
amclip_ak(BinaryOpUGen * unit,int inNumSamples)2684 void amclip_ak(BinaryOpUGen* unit, int inNumSamples) {
2685 float* out = ZOUT(0);
2686 float* a = ZIN(0);
2687 float xb = unit->mPrevB;
2688 float next_b = ZIN0(1);
2689
2690 if (xb == next_b) {
2691 if (xb > 0.f) {
2692 LOOP1(inNumSamples, ZXP(out) = ZXP(a) * xb;);
2693 } else {
2694 ZClear(inNumSamples, out);
2695 }
2696 } else {
2697 float slope = CALCSLOPE(next_b, xb);
2698 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_amclip(xa, xb); xb += slope;);
2699 unit->mPrevB = xb;
2700 }
2701 }
2702
amclip_ka(BinaryOpUGen * unit,int inNumSamples)2703 void amclip_ka(BinaryOpUGen* unit, int inNumSamples) {
2704 float* out = ZOUT(0);
2705 float xa = unit->mPrevA;
2706 float* b = ZIN(1);
2707 float next_a = ZIN0(0);
2708
2709 if (xa == next_a) {
2710 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_amclip(xa, xb););
2711 } else {
2712 float slope = CALCSLOPE(next_a, xa);
2713 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_amclip(xa, xb); xa += slope;);
2714 unit->mPrevA = xa;
2715 }
2716 }
2717
amclip_ia(BinaryOpUGen * unit,int inNumSamples)2718 void amclip_ia(BinaryOpUGen* unit, int inNumSamples) {
2719 float* out = ZOUT(0);
2720 float xa = ZIN0(0);
2721 float* b = ZIN(1);
2722
2723 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_amclip(xa, xb););
2724 unit->mPrevA = xa;
2725 }
2726
2727
amclip_ai(BinaryOpUGen * unit,int inNumSamples)2728 void amclip_ai(BinaryOpUGen* unit, int inNumSamples) {
2729 float* out = ZOUT(0);
2730 float* a = ZIN(0);
2731 float xb = ZIN0(1);
2732
2733 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_amclip(xa, xb););
2734 unit->mPrevB = xb;
2735 }
2736
2737
scaleneg_aa(BinaryOpUGen * unit,int inNumSamples)2738 void scaleneg_aa(BinaryOpUGen* unit, int inNumSamples) {
2739 float* out = ZOUT(0);
2740 float* a = ZIN(0);
2741 float* b = ZIN(1);
2742
2743 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa >= 0.f ? xa : xa * xb;);
2744 }
2745
scaleneg_ak(BinaryOpUGen * unit,int inNumSamples)2746 void scaleneg_ak(BinaryOpUGen* unit, int inNumSamples) {
2747 float* out = ZOUT(0);
2748 float* a = ZIN(0);
2749 float xb = unit->mPrevB;
2750 float next_b = ZIN0(1);
2751
2752 if (xb == next_b) {
2753 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa >= 0.f ? xa : xa * xb;);
2754 } else {
2755 float slope = CALCSLOPE(next_b, xb);
2756 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa >= 0.f ? xa : xa * xb; xb += slope;);
2757 unit->mPrevB = xb;
2758 }
2759 }
2760
scaleneg_ka(BinaryOpUGen * unit,int inNumSamples)2761 void scaleneg_ka(BinaryOpUGen* unit, int inNumSamples) {
2762 float* out = ZOUT(0);
2763 float xa = unit->mPrevA;
2764 float* b = ZIN(1);
2765 float next_a = ZIN0(0);
2766
2767 if (xa == next_a) {
2768 if (xa >= 0.f) {
2769 LOOP1(inNumSamples, ZXP(out) = xa;);
2770 } else {
2771 LOOP1(inNumSamples, ZXP(out) = xa * ZXP(b););
2772 }
2773 } else {
2774 float slope = CALCSLOPE(next_a, xa);
2775 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa >= 0.f ? xa : xa * xb; xa += slope;);
2776 unit->mPrevA = xa;
2777 }
2778 }
2779
scaleneg_ia(BinaryOpUGen * unit,int inNumSamples)2780 void scaleneg_ia(BinaryOpUGen* unit, int inNumSamples) {
2781 float* out = ZOUT(0);
2782 float xa = ZIN0(0);
2783 float* b = ZIN(1);
2784
2785 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa >= 0.f ? xa : xa * xb;);
2786 unit->mPrevA = xa;
2787 }
2788
2789
scaleneg_ai(BinaryOpUGen * unit,int inNumSamples)2790 void scaleneg_ai(BinaryOpUGen* unit, int inNumSamples) {
2791 float* out = ZOUT(0);
2792 float* a = ZIN(0);
2793 float xb = ZIN0(1);
2794
2795 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa >= 0.f ? xa : xa * xb;);
2796 unit->mPrevB = xb;
2797 }
2798
2799
pow_aa(BinaryOpUGen * unit,int inNumSamples)2800 void pow_aa(BinaryOpUGen* unit, int inNumSamples) {
2801 float* out = ZOUT(0);
2802 float* a = ZIN(0);
2803 float* b = ZIN(1);
2804
2805 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa >= 0.f ? pow(xa, xb) : -pow(-xa, xb););
2806 }
2807
2808
pow_ak(BinaryOpUGen * unit,int inNumSamples)2809 void pow_ak(BinaryOpUGen* unit, int inNumSamples) {
2810 float* out = ZOUT(0);
2811 float* a = ZIN(0);
2812 float xb = unit->mPrevB;
2813 float next_b = ZIN0(1);
2814
2815 if (xb == next_b) {
2816 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa >= 0.f ? pow(xa, xb) : -pow(-xa, xb););
2817 } else {
2818 float slope = CALCSLOPE(next_b, xb);
2819 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa >= 0.f ? pow(xa, xb) : -pow(-xa, xb); xb += slope;);
2820 unit->mPrevB = xb;
2821 }
2822 }
2823
pow_ka(BinaryOpUGen * unit,int inNumSamples)2824 void pow_ka(BinaryOpUGen* unit, int inNumSamples) {
2825 float* out = ZOUT(0);
2826 float xa = unit->mPrevA;
2827 float* b = ZIN(1);
2828 float next_a = ZIN0(0);
2829
2830 if (xa == next_a) {
2831 if (xa >= 0.f) {
2832 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = pow(xa, xb););
2833 } else {
2834 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = -pow(-xa, xb););
2835 }
2836 } else {
2837 float slope = CALCSLOPE(next_a, xa);
2838 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa >= 0.f ? pow(xa, xb) : -pow(-xa, xb); xa += slope;);
2839 unit->mPrevA = xa;
2840 }
2841 }
2842
pow_ia(BinaryOpUGen * unit,int inNumSamples)2843 void pow_ia(BinaryOpUGen* unit, int inNumSamples) {
2844 float* out = ZOUT(0);
2845 float xa = ZIN0(0);
2846 float* b = ZIN(1);
2847
2848 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa >= 0.f ? pow(xa, xb) : -pow(-xa, xb););
2849 unit->mPrevA = xa;
2850 }
2851
2852
pow_ai(BinaryOpUGen * unit,int inNumSamples)2853 void pow_ai(BinaryOpUGen* unit, int inNumSamples) {
2854 float* out = ZOUT(0);
2855 float* a = ZIN(0);
2856 float xb = ZIN0(1);
2857
2858 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa >= 0.f ? pow(xa, xb) : -pow(-xa, xb););
2859 unit->mPrevB = xb;
2860 }
2861
2862 #ifdef NOVA_SIMD
pow_aa_nova(BinaryOpUGen * unit,int inNumSamples)2863 FLATTEN void pow_aa_nova(BinaryOpUGen* unit, int inNumSamples) {
2864 nova::spow_vec_simd(OUT(0), IN(0), IN(1), inNumSamples);
2865 }
2866
pow_ak_nova(BinaryOpUGen * unit,int inNumSamples)2867 FLATTEN void pow_ak_nova(BinaryOpUGen* unit, int inNumSamples) {
2868 float xb = unit->mPrevB;
2869 float next_b = ZIN0(1);
2870
2871 if (xb == next_b)
2872 nova::spow_vec_simd(OUT(0), IN(0), xb, inNumSamples);
2873 else {
2874 float slope = CALCSLOPE(next_b, xb);
2875 nova::spow_vec_simd(OUT(0), IN(0), slope_argument(xb, slope), inNumSamples);
2876 unit->mPrevB = next_b;
2877 }
2878 }
2879
pow_ka_nova(BinaryOpUGen * unit,int inNumSamples)2880 FLATTEN void pow_ka_nova(BinaryOpUGen* unit, int inNumSamples) {
2881 float xa = unit->mPrevA;
2882 float next_a = ZIN0(0);
2883
2884 if (xa == next_a) {
2885 if (xa >= 0.f)
2886 nova::pow_vec_simd(OUT(0), xa, IN(1), inNumSamples);
2887 else
2888 nova::spow_vec_simd(OUT(0), xa, IN(1), inNumSamples);
2889 } else {
2890 float slope = CALCSLOPE(next_a, xa);
2891 nova::spow_vec_simd(OUT(0), slope_argument(xa, slope), IN(1), inNumSamples);
2892 unit->mPrevA = next_a;
2893 }
2894 }
2895
2896
pow_ia_nova(BinaryOpUGen * unit,int inNumSamples)2897 FLATTEN void pow_ia_nova(BinaryOpUGen* unit, int inNumSamples) {
2898 float xa = ZIN0(0);
2899 if (xa > 0.f)
2900 nova::pow_vec_simd(OUT(0), xa, IN(1), inNumSamples);
2901 else
2902 nova::spow_vec_simd(OUT(0), xa, IN(1), inNumSamples);
2903 unit->mPrevA = xa;
2904 }
2905
2906
pow_ai_nova(BinaryOpUGen * unit,int inNumSamples)2907 FLATTEN void pow_ai_nova(BinaryOpUGen* unit, int inNumSamples) {
2908 float xb = ZIN0(1);
2909 nova::spow_vec_simd(OUT(0), IN(0), xb, inNumSamples);
2910 }
2911 #endif
2912
2913 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER(ring1,sc_ring1)2914 NOVA_BINARY_WRAPPER(ring1, sc_ring1)
2915 NOVA_BINARY_WRAPPER(ring2, sc_ring2)
2916 NOVA_BINARY_WRAPPER(ring3, sc_ring3)
2917 NOVA_BINARY_WRAPPER(ring4, sc_ring4)
2918 #endif
2919
2920
2921 void ring1_aa(BinaryOpUGen* unit, int inNumSamples) {
2922 float* out = ZOUT(0);
2923 float* a = ZIN(0);
2924 float* b = ZIN(1);
2925
2926 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa * xb + xa;);
2927 }
2928
ring1_ak(BinaryOpUGen * unit,int inNumSamples)2929 void ring1_ak(BinaryOpUGen* unit, int inNumSamples) {
2930 float* out = ZOUT(0);
2931 float* a = ZIN(0);
2932 float xb = unit->mPrevB;
2933 float next_b = ZIN0(1);
2934
2935 if (xb == next_b) {
2936 if (xb == 0.f) {
2937 ZCopy(inNumSamples, out, a);
2938 } else if (xb == 1.f) {
2939 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa + xa;);
2940 } else {
2941 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xb + xa;);
2942 }
2943 } else {
2944 float slope = CALCSLOPE(next_b, xb);
2945 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xb + xa; xb += slope;);
2946 unit->mPrevB = xb;
2947 }
2948 }
2949
ring1_ka(BinaryOpUGen * unit,int inNumSamples)2950 void ring1_ka(BinaryOpUGen* unit, int inNumSamples) {
2951 float* out = ZOUT(0);
2952 float xa = unit->mPrevA;
2953 float* b = ZIN(1);
2954 float next_a = ZIN0(0);
2955
2956 if (xa == next_a) {
2957 if (xa == 0.f) {
2958 LOOP1(inNumSamples, ZXP(out) = 0.f;);
2959 } else {
2960 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xb + xa;);
2961 }
2962 } else {
2963 float slope = CALCSLOPE(next_a, xa);
2964 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xb + xa; xa += slope;);
2965 unit->mPrevA = xa;
2966 }
2967 }
2968
ring1_ia(BinaryOpUGen * unit,int inNumSamples)2969 void ring1_ia(BinaryOpUGen* unit, int inNumSamples) {
2970 float* out = ZOUT(0);
2971 float xa = ZIN0(0);
2972 float* b = ZIN(1);
2973
2974 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xb + xa;);
2975 unit->mPrevA = xa;
2976 }
2977
2978
ring1_ai(BinaryOpUGen * unit,int inNumSamples)2979 void ring1_ai(BinaryOpUGen* unit, int inNumSamples) {
2980 float* out = ZOUT(0);
2981 float* a = ZIN(0);
2982 float xb = ZIN0(1);
2983
2984 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xb + xa;);
2985 unit->mPrevB = xb;
2986 }
2987
2988
ring2_aa(BinaryOpUGen * unit,int inNumSamples)2989 void ring2_aa(BinaryOpUGen* unit, int inNumSamples) {
2990 float* out = ZOUT(0);
2991 float* a = ZIN(0);
2992 float* b = ZIN(1);
2993
2994 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa * xb + xa + xb;);
2995 }
2996
ring2_ak(BinaryOpUGen * unit,int inNumSamples)2997 void ring2_ak(BinaryOpUGen* unit, int inNumSamples) {
2998 float* out = ZOUT(0);
2999 float* a = ZIN(0);
3000 float xb = unit->mPrevB;
3001 float next_b = ZIN0(1);
3002
3003 if (xb == next_b) {
3004 if (xb == 0.f) {
3005 ZCopy(inNumSamples, out, a);
3006 } else {
3007 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xb + xa + xb;);
3008 }
3009 } else {
3010 float slope = CALCSLOPE(next_b, xb);
3011 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xb + xa + xb; xb += slope;);
3012 unit->mPrevB = xb;
3013 }
3014 }
3015
ring2_ka(BinaryOpUGen * unit,int inNumSamples)3016 void ring2_ka(BinaryOpUGen* unit, int inNumSamples) {
3017 float* out = ZOUT(0);
3018 float xa = unit->mPrevA;
3019 float* b = ZIN(1);
3020 float next_a = ZIN0(0);
3021
3022 if (xa == next_a) {
3023 if (xa == 0.f) {
3024 ZCopy(inNumSamples, out, b);
3025 } else {
3026 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xb + xa + xb;);
3027 }
3028 } else {
3029 float slope = CALCSLOPE(next_a, xa);
3030 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xb + xa + xb; xa += slope;);
3031 unit->mPrevA = xa;
3032 }
3033 }
3034
ring2_ia(BinaryOpUGen * unit,int inNumSamples)3035 void ring2_ia(BinaryOpUGen* unit, int inNumSamples) {
3036 float* out = ZOUT(0);
3037 float xa = ZIN0(0);
3038 float* b = ZIN(1);
3039
3040 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xb + xa + xb;);
3041 unit->mPrevA = xa;
3042 }
3043
3044
ring2_ai(BinaryOpUGen * unit,int inNumSamples)3045 void ring2_ai(BinaryOpUGen* unit, int inNumSamples) {
3046 float* out = ZOUT(0);
3047 float* a = ZIN(0);
3048 float xb = ZIN0(1);
3049
3050 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xb + xa + xb;);
3051 unit->mPrevB = xb;
3052 }
3053
3054
ring3_aa(BinaryOpUGen * unit,int inNumSamples)3055 void ring3_aa(BinaryOpUGen* unit, int inNumSamples) {
3056 float* out = ZOUT(0);
3057 float* a = ZIN(0);
3058 float* b = ZIN(1);
3059
3060 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa * xa * xb;);
3061 }
3062
ring3_ak(BinaryOpUGen * unit,int inNumSamples)3063 void ring3_ak(BinaryOpUGen* unit, int inNumSamples) {
3064 float* out = ZOUT(0);
3065 float* a = ZIN(0);
3066 float xb = unit->mPrevB;
3067 float next_b = ZIN0(1);
3068
3069 if (xb == next_b) {
3070 if (xb == 0.f) {
3071 ZClear(inNumSamples, out);
3072 } else if (xb == 1.f) {
3073 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa;);
3074 } else {
3075 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa * xb;);
3076 }
3077 } else {
3078 float slope = CALCSLOPE(next_b, xb);
3079 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa * xb; xb += slope;);
3080 unit->mPrevB = xb;
3081 }
3082 }
3083
ring3_ka(BinaryOpUGen * unit,int inNumSamples)3084 void ring3_ka(BinaryOpUGen* unit, int inNumSamples) {
3085 float* out = ZOUT(0);
3086 float xa = unit->mPrevA;
3087 float* b = ZIN(1);
3088 float next_a = ZIN0(0);
3089
3090 if (xa == next_a) {
3091 if (xa == 0.f) {
3092 ZClear(inNumSamples, out);
3093 } else if (xa == 1.f) {
3094 ZCopy(inNumSamples, out, b);
3095 } else {
3096 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa * xb;);
3097 }
3098 } else {
3099 float slope = CALCSLOPE(next_a, xa);
3100 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa * xb; xa += slope;);
3101 unit->mPrevA = xa;
3102 }
3103 }
3104
ring3_ia(BinaryOpUGen * unit,int inNumSamples)3105 void ring3_ia(BinaryOpUGen* unit, int inNumSamples) {
3106 float* out = ZOUT(0);
3107 float xa = ZIN0(0);
3108 float* b = ZIN(1);
3109
3110 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa * xb;);
3111 unit->mPrevA = xa;
3112 }
3113
3114
ring3_ai(BinaryOpUGen * unit,int inNumSamples)3115 void ring3_ai(BinaryOpUGen* unit, int inNumSamples) {
3116 float* out = ZOUT(0);
3117 float* a = ZIN(0);
3118 float xb = ZIN0(1);
3119
3120 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa * xb;);
3121 unit->mPrevB = xb;
3122 }
3123
3124
ring4_aa(BinaryOpUGen * unit,int inNumSamples)3125 void ring4_aa(BinaryOpUGen* unit, int inNumSamples) {
3126 float* out = ZOUT(0);
3127 float* a = ZIN(0);
3128 float* b = ZIN(1);
3129
3130 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa * xa * xb - xa * xb * xb;);
3131 }
3132
ring4_ak(BinaryOpUGen * unit,int inNumSamples)3133 void ring4_ak(BinaryOpUGen* unit, int inNumSamples) {
3134 float* out = ZOUT(0);
3135 float* a = ZIN(0);
3136 float xb = unit->mPrevB;
3137 float next_b = ZIN0(1);
3138
3139 if (xb == next_b) {
3140 if (xb == 0.f) {
3141 ZClear(inNumSamples, out);
3142 } else if (xb == 1.f) {
3143 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa - xa;);
3144 } else {
3145 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa * xb - xa * xb * xb;);
3146 }
3147 } else {
3148 float slope = CALCSLOPE(next_b, xb);
3149 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa * xb - xa * xb * xb; xb += slope;);
3150 unit->mPrevB = xb;
3151 }
3152 }
3153
ring4_ka(BinaryOpUGen * unit,int inNumSamples)3154 void ring4_ka(BinaryOpUGen* unit, int inNumSamples) {
3155 float* out = ZOUT(0);
3156 float xa = unit->mPrevA;
3157 float* b = ZIN(1);
3158 float next_a = ZIN0(0);
3159
3160 if (xa == next_a) {
3161 if (xa == 0.f) {
3162 ZClear(inNumSamples, out);
3163 } else if (xa == 1.f) {
3164 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xb - xb * xb;);
3165 } else {
3166 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa * xb - xa * xb * xb;);
3167 }
3168 } else {
3169 float slope = CALCSLOPE(next_a, xa);
3170 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa * xb - xa * xb * xb; xa += slope;);
3171 unit->mPrevA = xa;
3172 }
3173 }
3174
ring4_ia(BinaryOpUGen * unit,int inNumSamples)3175 void ring4_ia(BinaryOpUGen* unit, int inNumSamples) {
3176 float* out = ZOUT(0);
3177 float xa = ZIN0(0);
3178 float* b = ZIN(1);
3179
3180 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa * xb - xa * xb * xb;);
3181 unit->mPrevA = xa;
3182 }
3183
3184
ring4_ai(BinaryOpUGen * unit,int inNumSamples)3185 void ring4_ai(BinaryOpUGen* unit, int inNumSamples) {
3186 float* out = ZOUT(0);
3187 float* a = ZIN(0);
3188 float xb = ZIN0(1);
3189
3190 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa * xb - xa * xb * xb;);
3191 unit->mPrevB = xb;
3192 }
3193
3194
thresh_aa(BinaryOpUGen * unit,int inNumSamples)3195 void thresh_aa(BinaryOpUGen* unit, int inNumSamples) {
3196 float* out = ZOUT(0);
3197 float* a = ZIN(0);
3198 float* b = ZIN(1);
3199
3200 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa < xb ? 0.f : xa;);
3201 }
3202
thresh_ak(BinaryOpUGen * unit,int inNumSamples)3203 void thresh_ak(BinaryOpUGen* unit, int inNumSamples) {
3204 float* out = ZOUT(0);
3205 float* a = ZIN(0);
3206 float xb = unit->mPrevB;
3207 float next_b = ZIN0(1);
3208
3209 if (xb == next_b) {
3210 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa < xb ? 0.f : xa;);
3211 } else {
3212 float slope = CALCSLOPE(next_b, xb);
3213 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa < xb ? 0.f : xa; xb += slope;);
3214 unit->mPrevB = xb;
3215 }
3216 }
3217
thresh_ka(BinaryOpUGen * unit,int inNumSamples)3218 void thresh_ka(BinaryOpUGen* unit, int inNumSamples) {
3219 float* out = ZOUT(0);
3220 float xa = unit->mPrevA;
3221 float* b = ZIN(1);
3222 float next_a = ZIN0(0);
3223
3224 if (xa == next_a) {
3225 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa < xb ? 0.f : xa;);
3226 } else {
3227 float slope = CALCSLOPE(next_a, xa);
3228 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa < xb ? 0.f : xa; xa += slope;);
3229 unit->mPrevA = xa;
3230 }
3231 }
3232
thresh_ia(BinaryOpUGen * unit,int inNumSamples)3233 void thresh_ia(BinaryOpUGen* unit, int inNumSamples) {
3234 float* out = ZOUT(0);
3235 float xa = ZIN0(0);
3236 float* b = ZIN(1);
3237
3238 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa < xb ? 0.f : xa;);
3239 unit->mPrevA = xa;
3240 }
3241
3242
thresh_ai(BinaryOpUGen * unit,int inNumSamples)3243 void thresh_ai(BinaryOpUGen* unit, int inNumSamples) {
3244 float* out = ZOUT(0);
3245 float* a = ZIN(0);
3246 float xb = ZIN0(1);
3247
3248 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa < xb ? 0.f : xa;);
3249 unit->mPrevB = xb;
3250 }
3251
3252
clip2_aa(BinaryOpUGen * unit,int inNumSamples)3253 void clip2_aa(BinaryOpUGen* unit, int inNumSamples) {
3254 float* out = ZOUT(0);
3255 float* a = ZIN(0);
3256 float* b = ZIN(1);
3257
3258 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa > xb ? xb : (xa < -xb ? -xb : xa););
3259 }
3260
clip2_ak(BinaryOpUGen * unit,int inNumSamples)3261 void clip2_ak(BinaryOpUGen* unit, int inNumSamples) {
3262 float* out = ZOUT(0);
3263 float* a = ZIN(0);
3264 float xb = unit->mPrevB;
3265 float next_b = ZIN0(1);
3266
3267 if (xb == next_b) {
3268 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa > xb ? xb : (xa < -xb ? -xb : xa););
3269 } else {
3270 float slope = CALCSLOPE(next_b, xb);
3271 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa > xb ? xb : (xa < -xb ? -xb : xa); xb += slope;);
3272 unit->mPrevB = xb;
3273 }
3274 }
3275
clip2_ka(BinaryOpUGen * unit,int inNumSamples)3276 void clip2_ka(BinaryOpUGen* unit, int inNumSamples) {
3277 float* out = ZOUT(0);
3278 float xa = unit->mPrevA;
3279 float* b = ZIN(1);
3280 float next_a = ZIN0(0);
3281
3282 if (xa == next_a) {
3283 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa > xb ? xb : (xa < -xb ? -xb : xa););
3284 } else {
3285 float slope = CALCSLOPE(next_a, xa);
3286 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa > xb ? xb : (xa < -xb ? -xb : xa); xa += slope;);
3287 unit->mPrevA = xa;
3288 }
3289 }
3290
clip2_ia(BinaryOpUGen * unit,int inNumSamples)3291 void clip2_ia(BinaryOpUGen* unit, int inNumSamples) {
3292 float* out = ZOUT(0);
3293 float xa = ZIN0(0);
3294 float* b = ZIN(1);
3295
3296 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa > xb ? xb : (xa < -xb ? -xb : xa););
3297 unit->mPrevA = xa;
3298 }
3299
3300
clip2_ai(BinaryOpUGen * unit,int inNumSamples)3301 void clip2_ai(BinaryOpUGen* unit, int inNumSamples) {
3302 float* out = ZOUT(0);
3303 float* a = ZIN(0);
3304 float xb = ZIN0(1);
3305
3306 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa > xb ? xb : (xa < -xb ? -xb : xa););
3307 unit->mPrevB = xb;
3308 }
3309
3310
3311 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(clip2,clip2)3312 NOVA_BINARY_WRAPPER_K(clip2, clip2)
3313 #endif
3314
3315
3316 void excess_aa(BinaryOpUGen* unit, int inNumSamples) {
3317 float* out = ZOUT(0);
3318 float* a = ZIN(0);
3319 float* b = ZIN(1);
3320
3321 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b);
3322 ZXP(out) = xa > xb ? xa - xb : (xa < -xb ? xa + xb : 0.f););
3323 }
3324
excess_ak(BinaryOpUGen * unit,int inNumSamples)3325 void excess_ak(BinaryOpUGen* unit, int inNumSamples) {
3326 float* out = ZOUT(0);
3327 float* a = ZIN(0);
3328 float xb = unit->mPrevB;
3329 float next_b = ZIN0(1);
3330
3331 if (xb == next_b) {
3332 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa > xb ? xa - xb : (xa < -xb ? xa + xb : 0.f););
3333 } else {
3334 float slope = CALCSLOPE(next_b, xb);
3335 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa > xb ? xa - xb : (xa < -xb ? xa + xb : 0.f); xb += slope;);
3336 unit->mPrevB = xb;
3337 }
3338 }
3339
excess_ka(BinaryOpUGen * unit,int inNumSamples)3340 void excess_ka(BinaryOpUGen* unit, int inNumSamples) {
3341 float* out = ZOUT(0);
3342 float xa = unit->mPrevA;
3343 float* b = ZIN(1);
3344 float next_a = ZIN0(0);
3345
3346 if (xa == next_a) {
3347 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa > xb ? xa - xb : (xa < -xb ? xa + xb : 0.f););
3348 } else {
3349 float slope = CALCSLOPE(next_a, xa);
3350 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa > xb ? xa - xb : (xa < -xb ? xa + xb : 0.f); xa += slope;);
3351 unit->mPrevA = xa;
3352 }
3353 }
3354
excess_ia(BinaryOpUGen * unit,int inNumSamples)3355 void excess_ia(BinaryOpUGen* unit, int inNumSamples) {
3356 float* out = ZOUT(0);
3357 float xa = ZIN0(0);
3358 float* b = ZIN(1);
3359
3360 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa > xb ? xa - xb : (xa < -xb ? xa + xb : 0.f););
3361 unit->mPrevA = xa;
3362 }
3363
excess_ai(BinaryOpUGen * unit,int inNumSamples)3364 void excess_ai(BinaryOpUGen* unit, int inNumSamples) {
3365 float* out = ZOUT(0);
3366 float* a = ZIN(0);
3367 float xb = ZIN0(1);
3368
3369 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa > xb ? xa - xb : (xa < -xb ? xa + xb : 0.f););
3370 unit->mPrevB = xb;
3371 }
3372
rrand_aa(BinaryOpUGen * unit,int inNumSamples)3373 void rrand_aa(BinaryOpUGen* unit, int inNumSamples) {
3374 float* out = ZOUT(0);
3375 float* a = ZIN(0);
3376 float* b = ZIN(1);
3377
3378 RGET
3379
3380 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b);
3381 ZXP(out) = xb > xa ? xa + frand2(s1, s2, s3) * (xb - xa) : (xb + frand2(s1, s2, s3) * (xa - xb)););
3382
3383 RPUT
3384 }
3385
rrand_ak(BinaryOpUGen * unit,int inNumSamples)3386 void rrand_ak(BinaryOpUGen* unit, int inNumSamples) {
3387 float* out = ZOUT(0);
3388 float* a = ZIN(0);
3389 float xb = unit->mPrevB;
3390 float next_b = ZIN0(1);
3391
3392 RGET
3393
3394 if (xb == next_b) {
3395 LOOP1(inNumSamples, float xa = ZXP(a);
3396 ZXP(out) = xb > xa ? xa + frand2(s1, s2, s3) * (xb - xa) : (xb + frand2(s1, s2, s3) * (xa - xb)););
3397 }
3398 else {
3399 float slope = CALCSLOPE(next_b, xb);
3400 LOOP1(inNumSamples, float xa = ZXP(a);
3401 ZXP(out) = xb > xa ? xa + frand2(s1, s2, s3) * (xb - xa) : (xb + frand2(s1, s2, s3) * (xa - xb));
3402 xb += slope;);
3403 unit->mPrevB = xb;
3404 }
3405
3406 RPUT
3407 }
3408
rrand_ka(BinaryOpUGen * unit,int inNumSamples)3409 void rrand_ka(BinaryOpUGen* unit, int inNumSamples) {
3410 float* out = ZOUT(0);
3411 float xa = unit->mPrevA;
3412 float* b = ZIN(1);
3413 float next_a = ZIN0(0);
3414
3415 RGET
3416
3417 if (xa == next_a) {
3418 LOOP1(inNumSamples, float xb = ZXP(b);
3419 ZXP(out) = xb > xa ? xa + frand2(s1, s2, s3) * (xb - xa) : (xb + frand2(s1, s2, s3) * (xa - xb)););
3420 }
3421 else {
3422 float slope = CALCSLOPE(next_a, xa);
3423 LOOP1(inNumSamples, float xb = ZXP(b);
3424 ZXP(out) = xb > xa ? xa + frand2(s1, s2, s3) * (xb - xa) : (xb + frand2(s1, s2, s3) * (xa - xb));
3425 xa += slope;);
3426 unit->mPrevA = xa;
3427 }
3428
3429 RPUT
3430 }
3431
rrand_ia(BinaryOpUGen * unit,int inNumSamples)3432 void rrand_ia(BinaryOpUGen* unit, int inNumSamples) {
3433 float* out = ZOUT(0);
3434 float xa = ZIN0(0);
3435 float* b = ZIN(1);
3436
3437 RGET
3438
3439 LOOP1(inNumSamples, float xb = ZXP(b);
3440 ZXP(out) = xb > xa ? xa + frand2(s1, s2, s3) * (xb - xa) : (xb + frand2(s1, s2, s3) * (xa - xb)););
3441 unit->mPrevA = xa;
3442
3443 RPUT
3444 }
3445
3446
rrand_ai(BinaryOpUGen * unit,int inNumSamples)3447 void rrand_ai(BinaryOpUGen* unit, int inNumSamples) {
3448 float* out = ZOUT(0);
3449 float* a = ZIN(0);
3450 float xb = ZIN0(1);
3451
3452 RGET
3453
3454 LOOP1(inNumSamples, float xa = ZXP(a);
3455 ZXP(out) = xb > xa ? xa + frand2(s1, s2, s3) * (xb - xa) : (xb + frand2(s1, s2, s3) * (xa - xb)););
3456
3457 RPUT
3458
3459 unit->mPrevB = xb;
3460 }
3461
3462
exprand_aa(BinaryOpUGen * unit,int inNumSamples)3463 void exprand_aa(BinaryOpUGen* unit, int inNumSamples) {
3464 float* out = ZOUT(0);
3465 float* a = ZIN(0);
3466 float* b = ZIN(1);
3467
3468 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); RGen& rgen = *unit->mParent->mRGen;
3469 ZXP(out) = xb > xa ? rgen.exprandrng(xa, xb) : rgen.exprandrng(xb, xa););
3470 }
3471
exprand_ak(BinaryOpUGen * unit,int inNumSamples)3472 void exprand_ak(BinaryOpUGen* unit, int inNumSamples) {
3473 float* out = ZOUT(0);
3474 float* a = ZIN(0);
3475 float xb = unit->mPrevB;
3476 float next_b = ZIN0(1);
3477 RGen& rgen = *unit->mParent->mRGen;
3478
3479 if (xb == next_b) {
3480 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xb > xa ? rgen.exprandrng(xa, xb) : rgen.exprandrng(xb, xa););
3481 } else {
3482 float slope = CALCSLOPE(next_b, xb);
3483 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xb > xa ? rgen.exprandrng(xa, xb) : rgen.exprandrng(xb, xa);
3484 xb += slope;);
3485 unit->mPrevB = xb;
3486 }
3487 }
3488
exprand_ka(BinaryOpUGen * unit,int inNumSamples)3489 void exprand_ka(BinaryOpUGen* unit, int inNumSamples) {
3490 float* out = ZOUT(0);
3491 float xa = unit->mPrevA;
3492 float* b = ZIN(1);
3493 float next_a = ZIN0(0);
3494 RGen& rgen = *unit->mParent->mRGen;
3495
3496 if (xa == next_a) {
3497 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xb > xa ? rgen.exprandrng(xa, xb) : rgen.exprandrng(xb, xa););
3498 } else {
3499 float slope = CALCSLOPE(next_a, xa);
3500 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xb > xa ? rgen.exprandrng(xa, xb) : rgen.exprandrng(xb, xa);
3501 xa += slope;);
3502 unit->mPrevA = xa;
3503 }
3504 }
3505
exprand_ia(BinaryOpUGen * unit,int inNumSamples)3506 void exprand_ia(BinaryOpUGen* unit, int inNumSamples) {
3507 float* out = ZOUT(0);
3508 float xa = ZIN0(0);
3509 float* b = ZIN(1);
3510
3511 LOOP1(inNumSamples, float xb = ZXP(b); RGen& rgen = *unit->mParent->mRGen;
3512 ZXP(out) = xb > xa ? rgen.exprandrng(xa, xb) : rgen.exprandrng(xb, xa););
3513 unit->mPrevA = xa;
3514 }
3515
3516
exprand_ai(BinaryOpUGen * unit,int inNumSamples)3517 void exprand_ai(BinaryOpUGen* unit, int inNumSamples) {
3518 float* out = ZOUT(0);
3519 float* a = ZIN(0);
3520 float xb = ZIN0(1);
3521
3522 LOOP1(inNumSamples, float xa = ZXP(a); RGen& rgen = *unit->mParent->mRGen;
3523 ZXP(out) = xb > xa ? rgen.exprandrng(xa, xb) : rgen.exprandrng(xb, xa););
3524 unit->mPrevB = xb;
3525 }
3526
3527
lt_aa(BinaryOpUGen * unit,int inNumSamples)3528 void lt_aa(BinaryOpUGen* unit, int inNumSamples) {
3529 float* out = ZOUT(0);
3530 float* a = ZIN(0);
3531 float* b = ZIN(1);
3532
3533 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa < xb ? 1.f : 0.f;);
3534 }
3535
3536 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(lt,less)3537 NOVA_BINARY_WRAPPER_K(lt, less)
3538 #endif
3539
3540
3541 void lt_ak(BinaryOpUGen* unit, int inNumSamples) {
3542 float* out = ZOUT(0);
3543 float* a = ZIN(0);
3544 float xb = unit->mPrevB;
3545 float next_b = ZIN0(1);
3546
3547 if (xb == next_b) {
3548 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa < xb ? 1.f : 0.f;);
3549 } else {
3550 float slope = CALCSLOPE(next_b, xb);
3551 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa < xb ? 1.f : 0.f; xb += slope;);
3552 unit->mPrevB = xb;
3553 }
3554 }
3555
lt_ka(BinaryOpUGen * unit,int inNumSamples)3556 void lt_ka(BinaryOpUGen* unit, int inNumSamples) {
3557 float* out = ZOUT(0);
3558 float xa = unit->mPrevA;
3559 float* b = ZIN(1);
3560 float next_a = ZIN0(0);
3561
3562 if (xa == next_a) {
3563 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa < xb ? 1.f : 0.f;);
3564 } else {
3565 float slope = CALCSLOPE(next_a, xa);
3566 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa < xb ? 1.f : 0.f; xa += slope;);
3567 unit->mPrevA = xa;
3568 }
3569 }
3570
lt_ia(BinaryOpUGen * unit,int inNumSamples)3571 void lt_ia(BinaryOpUGen* unit, int inNumSamples) {
3572 float* out = ZOUT(0);
3573 float xa = ZIN0(0);
3574 float* b = ZIN(1);
3575
3576 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa < xb ? 1.f : 0.f;);
3577 unit->mPrevA = xa;
3578 }
3579
3580
lt_ai(BinaryOpUGen * unit,int inNumSamples)3581 void lt_ai(BinaryOpUGen* unit, int inNumSamples) {
3582 float* out = ZOUT(0);
3583 float* a = ZIN(0);
3584 float xb = ZIN0(1);
3585
3586 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa < xb ? 1.f : 0.f;);
3587 unit->mPrevB = xb;
3588 }
3589
3590
le_aa(BinaryOpUGen * unit,int inNumSamples)3591 void le_aa(BinaryOpUGen* unit, int inNumSamples) {
3592 float* out = ZOUT(0);
3593 float* a = ZIN(0);
3594 float* b = ZIN(1);
3595
3596 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa <= xb ? 1.f : 0.f;);
3597 }
3598
3599 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(le,less_equal)3600 NOVA_BINARY_WRAPPER_K(le, less_equal)
3601 #endif
3602
3603 void le_ak(BinaryOpUGen* unit, int inNumSamples) {
3604 float* out = ZOUT(0);
3605 float* a = ZIN(0);
3606 float xb = unit->mPrevB;
3607 float next_b = ZIN0(1);
3608
3609 if (xb == next_b) {
3610 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa <= xb ? 1.f : 0.f;);
3611 } else {
3612 float slope = CALCSLOPE(next_b, xb);
3613 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa <= xb ? 1.f : 0.f; xb += slope;);
3614 unit->mPrevB = xb;
3615 }
3616 }
3617
le_ka(BinaryOpUGen * unit,int inNumSamples)3618 void le_ka(BinaryOpUGen* unit, int inNumSamples) {
3619 float* out = ZOUT(0);
3620 float xa = unit->mPrevA;
3621 float* b = ZIN(1);
3622 float next_a = ZIN0(0);
3623
3624 if (xa == next_a) {
3625 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa <= xb ? 1.f : 0.f;);
3626 } else {
3627 float slope = CALCSLOPE(next_a, xa);
3628 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa <= xb ? 1.f : 0.f; xa += slope;);
3629 unit->mPrevA = xa;
3630 }
3631 }
3632
le_ia(BinaryOpUGen * unit,int inNumSamples)3633 void le_ia(BinaryOpUGen* unit, int inNumSamples) {
3634 float* out = ZOUT(0);
3635 float xa = ZIN0(0);
3636 float* b = ZIN(1);
3637
3638 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa <= xb ? 1.f : 0.f;);
3639 unit->mPrevA = xa;
3640 }
3641
3642
le_ai(BinaryOpUGen * unit,int inNumSamples)3643 void le_ai(BinaryOpUGen* unit, int inNumSamples) {
3644 float* out = ZOUT(0);
3645 float* a = ZIN(0);
3646 float xb = ZIN0(1);
3647
3648 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa <= xb ? 1.f : 0.f;);
3649 unit->mPrevB = xb;
3650 }
3651
3652
gt_aa(BinaryOpUGen * unit,int inNumSamples)3653 void gt_aa(BinaryOpUGen* unit, int inNumSamples) {
3654 float* out = ZOUT(0);
3655 float* a = ZIN(0);
3656 float* b = ZIN(1);
3657
3658 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa > xb ? 1.f : 0.f;);
3659 }
3660
3661 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(gt,greater)3662 NOVA_BINARY_WRAPPER_K(gt, greater)
3663 #endif
3664
3665
3666 void gt_ak(BinaryOpUGen* unit, int inNumSamples) {
3667 float* out = ZOUT(0);
3668 float* a = ZIN(0);
3669 float xb = unit->mPrevB;
3670 float next_b = ZIN0(1);
3671
3672 if (xb == next_b) {
3673 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa > xb ? 1.f : 0.f;);
3674 } else {
3675 float slope = CALCSLOPE(next_b, xb);
3676 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa > xb ? 1.f : 0.f; xb += slope;);
3677 unit->mPrevB = xb;
3678 }
3679 }
3680
gt_ka(BinaryOpUGen * unit,int inNumSamples)3681 void gt_ka(BinaryOpUGen* unit, int inNumSamples) {
3682 float* out = ZOUT(0);
3683 float xa = unit->mPrevA;
3684 float* b = ZIN(1);
3685 float next_a = ZIN0(0);
3686
3687 if (xa == next_a) {
3688 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa > xb ? 1.f : 0.f;);
3689 } else {
3690 float slope = CALCSLOPE(next_a, xa);
3691 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa > xb ? 1.f : 0.f; xa += slope;);
3692 unit->mPrevA = xa;
3693 }
3694 }
3695
gt_ia(BinaryOpUGen * unit,int inNumSamples)3696 void gt_ia(BinaryOpUGen* unit, int inNumSamples) {
3697 float* out = ZOUT(0);
3698 float xa = ZIN0(0);
3699 float* b = ZIN(1);
3700
3701 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa > xb ? 1.f : 0.f;);
3702 unit->mPrevA = xa;
3703 }
3704
3705
gt_ai(BinaryOpUGen * unit,int inNumSamples)3706 void gt_ai(BinaryOpUGen* unit, int inNumSamples) {
3707 float* out = ZOUT(0);
3708 float* a = ZIN(0);
3709 float xb = ZIN0(1);
3710
3711 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa > xb ? 1.f : 0.f;);
3712 unit->mPrevB = xb;
3713 }
3714
3715
ge_aa(BinaryOpUGen * unit,int inNumSamples)3716 void ge_aa(BinaryOpUGen* unit, int inNumSamples) {
3717 float* out = ZOUT(0);
3718 float* a = ZIN(0);
3719 float* b = ZIN(1);
3720
3721 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa >= xb ? 1.f : 0.f;);
3722 }
3723
3724 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(ge,greater_equal)3725 NOVA_BINARY_WRAPPER_K(ge, greater_equal)
3726 #endif
3727
3728
3729 void ge_ak(BinaryOpUGen* unit, int inNumSamples) {
3730 float* out = ZOUT(0);
3731 float* a = ZIN(0);
3732 float xb = unit->mPrevB;
3733 float next_b = ZIN0(1);
3734
3735 if (xb == next_b) {
3736 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa >= xb ? 1.f : 0.f;);
3737 } else {
3738 float slope = CALCSLOPE(next_b, xb);
3739 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa >= xb ? 1.f : 0.f; xb += slope;);
3740 unit->mPrevB = xb;
3741 }
3742 }
3743
ge_ka(BinaryOpUGen * unit,int inNumSamples)3744 void ge_ka(BinaryOpUGen* unit, int inNumSamples) {
3745 float* out = ZOUT(0);
3746 float xa = unit->mPrevA;
3747 float* b = ZIN(1);
3748 float next_a = ZIN0(0);
3749
3750 if (xa == next_a) {
3751 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa >= xb ? 1.f : 0.f;);
3752 } else {
3753 float slope = CALCSLOPE(next_a, xa);
3754 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa >= xb ? 1.f : 0.f; xa += slope;);
3755 unit->mPrevA = xa;
3756 }
3757 }
3758
ge_ia(BinaryOpUGen * unit,int inNumSamples)3759 void ge_ia(BinaryOpUGen* unit, int inNumSamples) {
3760 float* out = ZOUT(0);
3761 float xa = ZIN0(0);
3762 float* b = ZIN(1);
3763
3764 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa >= xb ? 1.f : 0.f;);
3765 unit->mPrevA = xa;
3766 }
3767
3768
ge_ai(BinaryOpUGen * unit,int inNumSamples)3769 void ge_ai(BinaryOpUGen* unit, int inNumSamples) {
3770 float* out = ZOUT(0);
3771 float* a = ZIN(0);
3772 float xb = ZIN0(1);
3773
3774 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa >= xb ? 1.f : 0.f;);
3775 unit->mPrevB = xb;
3776 }
3777
3778
eq_aa(BinaryOpUGen * unit,int inNumSamples)3779 void eq_aa(BinaryOpUGen* unit, int inNumSamples) {
3780 float* out = ZOUT(0);
3781 float* a = ZIN(0);
3782 float* b = ZIN(1);
3783
3784 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa == xb ? 1.f : 0.f;);
3785 }
3786
3787 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(eq,equal)3788 NOVA_BINARY_WRAPPER_K(eq, equal)
3789 #endif
3790
3791 void eq_ak(BinaryOpUGen* unit, int inNumSamples) {
3792 float* out = ZOUT(0);
3793 float* a = ZIN(0);
3794 float xb = unit->mPrevB;
3795 float next_b = ZIN0(1);
3796
3797 if (xb == next_b) {
3798 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa == xb ? 1.f : 0.f;);
3799 } else {
3800 float slope = CALCSLOPE(next_b, xb);
3801 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa == xb ? 1.f : 0.f; xb += slope;);
3802 unit->mPrevB = xb;
3803 }
3804 }
3805
eq_ka(BinaryOpUGen * unit,int inNumSamples)3806 void eq_ka(BinaryOpUGen* unit, int inNumSamples) {
3807 float* out = ZOUT(0);
3808 float xa = unit->mPrevA;
3809 float* b = ZIN(1);
3810 float next_a = ZIN0(0);
3811
3812 if (xa == next_a) {
3813 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa == xb ? 1.f : 0.f;);
3814 } else {
3815 float slope = CALCSLOPE(next_a, xa);
3816 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa == xb ? 1.f : 0.f; xa += slope;);
3817 unit->mPrevA = xa;
3818 }
3819 }
3820
eq_ia(BinaryOpUGen * unit,int inNumSamples)3821 void eq_ia(BinaryOpUGen* unit, int inNumSamples) {
3822 float* out = ZOUT(0);
3823 float xa = ZIN0(0);
3824 float* b = ZIN(1);
3825
3826 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa == xb ? 1.f : 0.f;);
3827 unit->mPrevA = xa;
3828 }
3829
3830
eq_ai(BinaryOpUGen * unit,int inNumSamples)3831 void eq_ai(BinaryOpUGen* unit, int inNumSamples) {
3832 float* out = ZOUT(0);
3833 float* a = ZIN(0);
3834 float xb = ZIN0(1);
3835
3836 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa == xb ? 1.f : 0.f;);
3837 unit->mPrevB = xb;
3838 }
3839
3840
neq_aa(BinaryOpUGen * unit,int inNumSamples)3841 void neq_aa(BinaryOpUGen* unit, int inNumSamples) {
3842 float* out = ZOUT(0);
3843 float* a = ZIN(0);
3844 float* b = ZIN(1);
3845
3846 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa != xb ? 1.f : 0.f;);
3847 }
3848
3849 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(neq,notequal)3850 NOVA_BINARY_WRAPPER_K(neq, notequal)
3851 #endif
3852
3853
3854 void neq_ak(BinaryOpUGen* unit, int inNumSamples) {
3855 float* out = ZOUT(0);
3856 float* a = ZIN(0);
3857 float xb = unit->mPrevB;
3858 float next_b = ZIN0(1);
3859
3860 if (xb == next_b) {
3861 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa != xb ? 1.f : 0.f;);
3862 } else {
3863 float slope = CALCSLOPE(next_b, xb);
3864 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa != xb ? 1.f : 0.f; xb += slope;);
3865 unit->mPrevB = xb;
3866 }
3867 }
3868
neq_ka(BinaryOpUGen * unit,int inNumSamples)3869 void neq_ka(BinaryOpUGen* unit, int inNumSamples) {
3870 float* out = ZOUT(0);
3871 float xa = unit->mPrevA;
3872 float* b = ZIN(1);
3873 float next_a = ZIN0(0);
3874
3875 if (xa == next_a) {
3876 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa != xb ? 1.f : 0.f;);
3877 } else {
3878 float slope = CALCSLOPE(next_a, xa);
3879 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa != xb ? 1.f : 0.f; xa += slope;);
3880 unit->mPrevA = xa;
3881 }
3882 }
3883
neq_ia(BinaryOpUGen * unit,int inNumSamples)3884 void neq_ia(BinaryOpUGen* unit, int inNumSamples) {
3885 float* out = ZOUT(0);
3886 float xa = ZIN0(0);
3887 float* b = ZIN(1);
3888
3889 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa != xb ? 1.f : 0.f;);
3890 unit->mPrevA = xa;
3891 }
3892
3893
neq_ai(BinaryOpUGen * unit,int inNumSamples)3894 void neq_ai(BinaryOpUGen* unit, int inNumSamples) {
3895 float* out = ZOUT(0);
3896 float* a = ZIN(0);
3897 float xb = ZIN0(1);
3898
3899 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa != xb ? 1.f : 0.f;);
3900 unit->mPrevB = xb;
3901 }
3902
3903 #ifdef NOVA_SIMD
NOVA_BINARY_WRAPPER_K(sumsqr,sc_sumsqr)3904 NOVA_BINARY_WRAPPER_K(sumsqr, sc_sumsqr)
3905 NOVA_BINARY_WRAPPER_K(difsqr, sc_difsqr)
3906 NOVA_BINARY_WRAPPER_K(sqrsum, sc_sqrsum)
3907 NOVA_BINARY_WRAPPER_K(sqrdif, sc_sqrdif)
3908 #endif
3909
3910 void sumsqr_aa(BinaryOpUGen* unit, int inNumSamples) {
3911 float* out = ZOUT(0);
3912 float* a = ZIN(0);
3913 float* b = ZIN(1);
3914
3915 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa * xa + xb * xb;);
3916 }
3917
sumsqr_ak(BinaryOpUGen * unit,int inNumSamples)3918 void sumsqr_ak(BinaryOpUGen* unit, int inNumSamples) {
3919 float* out = ZOUT(0);
3920 float* a = ZIN(0);
3921 float xb = unit->mPrevB;
3922 float next_b = ZIN0(1);
3923
3924 if (xb == next_b) {
3925 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa + xb * xb;);
3926 } else {
3927 float slope = CALCSLOPE(next_b, xb);
3928 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa + xb * xb; xb += slope;);
3929 unit->mPrevB = xb;
3930 }
3931 }
3932
sumsqr_ka(BinaryOpUGen * unit,int inNumSamples)3933 void sumsqr_ka(BinaryOpUGen* unit, int inNumSamples) {
3934 float* out = ZOUT(0);
3935 float xa = unit->mPrevA;
3936 float* b = ZIN(1);
3937 float next_a = ZIN0(0);
3938
3939 if (xa == next_a) {
3940 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa + xb * xb;);
3941 } else {
3942 float slope = CALCSLOPE(next_a, xa);
3943 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa + xb * xb; xa += slope;);
3944 unit->mPrevA = xa;
3945 }
3946 }
3947
3948
sumsqr_ia(BinaryOpUGen * unit,int inNumSamples)3949 void sumsqr_ia(BinaryOpUGen* unit, int inNumSamples) {
3950 float* out = ZOUT(0);
3951 float xa = ZIN0(0);
3952 float* b = ZIN(1);
3953
3954 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa + xb * xb;);
3955 unit->mPrevA = xa;
3956 }
3957
3958
sumsqr_ai(BinaryOpUGen * unit,int inNumSamples)3959 void sumsqr_ai(BinaryOpUGen* unit, int inNumSamples) {
3960 float* out = ZOUT(0);
3961 float* a = ZIN(0);
3962 float xb = ZIN0(1);
3963
3964 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa + xb * xb;);
3965 unit->mPrevB = xb;
3966 }
3967
3968
difsqr_aa(BinaryOpUGen * unit,int inNumSamples)3969 void difsqr_aa(BinaryOpUGen* unit, int inNumSamples) {
3970 float* out = ZOUT(0);
3971 float* a = ZIN(0);
3972 float* b = ZIN(1);
3973
3974 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = xa * xa - xb * xb;);
3975 }
3976
difsqr_ak(BinaryOpUGen * unit,int inNumSamples)3977 void difsqr_ak(BinaryOpUGen* unit, int inNumSamples) {
3978 float* out = ZOUT(0);
3979 float* a = ZIN(0);
3980 float xb = unit->mPrevB;
3981 float next_b = ZIN0(1);
3982
3983 if (xb == next_b) {
3984 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa - xb * xb;);
3985 } else {
3986 float slope = CALCSLOPE(next_b, xb);
3987 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa - xb * xb; xb += slope;);
3988 unit->mPrevB = xb;
3989 }
3990 }
3991
difsqr_ka(BinaryOpUGen * unit,int inNumSamples)3992 void difsqr_ka(BinaryOpUGen* unit, int inNumSamples) {
3993 float* out = ZOUT(0);
3994 float xa = unit->mPrevA;
3995 float* b = ZIN(1);
3996 float next_a = ZIN0(0);
3997
3998 if (xa == next_a) {
3999 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa - xb * xb;);
4000 } else {
4001 float slope = CALCSLOPE(next_a, xa);
4002 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa - xb * xb; xa += slope;);
4003 unit->mPrevA = xa;
4004 }
4005 }
4006
difsqr_ia(BinaryOpUGen * unit,int inNumSamples)4007 void difsqr_ia(BinaryOpUGen* unit, int inNumSamples) {
4008 float* out = ZOUT(0);
4009 float xa = ZIN0(0);
4010 float* b = ZIN(1);
4011
4012 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = xa * xa - xb * xb;);
4013 unit->mPrevA = xa;
4014 }
4015
4016
difsqr_ai(BinaryOpUGen * unit,int inNumSamples)4017 void difsqr_ai(BinaryOpUGen* unit, int inNumSamples) {
4018 float* out = ZOUT(0);
4019 float* a = ZIN(0);
4020 float xb = ZIN0(1);
4021
4022 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = xa * xa - xb * xb;);
4023 unit->mPrevB = xb;
4024 }
4025
4026
sqrsum_aa(BinaryOpUGen * unit,int inNumSamples)4027 void sqrsum_aa(BinaryOpUGen* unit, int inNumSamples) {
4028 float* out = ZOUT(0);
4029 float* a = ZIN(0);
4030 float* b = ZIN(1);
4031
4032 LOOP1(inNumSamples, float sum = ZXP(a) + ZXP(b); ZXP(out) = sum * sum;);
4033 }
4034
sqrsum_ak(BinaryOpUGen * unit,int inNumSamples)4035 void sqrsum_ak(BinaryOpUGen* unit, int inNumSamples) {
4036 float* out = ZOUT(0);
4037 float* a = ZIN(0);
4038 float xb = unit->mPrevB;
4039 float next_b = ZIN0(1);
4040
4041 if (xb == next_b) {
4042 LOOP1(inNumSamples, float xa = ZXP(a); float sum = xa + xb; ZXP(out) = sum * sum;);
4043 } else {
4044 float slope = CALCSLOPE(next_b, xb);
4045 LOOP1(inNumSamples, float xa = ZXP(a); float sum = xa + xb; ZXP(out) = sum * sum; xb += slope;);
4046 unit->mPrevB = xb;
4047 }
4048 }
4049
sqrsum_ka(BinaryOpUGen * unit,int inNumSamples)4050 void sqrsum_ka(BinaryOpUGen* unit, int inNumSamples) {
4051 float* out = ZOUT(0);
4052 float xa = unit->mPrevA;
4053 float* b = ZIN(1);
4054 float next_a = ZIN0(0);
4055
4056 if (xa == next_a) {
4057 LOOP1(inNumSamples, float xb = ZXP(b); float sum = xa + xb; ZXP(out) = sum * sum;);
4058 } else {
4059 float slope = CALCSLOPE(next_a, xa);
4060 LOOP1(inNumSamples, float xb = ZXP(b); float sum = xa + xb; ZXP(out) = sum * sum; xa += slope;);
4061 unit->mPrevA = xa;
4062 }
4063 }
4064
sqrsum_ia(BinaryOpUGen * unit,int inNumSamples)4065 void sqrsum_ia(BinaryOpUGen* unit, int inNumSamples) {
4066 float* out = ZOUT(0);
4067 float xa = ZIN0(0);
4068 float* b = ZIN(1);
4069
4070 LOOP1(inNumSamples, float xb = ZXP(b); float sum = xa + xb; ZXP(out) = sum * sum;);
4071 unit->mPrevA = xa;
4072 }
4073
4074
sqrsum_ai(BinaryOpUGen * unit,int inNumSamples)4075 void sqrsum_ai(BinaryOpUGen* unit, int inNumSamples) {
4076 float* out = ZOUT(0);
4077 float* a = ZIN(0);
4078 float xb = ZIN0(1);
4079
4080 LOOP1(inNumSamples, float xa = ZXP(a); float sum = xa + xb; ZXP(out) = sum * sum;);
4081 unit->mPrevB = xb;
4082 }
4083
4084
sqrdif_aa(BinaryOpUGen * unit,int inNumSamples)4085 void sqrdif_aa(BinaryOpUGen* unit, int inNumSamples) {
4086 float* out = ZOUT(0);
4087 float* a = ZIN(0);
4088 float* b = ZIN(1);
4089
4090 LOOP1(inNumSamples, float dif = ZXP(a) - ZXP(b); ZXP(out) = dif * dif;);
4091 }
4092
sqrdif_ak(BinaryOpUGen * unit,int inNumSamples)4093 void sqrdif_ak(BinaryOpUGen* unit, int inNumSamples) {
4094 float* out = ZOUT(0);
4095 float* a = ZIN(0);
4096 float xb = unit->mPrevB;
4097 float next_b = ZIN0(1);
4098
4099 if (xb == next_b) {
4100 LOOP1(inNumSamples, float xa = ZXP(a); float dif = xa - xb; ZXP(out) = dif * dif;);
4101 } else {
4102 float slope = CALCSLOPE(next_b, xb);
4103 LOOP1(inNumSamples, float xa = ZXP(a); float dif = xa - xb; ZXP(out) = dif * dif; xb += slope;);
4104 unit->mPrevB = xb;
4105 }
4106 }
4107
sqrdif_ka(BinaryOpUGen * unit,int inNumSamples)4108 void sqrdif_ka(BinaryOpUGen* unit, int inNumSamples) {
4109 float* out = ZOUT(0);
4110 float xa = unit->mPrevA;
4111 float* b = ZIN(1);
4112 float next_a = ZIN0(0);
4113
4114 if (xa == next_a) {
4115 LOOP1(inNumSamples, float xb = ZXP(b); float dif = xa - xb; ZXP(out) = dif * dif;);
4116 } else {
4117 float slope = CALCSLOPE(next_a, xa);
4118 LOOP1(inNumSamples, float xb = ZXP(b); float dif = xa - xb; ZXP(out) = dif * dif; xa += slope;);
4119 unit->mPrevA = xa;
4120 }
4121 }
4122
4123
sqrdif_ia(BinaryOpUGen * unit,int inNumSamples)4124 void sqrdif_ia(BinaryOpUGen* unit, int inNumSamples) {
4125 float* out = ZOUT(0);
4126 float xa = ZIN0(0);
4127 float* b = ZIN(1);
4128
4129 LOOP1(inNumSamples, float xb = ZXP(b); float dif = xa - xb; ZXP(out) = dif * dif;);
4130 unit->mPrevA = xa;
4131 }
4132
4133
sqrdif_ai(BinaryOpUGen * unit,int inNumSamples)4134 void sqrdif_ai(BinaryOpUGen* unit, int inNumSamples) {
4135 float* out = ZOUT(0);
4136 float* a = ZIN(0);
4137 float xb = ZIN0(1);
4138
4139 LOOP1(inNumSamples, float xa = ZXP(a); float dif = xa - xb; ZXP(out) = dif * dif;);
4140 unit->mPrevB = xb;
4141 }
4142
4143
absdif_aa(BinaryOpUGen * unit,int inNumSamples)4144 void absdif_aa(BinaryOpUGen* unit, int inNumSamples) {
4145 float* out = ZOUT(0);
4146 float* a = ZIN(0);
4147 float* b = ZIN(1);
4148
4149 LOOP1(inNumSamples, float dif = ZXP(a) - ZXP(b); ZXP(out) = fabs(dif););
4150 }
4151
absdif_ak(BinaryOpUGen * unit,int inNumSamples)4152 void absdif_ak(BinaryOpUGen* unit, int inNumSamples) {
4153 float* out = ZOUT(0);
4154 float* a = ZIN(0);
4155 float xb = unit->mPrevB;
4156 float next_b = ZIN0(1);
4157
4158 if (xb == next_b) {
4159 LOOP1(inNumSamples, float xa = ZXP(a); float dif = xa - xb; ZXP(out) = fabs(dif););
4160 } else {
4161 float slope = CALCSLOPE(next_b, xb);
4162 LOOP1(inNumSamples, float xa = ZXP(a); float dif = xa - xb; ZXP(out) = fabs(dif); xb += slope;);
4163 unit->mPrevB = xb;
4164 }
4165 }
4166
absdif_ka(BinaryOpUGen * unit,int inNumSamples)4167 void absdif_ka(BinaryOpUGen* unit, int inNumSamples) {
4168 float* out = ZOUT(0);
4169 float xa = unit->mPrevA;
4170 float* b = ZIN(1);
4171 float next_a = ZIN0(0);
4172
4173 if (xa == next_a) {
4174 LOOP1(inNumSamples, float xb = ZXP(b); float dif = xa - xb; ZXP(out) = fabs(dif););
4175 } else {
4176 float slope = CALCSLOPE(next_a, xa);
4177 LOOP1(inNumSamples, float xb = ZXP(b); float dif = xa - xb; ZXP(out) = fabs(dif); xa += slope;);
4178 unit->mPrevA = xa;
4179 }
4180 }
4181
absdif_ia(BinaryOpUGen * unit,int inNumSamples)4182 void absdif_ia(BinaryOpUGen* unit, int inNumSamples) {
4183 float* out = ZOUT(0);
4184 float xa = ZIN0(0);
4185 float* b = ZIN(1);
4186
4187 LOOP1(inNumSamples, float xb = ZXP(b); float dif = xa - xb; ZXP(out) = fabs(dif););
4188 unit->mPrevA = xa;
4189 }
4190
4191
absdif_ai(BinaryOpUGen * unit,int inNumSamples)4192 void absdif_ai(BinaryOpUGen* unit, int inNumSamples) {
4193 float* out = ZOUT(0);
4194 float* a = ZIN(0);
4195 float xb = ZIN0(1);
4196
4197 LOOP1(inNumSamples, float xa = ZXP(a); float dif = xa - xb; ZXP(out) = fabs(dif););
4198 unit->mPrevB = xb;
4199 }
4200
4201
round_aa(BinaryOpUGen * unit,int inNumSamples)4202 void round_aa(BinaryOpUGen* unit, int inNumSamples) {
4203 float* out = ZOUT(0);
4204 float* a = ZIN(0);
4205 float* b = ZIN(1);
4206
4207 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_round(xa, xb););
4208 }
4209
round_ak(BinaryOpUGen * unit,int inNumSamples)4210 void round_ak(BinaryOpUGen* unit, int inNumSamples) {
4211 float* out = ZOUT(0);
4212 float* a = ZIN(0);
4213 float xb = unit->mPrevB;
4214 float next_b = ZIN0(1);
4215
4216 if (xb == next_b) {
4217 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_round(xa, xb););
4218 } else {
4219 float slope = CALCSLOPE(next_b, xb);
4220 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_round(xa, xb); xb += slope;);
4221 unit->mPrevB = xb;
4222 }
4223 }
4224
round_ka(BinaryOpUGen * unit,int inNumSamples)4225 void round_ka(BinaryOpUGen* unit, int inNumSamples) {
4226 float* out = ZOUT(0);
4227 float xa = unit->mPrevA;
4228 float* b = ZIN(1);
4229 float next_a = ZIN0(0);
4230
4231 if (xa == next_a) {
4232 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_round(xa, xb););
4233 } else {
4234 float slope = CALCSLOPE(next_a, xa);
4235 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_round(xa, xb); xa += slope;);
4236 unit->mPrevA = xa;
4237 }
4238 }
4239
4240
round_ia(BinaryOpUGen * unit,int inNumSamples)4241 void round_ia(BinaryOpUGen* unit, int inNumSamples) {
4242 float* out = ZOUT(0);
4243 float xa = ZIN0(0);
4244 float* b = ZIN(1);
4245
4246 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_round(xa, xb););
4247 unit->mPrevA = xa;
4248 }
4249
4250
round_ai(BinaryOpUGen * unit,int inNumSamples)4251 void round_ai(BinaryOpUGen* unit, int inNumSamples) {
4252 float* out = ZOUT(0);
4253 float* a = ZIN(0);
4254 float xb = ZIN0(1);
4255
4256 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_round(xa, xb););
4257 unit->mPrevB = xb;
4258 }
4259
4260
roundUp_aa(BinaryOpUGen * unit,int inNumSamples)4261 void roundUp_aa(BinaryOpUGen* unit, int inNumSamples) {
4262 float* out = ZOUT(0);
4263 float* a = ZIN(0);
4264 float* b = ZIN(1);
4265
4266 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_roundUp(xa, xb););
4267 }
4268
roundUp_ak(BinaryOpUGen * unit,int inNumSamples)4269 void roundUp_ak(BinaryOpUGen* unit, int inNumSamples) {
4270 float* out = ZOUT(0);
4271 float* a = ZIN(0);
4272 float xb = unit->mPrevB;
4273 float next_b = ZIN0(1);
4274
4275 if (xb == next_b) {
4276 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_roundUp(xa, xb););
4277 } else {
4278 float slope = CALCSLOPE(next_b, xb);
4279 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_roundUp(xa, xb); xb += slope;);
4280 unit->mPrevB = xb;
4281 }
4282 }
4283
roundUp_ka(BinaryOpUGen * unit,int inNumSamples)4284 void roundUp_ka(BinaryOpUGen* unit, int inNumSamples) {
4285 float* out = ZOUT(0);
4286 float xa = unit->mPrevA;
4287 float* b = ZIN(1);
4288 float next_a = ZIN0(0);
4289
4290 if (xa == next_a) {
4291 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_roundUp(xa, xb););
4292 } else {
4293 float slope = CALCSLOPE(next_a, xa);
4294 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_roundUp(xa, xb); xa += slope;);
4295 unit->mPrevA = xa;
4296 }
4297 }
4298
4299
roundUp_ia(BinaryOpUGen * unit,int inNumSamples)4300 void roundUp_ia(BinaryOpUGen* unit, int inNumSamples) {
4301 float* out = ZOUT(0);
4302 float xa = ZIN0(0);
4303 float* b = ZIN(1);
4304
4305 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_roundUp(xa, xb););
4306 unit->mPrevA = xa;
4307 }
4308
4309
roundUp_ai(BinaryOpUGen * unit,int inNumSamples)4310 void roundUp_ai(BinaryOpUGen* unit, int inNumSamples) {
4311 float* out = ZOUT(0);
4312 float* a = ZIN(0);
4313 float xb = ZIN0(1);
4314
4315 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_roundUp(xa, xb););
4316 unit->mPrevB = xb;
4317 }
4318
4319
trunc_aa(BinaryOpUGen * unit,int inNumSamples)4320 void trunc_aa(BinaryOpUGen* unit, int inNumSamples) {
4321 float* out = ZOUT(0);
4322 float* a = ZIN(0);
4323 float* b = ZIN(1);
4324
4325 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_trunc(xa, xb););
4326 }
4327
trunc_ak(BinaryOpUGen * unit,int inNumSamples)4328 void trunc_ak(BinaryOpUGen* unit, int inNumSamples) {
4329 float* out = ZOUT(0);
4330 float* a = ZIN(0);
4331 float xb = unit->mPrevB;
4332 float next_b = ZIN0(1);
4333
4334 if (xb == next_b) {
4335 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_trunc(xa, xb););
4336 } else {
4337 float slope = CALCSLOPE(next_b, xb);
4338 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_trunc(xa, xb); xb += slope;);
4339 unit->mPrevB = xb;
4340 }
4341 }
4342
trunc_ka(BinaryOpUGen * unit,int inNumSamples)4343 void trunc_ka(BinaryOpUGen* unit, int inNumSamples) {
4344 float* out = ZOUT(0);
4345 float xa = unit->mPrevA;
4346 float* b = ZIN(1);
4347 float next_a = ZIN0(0);
4348
4349 if (xa == next_a) {
4350 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_trunc(xa, xb););
4351 } else {
4352 float slope = CALCSLOPE(next_a, xa);
4353 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_trunc(xa, xb); xa += slope;);
4354 unit->mPrevA = xa;
4355 }
4356 }
4357
trunc_ia(BinaryOpUGen * unit,int inNumSamples)4358 void trunc_ia(BinaryOpUGen* unit, int inNumSamples) {
4359 float* out = ZOUT(0);
4360 float xa = ZIN0(0);
4361 float* b = ZIN(1);
4362
4363 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_trunc(xa, xb););
4364 unit->mPrevA = xa;
4365 }
4366
4367
trunc_ai(BinaryOpUGen * unit,int inNumSamples)4368 void trunc_ai(BinaryOpUGen* unit, int inNumSamples) {
4369 float* out = ZOUT(0);
4370 float* a = ZIN(0);
4371 float xb = ZIN0(1);
4372
4373 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_trunc(xa, xb););
4374 unit->mPrevB = xb;
4375 }
4376
4377
fold2_aa(BinaryOpUGen * unit,int inNumSamples)4378 void fold2_aa(BinaryOpUGen* unit, int inNumSamples) {
4379 float* out = ZOUT(0);
4380 float* a = ZIN(0);
4381 float* b = ZIN(1);
4382
4383 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_fold(xa, -xb, xb););
4384 }
4385
fold2_ak(BinaryOpUGen * unit,int inNumSamples)4386 void fold2_ak(BinaryOpUGen* unit, int inNumSamples) {
4387 float* out = ZOUT(0);
4388 float* a = ZIN(0);
4389 float xb = unit->mPrevB;
4390 float next_b = ZIN0(1);
4391
4392 if (xb == next_b) {
4393 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_fold(xa, -xb, xb););
4394 } else {
4395 float slope = CALCSLOPE(next_b, xb);
4396 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_fold(xa, -xb, xb); xb += slope;);
4397 unit->mPrevB = xb;
4398 }
4399 }
4400
fold2_ka(BinaryOpUGen * unit,int inNumSamples)4401 void fold2_ka(BinaryOpUGen* unit, int inNumSamples) {
4402 float* out = ZOUT(0);
4403 float xa = unit->mPrevA;
4404 float* b = ZIN(1);
4405 float next_a = ZIN0(0);
4406
4407 if (xa == next_a) {
4408 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_fold(xa, -xb, xb););
4409 } else {
4410 float slope = CALCSLOPE(next_a, xa);
4411 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_fold(xa, -xb, xb); xa += slope;);
4412 unit->mPrevA = xa;
4413 }
4414 }
4415
fold2_ia(BinaryOpUGen * unit,int inNumSamples)4416 void fold2_ia(BinaryOpUGen* unit, int inNumSamples) {
4417 float* out = ZOUT(0);
4418 float xa = ZIN0(0);
4419 float* b = ZIN(1);
4420
4421 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_fold(xa, -xb, xb););
4422 unit->mPrevA = xa;
4423 }
4424
4425
fold2_ai(BinaryOpUGen * unit,int inNumSamples)4426 void fold2_ai(BinaryOpUGen* unit, int inNumSamples) {
4427 float* out = ZOUT(0);
4428 float* a = ZIN(0);
4429 float xb = ZIN0(1);
4430
4431 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_fold(xa, -xb, xb););
4432 unit->mPrevB = xb;
4433 }
4434
4435
wrap2_aa(BinaryOpUGen * unit,int inNumSamples)4436 void wrap2_aa(BinaryOpUGen* unit, int inNumSamples) {
4437 float* out = ZOUT(0);
4438 float* a = ZIN(0);
4439 float* b = ZIN(1);
4440
4441 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_wrap(xa, -xb, xb););
4442 }
4443
wrap2_ak(BinaryOpUGen * unit,int inNumSamples)4444 void wrap2_ak(BinaryOpUGen* unit, int inNumSamples) {
4445 float* out = ZOUT(0);
4446 float* a = ZIN(0);
4447 float xb = unit->mPrevB;
4448 float next_b = ZIN0(1);
4449
4450 if (xb == next_b) {
4451 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_wrap(xa, -xb, xb););
4452 } else {
4453 float slope = CALCSLOPE(next_b, xb);
4454 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_wrap(xa, -xb, xb); xb += slope;);
4455 unit->mPrevB = xb;
4456 }
4457 }
4458
wrap2_ka(BinaryOpUGen * unit,int inNumSamples)4459 void wrap2_ka(BinaryOpUGen* unit, int inNumSamples) {
4460 float* out = ZOUT(0);
4461 float xa = unit->mPrevA;
4462 float* b = ZIN(1);
4463 float next_a = ZIN0(0);
4464
4465 if (xa == next_a) {
4466 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_wrap(xa, -xb, xb););
4467 } else {
4468 float slope = CALCSLOPE(next_a, xa);
4469 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_wrap(xa, -xb, xb); xa += slope;);
4470 unit->mPrevA = xa;
4471 }
4472 }
4473
wrap2_ia(BinaryOpUGen * unit,int inNumSamples)4474 void wrap2_ia(BinaryOpUGen* unit, int inNumSamples) {
4475 float* out = ZOUT(0);
4476 float xa = ZIN0(0);
4477 float* b = ZIN(1);
4478
4479 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_wrap(xa, -xb, xb););
4480 unit->mPrevA = xa;
4481 }
4482
4483
wrap2_ai(BinaryOpUGen * unit,int inNumSamples)4484 void wrap2_ai(BinaryOpUGen* unit, int inNumSamples) {
4485 float* out = ZOUT(0);
4486 float* a = ZIN(0);
4487 float xb = ZIN0(1);
4488
4489 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_wrap(xa, -xb, xb););
4490 unit->mPrevB = xb;
4491 }
4492
4493
atan2_aa(BinaryOpUGen * unit,int inNumSamples)4494 void atan2_aa(BinaryOpUGen* unit, int inNumSamples) {
4495 float* out = ZOUT(0);
4496 float* a = ZIN(0);
4497 float* b = ZIN(1);
4498
4499 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = atan2(xa, xb););
4500 }
4501
atan2_ak(BinaryOpUGen * unit,int inNumSamples)4502 void atan2_ak(BinaryOpUGen* unit, int inNumSamples) {
4503 float* out = ZOUT(0);
4504 float* a = ZIN(0);
4505 float xb = unit->mPrevB;
4506 float next_b = ZIN0(1);
4507
4508 if (xb == next_b) {
4509 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = atan2(xa, xb););
4510 } else {
4511 float slope = CALCSLOPE(next_b, xb);
4512 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = atan2(xa, xb); xb += slope;);
4513 unit->mPrevB = xb;
4514 }
4515 }
4516
atan2_ka(BinaryOpUGen * unit,int inNumSamples)4517 void atan2_ka(BinaryOpUGen* unit, int inNumSamples) {
4518 float* out = ZOUT(0);
4519 float xa = unit->mPrevA;
4520 float* b = ZIN(1);
4521 float next_a = ZIN0(0);
4522
4523 if (xa == next_a) {
4524 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = atan2(xa, xb););
4525 } else {
4526 float slope = CALCSLOPE(next_a, xa);
4527 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = atan2(xa, xb); xa += slope;);
4528 unit->mPrevA = xa;
4529 }
4530 }
4531
atan2_ia(BinaryOpUGen * unit,int inNumSamples)4532 void atan2_ia(BinaryOpUGen* unit, int inNumSamples) {
4533 float* out = ZOUT(0);
4534 float xa = ZIN0(0);
4535 float* b = ZIN(1);
4536
4537 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = atan2(xa, xb););
4538 unit->mPrevA = xa;
4539 }
4540
4541
atan2_ai(BinaryOpUGen * unit,int inNumSamples)4542 void atan2_ai(BinaryOpUGen* unit, int inNumSamples) {
4543 float* out = ZOUT(0);
4544 float* a = ZIN(0);
4545 float xb = ZIN0(1);
4546
4547 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = atan2(xa, xb););
4548 unit->mPrevB = xb;
4549 }
4550
4551
hypot_aa(BinaryOpUGen * unit,int inNumSamples)4552 void hypot_aa(BinaryOpUGen* unit, int inNumSamples) {
4553 float* out = ZOUT(0);
4554 float* a = ZIN(0);
4555 float* b = ZIN(1);
4556
4557 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = hypotf(xa, xb););
4558 }
4559
hypot_ak(BinaryOpUGen * unit,int inNumSamples)4560 void hypot_ak(BinaryOpUGen* unit, int inNumSamples) {
4561 float* out = ZOUT(0);
4562 float* a = ZIN(0);
4563 float xb = unit->mPrevB;
4564 float next_b = ZIN0(1);
4565
4566 if (xb == next_b) {
4567 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = hypotf(xa, xb););
4568 } else {
4569 float slope = CALCSLOPE(next_b, xb);
4570 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = hypotf(xa, xb); xb += slope;);
4571 unit->mPrevB = xb;
4572 }
4573 }
4574
hypot_ka(BinaryOpUGen * unit,int inNumSamples)4575 void hypot_ka(BinaryOpUGen* unit, int inNumSamples) {
4576 float* out = ZOUT(0);
4577 float xa = unit->mPrevA;
4578 float* b = ZIN(1);
4579 float next_a = ZIN0(0);
4580
4581 if (xa == next_a) {
4582 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = hypotf(xa, xb););
4583 } else {
4584 float slope = CALCSLOPE(next_a, xa);
4585 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = hypotf(xa, xb); xa += slope;);
4586 unit->mPrevA = xa;
4587 }
4588 }
4589
hypot_ia(BinaryOpUGen * unit,int inNumSamples)4590 void hypot_ia(BinaryOpUGen* unit, int inNumSamples) {
4591 float* out = ZOUT(0);
4592 float xa = ZIN0(0);
4593 float* b = ZIN(1);
4594
4595 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = hypotf(xa, xb););
4596 unit->mPrevA = xa;
4597 }
4598
4599
hypot_ai(BinaryOpUGen * unit,int inNumSamples)4600 void hypot_ai(BinaryOpUGen* unit, int inNumSamples) {
4601 float* out = ZOUT(0);
4602 float* a = ZIN(0);
4603 float xb = ZIN0(1);
4604
4605 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = hypotf(xa, xb););
4606 unit->mPrevB = xb;
4607 }
4608
4609
hypotx_aa(BinaryOpUGen * unit,int inNumSamples)4610 void hypotx_aa(BinaryOpUGen* unit, int inNumSamples) {
4611 float* out = ZOUT(0);
4612 float* a = ZIN(0);
4613 float* b = ZIN(1);
4614
4615 LOOP1(inNumSamples, float xa = ZXP(a); float xb = ZXP(b); ZXP(out) = sc_hypotx(xa, xb););
4616 }
4617
hypotx_ak(BinaryOpUGen * unit,int inNumSamples)4618 void hypotx_ak(BinaryOpUGen* unit, int inNumSamples) {
4619 float* out = ZOUT(0);
4620 float* a = ZIN(0);
4621 float xb = unit->mPrevB;
4622 float next_b = ZIN0(1);
4623
4624 if (xb == next_b) {
4625 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_hypotx(xa, xb););
4626 } else {
4627 float slope = CALCSLOPE(next_b, xb);
4628 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_hypotx(xa, xb); xb += slope;);
4629 unit->mPrevB = xb;
4630 }
4631 }
4632
hypotx_ka(BinaryOpUGen * unit,int inNumSamples)4633 void hypotx_ka(BinaryOpUGen* unit, int inNumSamples) {
4634 float* out = ZOUT(0);
4635 float xa = unit->mPrevA;
4636 float* b = ZIN(1);
4637 float next_a = ZIN0(0);
4638
4639 if (xa == next_a) {
4640 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_hypotx(xa, xb););
4641 } else {
4642 float slope = CALCSLOPE(next_a, xa);
4643 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_hypotx(xa, xb); xa += slope;);
4644 unit->mPrevA = xa;
4645 }
4646 }
4647
hypotx_ia(BinaryOpUGen * unit,int inNumSamples)4648 void hypotx_ia(BinaryOpUGen* unit, int inNumSamples) {
4649 float* out = ZOUT(0);
4650 float xa = ZIN0(0);
4651 float* b = ZIN(1);
4652
4653 LOOP1(inNumSamples, float xb = ZXP(b); ZXP(out) = sc_hypotx(xa, xb););
4654 unit->mPrevA = xa;
4655 }
4656
4657
hypotx_ai(BinaryOpUGen * unit,int inNumSamples)4658 void hypotx_ai(BinaryOpUGen* unit, int inNumSamples) {
4659 float* out = ZOUT(0);
4660 float* a = ZIN(0);
4661 float xb = ZIN0(1);
4662
4663 LOOP1(inNumSamples, float xa = ZXP(a); ZXP(out) = sc_hypotx(xa, xb););
4664 unit->mPrevB = xb;
4665 }
4666
ChooseOneSampleFunc(BinaryOpUGen * unit)4667 static BinaryOpFunc ChooseOneSampleFunc(BinaryOpUGen* unit) {
4668 BinaryOpFunc func = &zero_1;
4669
4670 switch (unit->mSpecialIndex) {
4671 // case opSilence2 : func = &zero_1; break;
4672 case opAdd:
4673 func = &add_1;
4674 break;
4675 case opSub:
4676 func = &sub_1;
4677 break;
4678 case opMul:
4679 func = &mul_1;
4680 break;
4681 case opFDiv:
4682 func = &div_1;
4683 break;
4684 case opIDiv:
4685 func = &idiv_1;
4686 break;
4687 case opMod:
4688 func = &mod_1;
4689 break;
4690 case opEQ:
4691 func = &eq_1;
4692 break;
4693 case opNE:
4694 func = &neq_1;
4695 break;
4696 case opLT:
4697 func = <_1;
4698 break;
4699 case opGT:
4700 func = >_1;
4701 break;
4702 case opLE:
4703 func = &le_1;
4704 break;
4705 case opGE:
4706 func = &ge_1;
4707 break;
4708 case opMin:
4709 func = &min_1;
4710 break;
4711 case opMax:
4712 func = &max_1;
4713 break;
4714 case opBitAnd:
4715 func = &and_1;
4716 break;
4717 case opBitOr:
4718 func = &or_1;
4719 break;
4720 case opBitXor:
4721 func = &xor_1;
4722 break;
4723 case opShiftRight:
4724 func = &rightShift_1;
4725 break;
4726 case opShiftLeft:
4727 func = &leftShift_1;
4728 break;
4729 case opLCM:
4730 func = &lcm_1;
4731 break;
4732 case opGCD:
4733 func = &gcd_1;
4734 break;
4735 case opRound:
4736 func = &round_1;
4737 break;
4738 case opRoundUp:
4739 func = &roundUp_1;
4740 break;
4741 case opTrunc:
4742 func = &trunc_1;
4743 break;
4744 case opAtan2:
4745 func = &atan2_1;
4746 break;
4747 case opHypot:
4748 func = &hypot_1;
4749 break;
4750 case opHypotx:
4751 func = &hypotx_1;
4752 break;
4753 case opPow:
4754 func = &pow_1;
4755 break;
4756 case opRing1:
4757 func = &ring1_1;
4758 break;
4759 case opRing2:
4760 func = &ring2_1;
4761 break;
4762 case opRing3:
4763 func = &ring3_1;
4764 break;
4765 case opRing4:
4766 func = &ring4_1;
4767 break;
4768 case opDifSqr:
4769 func = &difsqr_1;
4770 break;
4771 case opSumSqr:
4772 func = &sumsqr_1;
4773 break;
4774 case opSqrSum:
4775 func = &sqrsum_1;
4776 break;
4777 case opSqrDif:
4778 func = &sqrdif_1;
4779 break;
4780 case opAbsDif:
4781 func = &absdif_1;
4782 break;
4783 case opThresh:
4784 func = &thresh_1;
4785 break;
4786 case opAMClip:
4787 func = &amclip_1;
4788 break;
4789 case opScaleNeg:
4790 func = &scaleneg_1;
4791 break;
4792 case opClip2:
4793 func = &clip2_1;
4794 break;
4795 case opFold2:
4796 func = &fold2_1;
4797 break;
4798 case opWrap2:
4799 func = &wrap2_1;
4800 break;
4801 case opExcess:
4802 func = &excess_1;
4803 break;
4804 case opFirstArg:
4805 func = &firstarg_1;
4806 break;
4807 case opRandRange:
4808 func = &rrand_1;
4809 break;
4810 case opExpRandRange:
4811 func = &exprand_1;
4812 break;
4813 // case opSecondArg : func = &secondarg_1; break;
4814 default:
4815 func = &add_1;
4816 break;
4817 }
4818 return func;
4819 }
4820
4821
ChooseDemandFunc(BinaryOpUGen * unit)4822 static BinaryOpFunc ChooseDemandFunc(BinaryOpUGen* unit) {
4823 BinaryOpFunc func = &zero_1;
4824
4825 switch (unit->mSpecialIndex) {
4826 // case opSilence2 : func = &zero_d; break;
4827 case opAdd:
4828 func = &add_d;
4829 break;
4830 case opSub:
4831 func = &sub_d;
4832 break;
4833 case opMul:
4834 func = &mul_d;
4835 break;
4836 case opFDiv:
4837 func = &div_d;
4838 break;
4839 case opIDiv:
4840 func = &idiv_d;
4841 break;
4842 case opMod:
4843 func = &mod_d;
4844 break;
4845 case opEQ:
4846 func = &eq_d;
4847 break;
4848 case opNE:
4849 func = &neq_d;
4850 break;
4851 case opLT:
4852 func = <_d;
4853 break;
4854 case opGT:
4855 func = >_d;
4856 break;
4857 case opLE:
4858 func = &le_d;
4859 break;
4860 case opGE:
4861 func = &ge_d;
4862 break;
4863 case opMin:
4864 func = &min_d;
4865 break;
4866 case opMax:
4867 func = &max_d;
4868 break;
4869 case opBitAnd:
4870 func = &and_d;
4871 break;
4872 case opBitOr:
4873 func = &or_d;
4874 break;
4875 case opBitXor:
4876 func = &xor_d;
4877 break;
4878 case opShiftRight:
4879 func = &rightShift_d;
4880 break;
4881 case opShiftLeft:
4882 func = &leftShift_d;
4883 break;
4884 case opLCM:
4885 func = &lcm_d;
4886 break;
4887 case opGCD:
4888 func = &gcd_d;
4889 break;
4890 case opRound:
4891 func = &round_d;
4892 break;
4893 case opRoundUp:
4894 func = &roundUp_d;
4895 break;
4896 case opTrunc:
4897 func = &trunc_d;
4898 break;
4899 case opAtan2:
4900 func = &atan2_d;
4901 break;
4902 case opHypot:
4903 func = &hypot_d;
4904 break;
4905 case opHypotx:
4906 func = &hypotx_d;
4907 break;
4908 case opPow:
4909 func = &pow_d;
4910 break;
4911 case opRing1:
4912 func = &ring1_d;
4913 break;
4914 case opRing2:
4915 func = &ring2_d;
4916 break;
4917 case opRing3:
4918 func = &ring3_d;
4919 break;
4920 case opRing4:
4921 func = &ring4_d;
4922 break;
4923 case opDifSqr:
4924 func = &difsqr_d;
4925 break;
4926 case opSumSqr:
4927 func = &sumsqr_d;
4928 break;
4929 case opSqrSum:
4930 func = &sqrsum_d;
4931 break;
4932 case opSqrDif:
4933 func = &sqrdif_d;
4934 break;
4935 case opAbsDif:
4936 func = &absdif_d;
4937 break;
4938 case opThresh:
4939 func = &thresh_d;
4940 break;
4941 case opAMClip:
4942 func = &amclip_d;
4943 break;
4944 case opScaleNeg:
4945 func = &scaleneg_d;
4946 break;
4947 case opClip2:
4948 func = &clip2_d;
4949 break;
4950 case opFold2:
4951 func = &fold2_d;
4952 break;
4953 case opWrap2:
4954 func = &wrap2_d;
4955 break;
4956 case opExcess:
4957 func = &excess_d;
4958 break;
4959 case opFirstArg:
4960 func = &firstarg_d;
4961 break;
4962 case opRandRange:
4963 func = &rrand_d;
4964 break;
4965 case opExpRandRange:
4966 func = &exprand_d;
4967 break;
4968
4969 // case opSecondArg : func = &secondarg_d; break;
4970 default:
4971 func = &add_d;
4972 break;
4973 }
4974 return func;
4975 }
4976
4977
ChooseNormalFunc(BinaryOpUGen * unit)4978 static BinaryOpFunc ChooseNormalFunc(BinaryOpUGen* unit) {
4979 BinaryOpFunc func = &zero_1;
4980
4981 int rateA = INRATE(0);
4982 int rateB = INRATE(1);
4983
4984 switch (rateA) {
4985 case calc_FullRate:
4986 switch (rateB) {
4987 case calc_FullRate:
4988 switch (unit->mSpecialIndex) {
4989 // case opSilence2 : func = &zero_aa; break;
4990 case opAdd:
4991 func = &add_aa;
4992 break;
4993 case opSub:
4994 func = &sub_aa;
4995 break;
4996 case opMul:
4997 func = &mul_aa;
4998 break;
4999 case opFDiv:
5000 func = &div_aa;
5001 break;
5002 case opIDiv:
5003 func = &idiv_aa;
5004 break;
5005 case opMod:
5006 func = &mod_aa;
5007 break;
5008 case opEQ:
5009 func = &eq_aa;
5010 break;
5011 case opNE:
5012 func = &neq_aa;
5013 break;
5014 case opLT:
5015 func = <_aa;
5016 break;
5017 case opGT:
5018 func = >_aa;
5019 break;
5020 case opLE:
5021 func = &le_aa;
5022 break;
5023 case opGE:
5024 func = &ge_aa;
5025 break;
5026 case opMin:
5027 func = &min_aa;
5028 break;
5029 case opMax:
5030 func = &max_aa;
5031 break;
5032 case opBitAnd:
5033 func = &and_aa;
5034 break;
5035 case opBitOr:
5036 func = &or_aa;
5037 break;
5038 case opBitXor:
5039 func = &xor_aa;
5040 break;
5041 case opShiftRight:
5042 func = &rightShift_aa;
5043 break;
5044 case opShiftLeft:
5045 func = &leftShift_aa;
5046 break;
5047 case opLCM:
5048 func = &lcm_aa;
5049 break;
5050 case opGCD:
5051 func = &gcd_aa;
5052 break;
5053 case opRound:
5054 func = &round_aa;
5055 break;
5056 case opRoundUp:
5057 func = &roundUp_aa;
5058 break;
5059 case opTrunc:
5060 func = &trunc_aa;
5061 break;
5062 case opAtan2:
5063 func = &atan2_aa;
5064 break;
5065 case opHypot:
5066 func = &hypot_aa;
5067 break;
5068 case opHypotx:
5069 func = &hypotx_aa;
5070 break;
5071 case opPow:
5072 func = &pow_aa;
5073 break;
5074 case opRing1:
5075 func = &ring1_aa;
5076 break;
5077 case opRing2:
5078 func = &ring2_aa;
5079 break;
5080 case opRing3:
5081 func = &ring3_aa;
5082 break;
5083 case opRing4:
5084 func = &ring4_aa;
5085 break;
5086 case opDifSqr:
5087 func = &difsqr_aa;
5088 break;
5089 case opSumSqr:
5090 func = &sumsqr_aa;
5091 break;
5092 case opSqrSum:
5093 func = &sqrsum_aa;
5094 break;
5095 case opSqrDif:
5096 func = &sqrdif_aa;
5097 break;
5098 case opAbsDif:
5099 func = &absdif_aa;
5100 break;
5101 case opThresh:
5102 func = &thresh_aa;
5103 break;
5104 case opAMClip:
5105 func = &amclip_aa;
5106 break;
5107 case opScaleNeg:
5108 func = &scaleneg_aa;
5109 break;
5110 case opClip2:
5111 func = &clip2_aa;
5112 break;
5113 case opFold2:
5114 func = &fold2_aa;
5115 break;
5116 case opWrap2:
5117 func = &wrap2_aa;
5118 break;
5119 case opExcess:
5120 func = &excess_aa;
5121 break;
5122 case opRandRange:
5123 func = &rrand_aa;
5124 break;
5125 case opExpRandRange:
5126 func = &exprand_aa;
5127 break;
5128 case opFirstArg:
5129 func = &firstarg_aa;
5130 break;
5131 // case opSecondArg : func = &secondarg_aa; break;
5132
5133
5134 default:
5135 func = &add_aa;
5136 break;
5137 }
5138 break;
5139 case calc_BufRate:
5140 switch (unit->mSpecialIndex) {
5141 // case opSilence2 : func = &zero_aa; break;
5142 case opAdd:
5143 func = &add_ak;
5144 break;
5145 case opSub:
5146 func = &sub_ak;
5147 break;
5148 case opMul:
5149 func = &mul_ak;
5150 break;
5151 case opFDiv:
5152 func = &div_ak;
5153 break;
5154 case opIDiv:
5155 func = &idiv_ak;
5156 break;
5157 case opMod:
5158 func = &mod_ak;
5159 break;
5160 case opEQ:
5161 func = &eq_ak;
5162 break;
5163 case opNE:
5164 func = &neq_ak;
5165 break;
5166 case opLT:
5167 func = <_ak;
5168 break;
5169 case opGT:
5170 func = >_ak;
5171 break;
5172 case opLE:
5173 func = &le_ak;
5174 break;
5175 case opGE:
5176 func = &ge_ak;
5177 break;
5178 case opMin:
5179 func = &min_ak;
5180 break;
5181 case opMax:
5182 func = &max_ak;
5183 break;
5184 case opBitAnd:
5185 func = &and_ak;
5186 break;
5187 case opBitOr:
5188 func = &or_ak;
5189 break;
5190 case opBitXor:
5191 func = &xor_ak;
5192 break;
5193 case opShiftRight:
5194 func = &rightShift_ak;
5195 break;
5196 case opShiftLeft:
5197 func = &leftShift_ak;
5198 break;
5199 case opLCM:
5200 func = &lcm_ak;
5201 break;
5202 case opGCD:
5203 func = &gcd_ak;
5204 break;
5205 case opRound:
5206 func = &round_ak;
5207 break;
5208 case opRoundUp:
5209 func = &roundUp_ak;
5210 break;
5211 case opTrunc:
5212 func = &trunc_ak;
5213 break;
5214 case opAtan2:
5215 func = &atan2_ak;
5216 break;
5217 case opHypot:
5218 func = &hypot_ak;
5219 break;
5220 case opHypotx:
5221 func = &hypotx_ak;
5222 break;
5223 case opPow:
5224 func = &pow_ak;
5225 break;
5226 case opRing1:
5227 func = &ring1_ak;
5228 break;
5229 case opRing2:
5230 func = &ring2_ak;
5231 break;
5232 case opRing3:
5233 func = &ring3_ak;
5234 break;
5235 case opRing4:
5236 func = &ring4_ak;
5237 break;
5238 case opDifSqr:
5239 func = &difsqr_ak;
5240 break;
5241 case opSumSqr:
5242 func = &sumsqr_ak;
5243 break;
5244 case opSqrSum:
5245 func = &sqrsum_ak;
5246 break;
5247 case opSqrDif:
5248 func = &sqrdif_ak;
5249 break;
5250 case opAbsDif:
5251 func = &absdif_ak;
5252 break;
5253 case opThresh:
5254 func = &thresh_ak;
5255 break;
5256 case opAMClip:
5257 func = &amclip_ak;
5258 break;
5259 case opScaleNeg:
5260 func = &scaleneg_ak;
5261 break;
5262 case opClip2:
5263 func = &clip2_ak;
5264 break;
5265 case opFold2:
5266 func = &fold2_ak;
5267 break;
5268 case opWrap2:
5269 func = &wrap2_ak;
5270 break;
5271 case opExcess:
5272 func = &excess_ak;
5273 break;
5274 case opRandRange:
5275 func = &rrand_ak;
5276 break;
5277 case opExpRandRange:
5278 func = &exprand_ak;
5279 break;
5280 case opFirstArg:
5281 func = &firstarg_aa;
5282 break;
5283 // case opSecondArg : func = &secondarg_aa; break;
5284
5285
5286 default:
5287 func = &add_ak;
5288 break;
5289 }
5290 break;
5291 case calc_ScalarRate:
5292 switch (unit->mSpecialIndex) {
5293 // case opSilence2 : func = &zero_aa; break;
5294 case opAdd:
5295 func = &add_ai;
5296 break;
5297 case opSub:
5298 func = &sub_ai;
5299 break;
5300 case opMul:
5301 func = &mul_ai;
5302 break;
5303 case opFDiv:
5304 func = &div_ai;
5305 break;
5306 case opIDiv:
5307 func = &idiv_ai;
5308 break;
5309 case opMod:
5310 func = &mod_ai;
5311 break;
5312 case opEQ:
5313 func = &eq_ai;
5314 break;
5315 case opNE:
5316 func = &neq_ai;
5317 break;
5318 case opLT:
5319 func = <_ai;
5320 break;
5321 case opGT:
5322 func = >_ai;
5323 break;
5324 case opLE:
5325 func = &le_ai;
5326 break;
5327 case opGE:
5328 func = &ge_ai;
5329 break;
5330 case opMin:
5331 func = &min_ai;
5332 break;
5333 case opMax:
5334 func = &max_ai;
5335 break;
5336 case opBitAnd:
5337 func = &and_ai;
5338 break;
5339 case opBitOr:
5340 func = &or_ai;
5341 break;
5342 case opBitXor:
5343 func = &xor_ai;
5344 break;
5345 case opShiftRight:
5346 func = &rightShift_ai;
5347 break;
5348 case opShiftLeft:
5349 func = &leftShift_ai;
5350 break;
5351 case opLCM:
5352 func = &lcm_ai;
5353 break;
5354 case opGCD:
5355 func = &gcd_ai;
5356 break;
5357 case opRound:
5358 func = &round_ai;
5359 break;
5360 case opRoundUp:
5361 func = &roundUp_ai;
5362 break;
5363 case opTrunc:
5364 func = &trunc_ai;
5365 break;
5366 case opAtan2:
5367 func = &atan2_ai;
5368 break;
5369 case opHypot:
5370 func = &hypot_ai;
5371 break;
5372 case opHypotx:
5373 func = &hypotx_ai;
5374 break;
5375 case opPow:
5376 func = &pow_ai;
5377 break;
5378 case opRing1:
5379 func = &ring1_ai;
5380 break;
5381 case opRing2:
5382 func = &ring2_ai;
5383 break;
5384 case opRing3:
5385 func = &ring3_ai;
5386 break;
5387 case opRing4:
5388 func = &ring4_ai;
5389 break;
5390 case opDifSqr:
5391 func = &difsqr_ai;
5392 break;
5393 case opSumSqr:
5394 func = &sumsqr_ai;
5395 break;
5396 case opSqrSum:
5397 func = &sqrsum_ai;
5398 break;
5399 case opSqrDif:
5400 func = &sqrdif_ai;
5401 break;
5402 case opAbsDif:
5403 func = &absdif_ai;
5404 break;
5405 case opThresh:
5406 func = &thresh_ai;
5407 break;
5408 case opAMClip:
5409 func = &amclip_ai;
5410 break;
5411 case opScaleNeg:
5412 func = &scaleneg_ai;
5413 break;
5414 case opClip2:
5415 func = &clip2_ai;
5416 break;
5417 case opFold2:
5418 func = &fold2_ai;
5419 break;
5420 case opWrap2:
5421 func = &wrap2_ai;
5422 break;
5423 case opExcess:
5424 func = &excess_ai;
5425 break;
5426 case opRandRange:
5427 func = &rrand_ai;
5428 break;
5429 case opExpRandRange:
5430 func = &exprand_ai;
5431 break;
5432 case opFirstArg:
5433 func = &firstarg_aa;
5434 break;
5435 // case opSecondArg : func = &secondarg_aa; break;
5436 default:
5437 func = &add_ai;
5438 break;
5439 }
5440 }
5441 break;
5442 case calc_BufRate:
5443 if (rateB == calc_FullRate) {
5444 switch (unit->mSpecialIndex) {
5445 // case opSilence2 : func = &zero_aa; break;
5446 case opAdd:
5447 func = &add_ka;
5448 break;
5449 case opSub:
5450 func = &sub_ka;
5451 break;
5452 case opMul:
5453 func = &mul_ka;
5454 break;
5455 case opFDiv:
5456 func = &div_ka;
5457 break;
5458 case opIDiv:
5459 func = &idiv_ka;
5460 break;
5461 case opMod:
5462 func = &mod_ka;
5463 break;
5464 case opEQ:
5465 func = &eq_ka;
5466 break;
5467 case opNE:
5468 func = &neq_ka;
5469 break;
5470 case opLT:
5471 func = <_ka;
5472 break;
5473 case opGT:
5474 func = >_ka;
5475 break;
5476 case opLE:
5477 func = &le_ka;
5478 break;
5479 case opGE:
5480 func = &ge_ka;
5481 break;
5482 case opMin:
5483 func = &min_ka;
5484 break;
5485 case opMax:
5486 func = &max_ka;
5487 break;
5488 case opBitAnd:
5489 func = &and_ka;
5490 break;
5491 case opBitOr:
5492 func = &or_ka;
5493 break;
5494 case opBitXor:
5495 func = &xor_ka;
5496 break;
5497 case opShiftRight:
5498 func = &rightShift_ka;
5499 break;
5500 case opShiftLeft:
5501 func = &leftShift_ka;
5502 break;
5503 case opLCM:
5504 func = &lcm_ka;
5505 break;
5506 case opGCD:
5507 func = &gcd_ka;
5508 break;
5509 case opRound:
5510 func = &round_ka;
5511 break;
5512 case opRoundUp:
5513 func = &roundUp_ka;
5514 break;
5515 case opTrunc:
5516 func = &trunc_ka;
5517 break;
5518 case opAtan2:
5519 func = &atan2_ka;
5520 break;
5521 case opHypot:
5522 func = &hypot_ka;
5523 break;
5524 case opHypotx:
5525 func = &hypotx_ka;
5526 break;
5527 case opPow:
5528 func = &pow_ka;
5529 break;
5530 case opRing1:
5531 func = &ring1_ka;
5532 break;
5533 case opRing2:
5534 func = &ring2_ka;
5535 break;
5536 case opRing3:
5537 func = &ring3_ka;
5538 break;
5539 case opRing4:
5540 func = &ring4_ka;
5541 break;
5542 case opDifSqr:
5543 func = &difsqr_ka;
5544 break;
5545 case opSumSqr:
5546 func = &sumsqr_ka;
5547 break;
5548 case opSqrSum:
5549 func = &sqrsum_ka;
5550 break;
5551 case opSqrDif:
5552 func = &sqrdif_ka;
5553 break;
5554 case opAbsDif:
5555 func = &absdif_ka;
5556 break;
5557 case opThresh:
5558 func = &thresh_ka;
5559 break;
5560 case opAMClip:
5561 func = &amclip_ka;
5562 break;
5563 case opScaleNeg:
5564 func = &scaleneg_ka;
5565 break;
5566 case opClip2:
5567 func = &clip2_ka;
5568 break;
5569 case opFold2:
5570 func = &fold2_ka;
5571 break;
5572 case opWrap2:
5573 func = &wrap2_ka;
5574 break;
5575 case opExcess:
5576 func = &excess_ka;
5577 break;
5578 case opRandRange:
5579 func = &rrand_ka;
5580 break;
5581 case opExpRandRange:
5582 func = &exprand_ka;
5583 break;
5584 // case opFirstArg : func = &firstarg_aa; break;
5585 // case opSecondArg : func = &secondarg_aa; break;
5586 default:
5587 func = &add_ka;
5588 break;
5589 }
5590 } else {
5591 // this should have been caught by mBufLength == 1
5592 func = &zero_aa;
5593 }
5594 break;
5595 case calc_ScalarRate:
5596 if (rateB == calc_FullRate) {
5597 switch (unit->mSpecialIndex) {
5598 // case opSilence2 : func = &zero_aa; break;
5599 case opAdd:
5600 func = &add_ia;
5601 break;
5602 case opSub:
5603 func = &sub_ia;
5604 break;
5605 case opMul:
5606 func = &mul_ia;
5607 break;
5608 case opFDiv:
5609 func = &div_ia;
5610 break;
5611 case opIDiv:
5612 func = &idiv_ia;
5613 break;
5614 case opMod:
5615 func = &mod_ia;
5616 break;
5617 case opEQ:
5618 func = &eq_ia;
5619 break;
5620 case opNE:
5621 func = &neq_ia;
5622 break;
5623 case opLT:
5624 func = <_ia;
5625 break;
5626 case opGT:
5627 func = >_ia;
5628 break;
5629 case opLE:
5630 func = &le_ia;
5631 break;
5632 case opGE:
5633 func = &ge_ia;
5634 break;
5635 case opMin:
5636 func = &min_ia;
5637 break;
5638 case opMax:
5639 func = &max_ia;
5640 break;
5641 case opBitAnd:
5642 func = &and_ia;
5643 break;
5644 case opBitOr:
5645 func = &or_ia;
5646 break;
5647 case opBitXor:
5648 func = &xor_ia;
5649 break;
5650 case opShiftRight:
5651 func = &rightShift_ia;
5652 break;
5653 case opShiftLeft:
5654 func = &leftShift_ia;
5655 break;
5656 case opLCM:
5657 func = &lcm_ia;
5658 break;
5659 case opGCD:
5660 func = &gcd_ia;
5661 break;
5662 case opRound:
5663 func = &round_ia;
5664 break;
5665 case opRoundUp:
5666 func = &roundUp_ia;
5667 break;
5668 case opTrunc:
5669 func = &trunc_ia;
5670 break;
5671 case opAtan2:
5672 func = &atan2_ia;
5673 break;
5674 case opHypot:
5675 func = &hypot_ia;
5676 break;
5677 case opHypotx:
5678 func = &hypotx_ia;
5679 break;
5680 case opPow:
5681 func = &pow_ia;
5682 break;
5683 case opRing1:
5684 func = &ring1_ia;
5685 break;
5686 case opRing2:
5687 func = &ring2_ia;
5688 break;
5689 case opRing3:
5690 func = &ring3_ia;
5691 break;
5692 case opRing4:
5693 func = &ring4_ia;
5694 break;
5695 case opDifSqr:
5696 func = &difsqr_ia;
5697 break;
5698 case opSumSqr:
5699 func = &sumsqr_ia;
5700 break;
5701 case opSqrSum:
5702 func = &sqrsum_ia;
5703 break;
5704 case opSqrDif:
5705 func = &sqrdif_ia;
5706 break;
5707 case opAbsDif:
5708 func = &absdif_ia;
5709 break;
5710 case opThresh:
5711 func = &thresh_ia;
5712 break;
5713 case opAMClip:
5714 func = &amclip_ia;
5715 break;
5716 case opScaleNeg:
5717 func = &scaleneg_ia;
5718 break;
5719 case opClip2:
5720 func = &clip2_ia;
5721 break;
5722 case opFold2:
5723 func = &fold2_ia;
5724 break;
5725 case opWrap2:
5726 func = &wrap2_ia;
5727 break;
5728 case opExcess:
5729 func = &excess_ia;
5730 break;
5731 case opRandRange:
5732 func = &rrand_ia;
5733 break;
5734 case opExpRandRange:
5735 func = &exprand_ia;
5736 break;
5737 // case opFirstArg : func = &firstarg_aa; break;
5738 // case opSecondArg : func = &secondarg_aa; break;
5739 default:
5740 func = &add_ia;
5741 break;
5742 }
5743 } else {
5744 // this should have been caught by mBufLength == 1
5745 func = &zero_aa;
5746 }
5747 break;
5748 }
5749
5750 return func;
5751 }
5752
5753 #ifdef NOVA_SIMD
ChooseNovaSimdFunc_64(BinaryOpUGen * unit)5754 static BinaryOpFunc ChooseNovaSimdFunc_64(BinaryOpUGen* unit) {
5755 BinaryOpFunc func = &zero_1;
5756
5757 int rateA = INRATE(0);
5758 int rateB = INRATE(1);
5759
5760 switch (rateA) {
5761 case calc_FullRate:
5762 switch (rateB) {
5763 case calc_FullRate:
5764 switch (unit->mSpecialIndex) {
5765 // case opSilence2 : func = &zero_aa; break;
5766 case opAdd:
5767 func = &add_aa_nova_64;
5768 break;
5769 case opSub:
5770 func = &sub_aa_nova_64;
5771 break;
5772 case opMul:
5773 func = &mul_aa_nova_64;
5774 break;
5775 case opFDiv:
5776 func = &div_aa_nova;
5777 break;
5778 case opIDiv:
5779 func = &idiv_aa;
5780 break;
5781 case opMod:
5782 func = &mod_aa;
5783 break;
5784 case opEQ:
5785 func = &eq_aa_nova_64;
5786 break;
5787 case opNE:
5788 func = &neq_aa_nova_64;
5789 break;
5790 case opLT:
5791 func = <_aa_nova_64;
5792 break;
5793 case opGT:
5794 func = >_aa_nova_64;
5795 break;
5796 case opLE:
5797 func = &le_aa_nova_64;
5798 break;
5799 case opGE:
5800 func = &ge_aa_nova_64;
5801 break;
5802 case opMin:
5803 func = &min_aa_nova_64;
5804 break;
5805 case opMax:
5806 func = &max_aa_nova_64;
5807 break;
5808 case opBitAnd:
5809 func = &and_aa;
5810 break;
5811 case opBitOr:
5812 func = &or_aa;
5813 break;
5814 case opBitXor:
5815 func = &xor_aa;
5816 break;
5817 case opShiftRight:
5818 func = &rightShift_aa;
5819 break;
5820 case opShiftLeft:
5821 func = &leftShift_aa;
5822 break;
5823 case opLCM:
5824 func = &lcm_aa;
5825 break;
5826 case opGCD:
5827 func = &gcd_aa;
5828 break;
5829 case opRound:
5830 func = &round_aa;
5831 break;
5832 case opRoundUp:
5833 func = &roundUp_aa;
5834 break;
5835 case opTrunc:
5836 func = &trunc_aa;
5837 break;
5838 case opAtan2:
5839 func = &atan2_aa;
5840 break;
5841 case opHypot:
5842 func = &hypot_aa;
5843 break;
5844 case opHypotx:
5845 func = &hypotx_aa;
5846 break;
5847 case opPow:
5848 func = &pow_aa_nova;
5849 break;
5850 case opRing1:
5851 func = &ring1_aa_nova_64;
5852 break;
5853 case opRing2:
5854 func = &ring2_aa_nova_64;
5855 break;
5856 case opRing3:
5857 func = &ring3_aa_nova_64;
5858 break;
5859 case opRing4:
5860 func = &ring4_aa_nova_64;
5861 break;
5862 case opDifSqr:
5863 func = &difsqr_aa_nova_64;
5864 break;
5865 case opSumSqr:
5866 func = &sumsqr_aa_nova_64;
5867 break;
5868 case opSqrSum:
5869 func = &sqrsum_aa_nova_64;
5870 break;
5871 case opSqrDif:
5872 func = &sqrdif_aa_nova_64;
5873 break;
5874 case opAbsDif:
5875 func = &absdif_aa;
5876 break;
5877 case opThresh:
5878 func = &thresh_aa;
5879 break;
5880 case opAMClip:
5881 func = &amclip_aa;
5882 break;
5883 case opScaleNeg:
5884 func = &scaleneg_aa;
5885 break;
5886 case opClip2:
5887 func = &clip2_aa_nova_64;
5888 break;
5889 case opFold2:
5890 func = &fold2_aa;
5891 break;
5892 case opWrap2:
5893 func = &wrap2_aa;
5894 break;
5895 case opExcess:
5896 func = &excess_aa;
5897 break;
5898 case opRandRange:
5899 func = &rrand_aa;
5900 break;
5901 case opExpRandRange:
5902 func = &exprand_aa;
5903 break;
5904 case opFirstArg:
5905 func = &firstarg_aa_nova;
5906 break;
5907 // case opSecondArg : func = &secondarg_aa_nova; break;
5908 default:
5909 func = &add_aa;
5910 break;
5911 }
5912 break;
5913 case calc_BufRate:
5914 switch (unit->mSpecialIndex) {
5915 // case opSilence2 : func = &zero_aa; break;
5916 case opAdd:
5917 func = &add_ak_nova_64;
5918 break;
5919 case opSub:
5920 func = &sub_ak_nova_64;
5921 break;
5922 case opMul:
5923 func = &mul_ak_nova_64;
5924 break;
5925 case opFDiv:
5926 func = &div_ak_nova;
5927 break;
5928 case opIDiv:
5929 func = &idiv_ak;
5930 break;
5931 case opMod:
5932 func = &mod_ak;
5933 break;
5934 case opEQ:
5935 func = &eq_ak_nova_64;
5936 break;
5937 case opNE:
5938 func = &neq_ak_nova_64;
5939 break;
5940 case opLT:
5941 func = <_ak_nova_64;
5942 break;
5943 case opGT:
5944 func = >_ak_nova_64;
5945 break;
5946 case opLE:
5947 func = &le_ak_nova_64;
5948 break;
5949 case opGE:
5950 func = &ge_ak_nova_64;
5951 break;
5952 case opMin:
5953 func = &min_ak_nova_64;
5954 break;
5955 case opMax:
5956 func = &max_ak_nova_64;
5957 break;
5958 case opBitAnd:
5959 func = &and_ak;
5960 break;
5961 case opBitOr:
5962 func = &or_ak;
5963 break;
5964 case opBitXor:
5965 func = &xor_ak;
5966 break;
5967 case opShiftRight:
5968 func = &rightShift_ak;
5969 break;
5970 case opShiftLeft:
5971 func = &leftShift_ak;
5972 break;
5973 case opLCM:
5974 func = &lcm_ak;
5975 break;
5976 case opGCD:
5977 func = &gcd_ak;
5978 break;
5979 case opRound:
5980 func = &round_ak;
5981 break;
5982 case opRoundUp:
5983 func = &roundUp_ak;
5984 break;
5985 case opTrunc:
5986 func = &trunc_ak;
5987 break;
5988 case opAtan2:
5989 func = &atan2_ak;
5990 break;
5991 case opHypot:
5992 func = &hypot_ak;
5993 break;
5994 case opHypotx:
5995 func = &hypotx_ak;
5996 break;
5997 case opPow:
5998 func = &pow_ak_nova;
5999 break;
6000 case opRing1:
6001 func = &ring1_ak;
6002 break;
6003 case opRing2:
6004 func = &ring2_ak;
6005 break;
6006 case opRing3:
6007 func = &ring3_ak;
6008 break;
6009 case opRing4:
6010 func = &ring4_ak;
6011 break;
6012 case opDifSqr:
6013 func = &difsqr_ak_nova_64;
6014 break;
6015 case opSumSqr:
6016 func = &sumsqr_ak_nova_64;
6017 break;
6018 case opSqrSum:
6019 func = &sqrsum_ak_nova_64;
6020 break;
6021 case opSqrDif:
6022 func = &sqrdif_ak_nova_64;
6023 break;
6024 case opAbsDif:
6025 func = &absdif_ak;
6026 break;
6027 case opThresh:
6028 func = &thresh_ak;
6029 break;
6030 case opAMClip:
6031 func = &amclip_ak;
6032 break;
6033 case opScaleNeg:
6034 func = &scaleneg_ak;
6035 break;
6036 case opClip2:
6037 func = &clip2_ak_nova_64;
6038 break;
6039 case opFold2:
6040 func = &fold2_ak;
6041 break;
6042 case opWrap2:
6043 func = &wrap2_ak;
6044 break;
6045 case opExcess:
6046 func = &excess_ak;
6047 break;
6048 case opRandRange:
6049 func = &rrand_ak;
6050 break;
6051 case opExpRandRange:
6052 func = &exprand_ak;
6053 break;
6054 case opFirstArg:
6055 func = &firstarg_aa;
6056 break;
6057 // case opSecondArg : func = &secondarg_aa; break;
6058 default:
6059 func = &add_ak;
6060 break;
6061 }
6062 break;
6063 case calc_ScalarRate:
6064 switch (unit->mSpecialIndex) {
6065 // case opSilence2 : func = &zero_aa; break;
6066 case opAdd:
6067 func = &add_ai_nova_64;
6068 break;
6069 case opSub:
6070 func = &sub_ai_nova_64;
6071 break;
6072 case opMul:
6073 func = &mul_ai_nova_64;
6074 break;
6075 case opFDiv:
6076 func = &div_ai_nova;
6077 break;
6078 case opIDiv:
6079 func = &idiv_ai;
6080 break;
6081 case opMod:
6082 func = &mod_ai;
6083 break;
6084 case opEQ:
6085 func = &eq_ai_nova_64;
6086 break;
6087 case opNE:
6088 func = &neq_ai_nova_64;
6089 break;
6090 case opLT:
6091 func = <_ai_nova_64;
6092 break;
6093 case opGT:
6094 func = >_ai_nova_64;
6095 break;
6096 case opLE:
6097 func = &le_ai_nova_64;
6098 break;
6099 case opGE:
6100 func = &ge_ai_nova_64;
6101 break;
6102 case opMin:
6103 func = &min_ai_nova_64;
6104 break;
6105 case opMax:
6106 func = &max_ai_nova_64;
6107 break;
6108 case opBitAnd:
6109 func = &and_ai;
6110 break;
6111 case opBitOr:
6112 func = &or_ai;
6113 break;
6114 case opBitXor:
6115 func = &xor_ai;
6116 break;
6117 case opShiftRight:
6118 func = &rightShift_ai;
6119 break;
6120 case opShiftLeft:
6121 func = &leftShift_ai;
6122 break;
6123 case opLCM:
6124 func = &lcm_ai;
6125 break;
6126 case opGCD:
6127 func = &gcd_ai;
6128 break;
6129 case opRound:
6130 func = &round_ai;
6131 break;
6132 case opRoundUp:
6133 func = &roundUp_ai;
6134 break;
6135 case opTrunc:
6136 func = &trunc_ai;
6137 break;
6138 case opAtan2:
6139 func = &atan2_ai;
6140 break;
6141 case opHypot:
6142 func = &hypot_ai;
6143 break;
6144 case opHypotx:
6145 func = &hypotx_ai;
6146 break;
6147 case opPow:
6148 func = &pow_ai_nova;
6149 break;
6150 case opRing1:
6151 func = &ring1_ai_nova_64;
6152 break;
6153 case opRing2:
6154 func = &ring2_ai_nova_64;
6155 break;
6156 case opRing3:
6157 func = &ring3_ai_nova_64;
6158 break;
6159 case opRing4:
6160 func = &ring4_ai_nova_64;
6161 break;
6162 case opDifSqr:
6163 func = &difsqr_ai_nova_64;
6164 break;
6165 case opSumSqr:
6166 func = &sumsqr_ai_nova_64;
6167 break;
6168 case opSqrSum:
6169 func = &sqrsum_ai_nova_64;
6170 break;
6171 case opSqrDif:
6172 func = &sqrdif_ai_nova_64;
6173 break;
6174 case opAbsDif:
6175 func = &absdif_ai;
6176 break;
6177 case opThresh:
6178 func = &thresh_ai;
6179 break;
6180 case opAMClip:
6181 func = &amclip_ai;
6182 break;
6183 case opScaleNeg:
6184 func = &scaleneg_ai;
6185 break;
6186 case opClip2:
6187 func = &clip2_ai_nova_64;
6188 break;
6189 case opFold2:
6190 func = &fold2_ai;
6191 break;
6192 case opWrap2:
6193 func = &wrap2_ai;
6194 break;
6195 case opExcess:
6196 func = &excess_ai;
6197 break;
6198 case opRandRange:
6199 func = &rrand_ai;
6200 break;
6201 case opExpRandRange:
6202 func = &exprand_ai;
6203 break;
6204 case opFirstArg:
6205 func = &firstarg_aa;
6206 break;
6207 // case opSecondArg : func = &secondarg_aa; break;
6208 default:
6209 func = &add_ai;
6210 break;
6211 }
6212 }
6213 break;
6214 case calc_BufRate:
6215 if (rateB == calc_FullRate) {
6216 switch (unit->mSpecialIndex) {
6217 // case opSilence2 : func = &zero_aa; break;
6218 case opAdd:
6219 func = &add_ka_nova_64;
6220 break;
6221 case opSub:
6222 func = &sub_ka_nova_64;
6223 break;
6224 case opMul:
6225 func = &mul_ka_nova_64;
6226 break;
6227 case opFDiv:
6228 func = &div_ka_nova;
6229 break;
6230 case opIDiv:
6231 func = &idiv_ka;
6232 break;
6233 case opMod:
6234 func = &mod_ka;
6235 break;
6236 case opEQ:
6237 func = &eq_ka_nova_64;
6238 break;
6239 case opNE:
6240 func = &neq_ka_nova_64;
6241 break;
6242 case opLT:
6243 func = <_ka_nova_64;
6244 break;
6245 case opGT:
6246 func = >_ka_nova_64;
6247 break;
6248 case opLE:
6249 func = &le_ka_nova_64;
6250 break;
6251 case opGE:
6252 func = &ge_ka_nova_64;
6253 break;
6254 case opMin:
6255 func = &min_ka_nova_64;
6256 break;
6257 case opMax:
6258 func = &max_ka_nova_64;
6259 break;
6260 case opBitAnd:
6261 func = &and_ka;
6262 break;
6263 case opBitOr:
6264 func = &or_ka;
6265 break;
6266 case opBitXor:
6267 func = &xor_ka;
6268 break;
6269 case opShiftRight:
6270 func = &rightShift_ka;
6271 break;
6272 case opShiftLeft:
6273 func = &leftShift_ka;
6274 break;
6275 case opLCM:
6276 func = &lcm_ka;
6277 break;
6278 case opGCD:
6279 func = &gcd_ka;
6280 break;
6281 case opRound:
6282 func = &round_ka;
6283 break;
6284 case opRoundUp:
6285 func = &roundUp_ka;
6286 break;
6287 case opTrunc:
6288 func = &trunc_ka;
6289 break;
6290 case opAtan2:
6291 func = &atan2_ka;
6292 break;
6293 case opHypot:
6294 func = &hypot_ka;
6295 break;
6296 case opHypotx:
6297 func = &hypotx_ka;
6298 break;
6299 case opPow:
6300 func = &pow_ka_nova;
6301 break;
6302 case opRing1:
6303 func = &ring1_ka;
6304 break;
6305 case opRing2:
6306 func = &ring2_ka;
6307 break;
6308 case opRing3:
6309 func = &ring3_ka;
6310 break;
6311 case opRing4:
6312 func = &ring4_ka;
6313 break;
6314 case opDifSqr:
6315 func = &difsqr_ka_nova_64;
6316 break;
6317 case opSumSqr:
6318 func = &sumsqr_ka_nova_64;
6319 break;
6320 case opSqrSum:
6321 func = &sqrsum_ka_nova_64;
6322 break;
6323 case opSqrDif:
6324 func = &sqrdif_ka_nova_64;
6325 break;
6326 case opAbsDif:
6327 func = &absdif_ka;
6328 break;
6329 case opThresh:
6330 func = &thresh_ka;
6331 break;
6332 case opAMClip:
6333 func = &amclip_ka;
6334 break;
6335 case opScaleNeg:
6336 func = &scaleneg_ka;
6337 break;
6338 case opClip2:
6339 func = &clip2_ka_nova_64;
6340 break;
6341 case opFold2:
6342 func = &fold2_ka;
6343 break;
6344 case opWrap2:
6345 func = &wrap2_ka;
6346 break;
6347 case opExcess:
6348 func = &excess_ka;
6349 break;
6350 case opRandRange:
6351 func = &rrand_ka;
6352 break;
6353 case opExpRandRange:
6354 func = &exprand_ka;
6355 break;
6356 // case opFirstArg : func = &firstarg_aa; break;
6357 // case opSecondArg : func = &secondarg_aa; break;
6358 default:
6359 func = &add_ka;
6360 break;
6361 }
6362 } else {
6363 // this should have been caught by mBufLength == 1
6364 func = &zero_aa;
6365 }
6366 break;
6367 case calc_ScalarRate:
6368 if (rateB == calc_FullRate) {
6369 switch (unit->mSpecialIndex) {
6370 // case opSilence2 : func = &zero_aa; break;
6371 case opAdd:
6372 func = &add_ia_nova_64;
6373 break;
6374 case opSub:
6375 func = &sub_ia_nova_64;
6376 break;
6377 case opMul:
6378 func = &mul_ia_nova_64;
6379 break;
6380 case opFDiv:
6381 func = &div_ia_nova;
6382 break;
6383 case opIDiv:
6384 func = &idiv_ia;
6385 break;
6386 case opMod:
6387 func = &mod_ia;
6388 break;
6389 case opEQ:
6390 func = &eq_ia_nova_64;
6391 break;
6392 case opNE:
6393 func = &neq_ia_nova_64;
6394 break;
6395 case opLT:
6396 func = <_ia_nova_64;
6397 break;
6398 case opGT:
6399 func = >_ia_nova_64;
6400 break;
6401 case opLE:
6402 func = &le_ia_nova_64;
6403 break;
6404 case opGE:
6405 func = &ge_ia_nova_64;
6406 break;
6407 case opMin:
6408 func = &min_ia_nova_64;
6409 break;
6410 case opMax:
6411 func = &max_ia_nova_64;
6412 break;
6413 case opBitAnd:
6414 func = &and_ia;
6415 break;
6416 case opBitOr:
6417 func = &or_ia;
6418 break;
6419 case opBitXor:
6420 func = &xor_ia;
6421 break;
6422 case opShiftRight:
6423 func = &rightShift_ia;
6424 break;
6425 case opShiftLeft:
6426 func = &leftShift_ia;
6427 break;
6428 case opLCM:
6429 func = &lcm_ia;
6430 break;
6431 case opGCD:
6432 func = &gcd_ia;
6433 break;
6434 case opRound:
6435 func = &round_ia;
6436 break;
6437 case opRoundUp:
6438 func = &roundUp_ia;
6439 break;
6440 case opTrunc:
6441 func = &trunc_ia;
6442 break;
6443 case opAtan2:
6444 func = &atan2_ia;
6445 break;
6446 case opHypot:
6447 func = &hypot_ia;
6448 break;
6449 case opHypotx:
6450 func = &hypotx_ia;
6451 break;
6452 case opPow:
6453 func = &pow_ia_nova;
6454 break;
6455 case opRing1:
6456 func = &ring1_ia_nova_64;
6457 break;
6458 case opRing2:
6459 func = &ring2_ia_nova_64;
6460 break;
6461 case opRing3:
6462 func = &ring3_ia_nova_64;
6463 break;
6464 case opRing4:
6465 func = &ring4_ia_nova_64;
6466 break;
6467 case opDifSqr:
6468 func = &difsqr_ia_nova_64;
6469 break;
6470 case opSumSqr:
6471 func = &sumsqr_ia_nova_64;
6472 break;
6473 case opSqrSum:
6474 func = &sqrsum_ia_nova_64;
6475 break;
6476 case opSqrDif:
6477 func = &sqrdif_ia_nova_64;
6478 break;
6479 case opAbsDif:
6480 func = &absdif_ia;
6481 break;
6482 case opThresh:
6483 func = &thresh_ia;
6484 break;
6485 case opAMClip:
6486 func = &amclip_ia;
6487 break;
6488 case opScaleNeg:
6489 func = &scaleneg_ia;
6490 break;
6491 case opClip2:
6492 func = &clip2_ia_nova_64;
6493 break;
6494 case opFold2:
6495 func = &fold2_ia;
6496 break;
6497 case opWrap2:
6498 func = &wrap2_ia;
6499 break;
6500 case opExcess:
6501 func = &excess_ia;
6502 break;
6503 case opRandRange:
6504 func = &rrand_ia;
6505 break;
6506 case opExpRandRange:
6507 func = &exprand_ia;
6508 break;
6509 // case opFirstArg : func = &firstarg_aa; break;
6510 // case opSecondArg : func = &secondarg_aa; break;
6511 default:
6512 func = &add_ia;
6513 break;
6514 }
6515 } else {
6516 // this should have been caught by mBufLength == 1
6517 func = &zero_aa;
6518 }
6519 break;
6520 }
6521
6522 return func;
6523 }
6524
6525
ChooseNovaSimdFunc(BinaryOpUGen * unit)6526 static BinaryOpFunc ChooseNovaSimdFunc(BinaryOpUGen* unit) {
6527 if (BUFLENGTH == 64)
6528 return ChooseNovaSimdFunc_64(unit);
6529
6530 BinaryOpFunc func = &zero_1;
6531
6532 int rateA = INRATE(0);
6533 int rateB = INRATE(1);
6534
6535 switch (rateA) {
6536 case calc_FullRate:
6537 switch (rateB) {
6538 case calc_FullRate:
6539 switch (unit->mSpecialIndex) {
6540 // case opSilence2 : func = &zero_aa; break;
6541 case opAdd:
6542 func = &add_aa_nova;
6543 break;
6544 case opSub:
6545 func = &sub_aa_nova;
6546 break;
6547 case opMul:
6548 func = &mul_aa_nova;
6549 break;
6550 case opFDiv:
6551 func = &div_aa_nova;
6552 break;
6553 case opIDiv:
6554 func = &idiv_aa;
6555 break;
6556 case opMod:
6557 func = &mod_aa;
6558 break;
6559 case opEQ:
6560 func = &eq_aa_nova;
6561 break;
6562 case opNE:
6563 func = &neq_aa_nova;
6564 break;
6565 case opLT:
6566 func = <_aa_nova;
6567 break;
6568 case opGT:
6569 func = >_aa_nova;
6570 break;
6571 case opLE:
6572 func = &le_aa_nova;
6573 break;
6574 case opGE:
6575 func = &ge_aa_nova;
6576 break;
6577 case opMin:
6578 func = &min_aa_nova;
6579 break;
6580 case opMax:
6581 func = &max_aa_nova;
6582 break;
6583 case opBitAnd:
6584 func = &and_aa;
6585 break;
6586 case opBitOr:
6587 func = &or_aa;
6588 break;
6589 case opBitXor:
6590 func = &xor_aa;
6591 break;
6592 case opShiftRight:
6593 func = &rightShift_aa;
6594 break;
6595 case opShiftLeft:
6596 func = &leftShift_aa;
6597 break;
6598 case opLCM:
6599 func = &lcm_aa;
6600 break;
6601 case opGCD:
6602 func = &gcd_aa;
6603 break;
6604 case opRound:
6605 func = &round_aa;
6606 break;
6607 case opRoundUp:
6608 func = &roundUp_aa;
6609 break;
6610 case opTrunc:
6611 func = &trunc_aa;
6612 break;
6613 case opAtan2:
6614 func = &atan2_aa;
6615 break;
6616 case opHypot:
6617 func = &hypot_aa;
6618 break;
6619 case opHypotx:
6620 func = &hypotx_aa;
6621 break;
6622 case opPow:
6623 func = &pow_aa_nova;
6624 break;
6625 case opRing1:
6626 func = &ring1_aa_nova;
6627 break;
6628 case opRing2:
6629 func = &ring2_aa_nova;
6630 break;
6631 case opRing3:
6632 func = &ring3_aa_nova;
6633 break;
6634 case opRing4:
6635 func = &ring4_aa_nova;
6636 break;
6637 case opDifSqr:
6638 func = &difsqr_aa_nova;
6639 break;
6640 case opSumSqr:
6641 func = &sumsqr_aa_nova;
6642 break;
6643 case opSqrSum:
6644 func = &sqrsum_aa_nova;
6645 break;
6646 case opSqrDif:
6647 func = &sqrdif_aa_nova;
6648 break;
6649 case opAbsDif:
6650 func = &absdif_aa;
6651 break;
6652 case opThresh:
6653 func = &thresh_aa;
6654 break;
6655 case opAMClip:
6656 func = &amclip_aa;
6657 break;
6658 case opScaleNeg:
6659 func = &scaleneg_aa;
6660 break;
6661 case opClip2:
6662 func = &clip2_aa_nova;
6663 break;
6664 case opFold2:
6665 func = &fold2_aa;
6666 break;
6667 case opWrap2:
6668 func = &wrap2_aa;
6669 break;
6670 case opExcess:
6671 func = &excess_aa;
6672 break;
6673 case opRandRange:
6674 func = &rrand_aa;
6675 break;
6676 case opExpRandRange:
6677 func = &exprand_aa;
6678 break;
6679 case opFirstArg:
6680 func = &firstarg_aa_nova;
6681 break;
6682 // case opSecondArg : func = &secondarg_aa_nova; break;
6683 default:
6684 func = &add_aa;
6685 break;
6686 }
6687 break;
6688 case calc_BufRate:
6689 switch (unit->mSpecialIndex) {
6690 // case opSilence2 : func = &zero_aa; break;
6691 case opAdd:
6692 func = &add_ak_nova;
6693 break;
6694 case opSub:
6695 func = &sub_ak_nova;
6696 break;
6697 case opMul:
6698 func = &mul_ak_nova;
6699 break;
6700 case opFDiv:
6701 func = &div_ak_nova;
6702 break;
6703 case opIDiv:
6704 func = &idiv_ak;
6705 break;
6706 case opMod:
6707 func = &mod_ak;
6708 break;
6709 case opEQ:
6710 func = &eq_ak_nova;
6711 break;
6712 case opNE:
6713 func = &neq_ak_nova;
6714 break;
6715 case opLT:
6716 func = <_ak_nova;
6717 break;
6718 case opGT:
6719 func = >_ak_nova;
6720 break;
6721 case opLE:
6722 func = &le_ak_nova;
6723 break;
6724 case opGE:
6725 func = &ge_ak_nova;
6726 break;
6727 case opMin:
6728 func = &min_ak_nova;
6729 break;
6730 case opMax:
6731 func = &max_ak_nova;
6732 break;
6733 case opBitAnd:
6734 func = &and_ak;
6735 break;
6736 case opBitOr:
6737 func = &or_ak;
6738 break;
6739 case opBitXor:
6740 func = &xor_ak;
6741 break;
6742 case opShiftRight:
6743 func = &rightShift_ak;
6744 break;
6745 case opShiftLeft:
6746 func = &leftShift_ak;
6747 break;
6748 case opLCM:
6749 func = &lcm_ak;
6750 break;
6751 case opGCD:
6752 func = &gcd_ak;
6753 break;
6754 case opRound:
6755 func = &round_ak;
6756 break;
6757 case opRoundUp:
6758 func = &roundUp_ak;
6759 break;
6760 case opTrunc:
6761 func = &trunc_ak;
6762 break;
6763 case opAtan2:
6764 func = &atan2_ak;
6765 break;
6766 case opHypot:
6767 func = &hypot_ak;
6768 break;
6769 case opHypotx:
6770 func = &hypotx_ak;
6771 break;
6772 case opPow:
6773 func = &pow_ak_nova;
6774 break;
6775 case opRing1:
6776 func = &ring1_ak;
6777 break;
6778 case opRing2:
6779 func = &ring2_ak;
6780 break;
6781 case opRing3:
6782 func = &ring3_ak;
6783 break;
6784 case opRing4:
6785 func = &ring4_ak;
6786 break;
6787 case opDifSqr:
6788 func = &difsqr_ak_nova;
6789 break;
6790 case opSumSqr:
6791 func = &sumsqr_ak_nova;
6792 break;
6793 case opSqrSum:
6794 func = &sqrsum_ak_nova;
6795 break;
6796 case opSqrDif:
6797 func = &sqrdif_ak_nova;
6798 break;
6799 case opAbsDif:
6800 func = &absdif_ak;
6801 break;
6802 case opThresh:
6803 func = &thresh_ak;
6804 break;
6805 case opAMClip:
6806 func = &amclip_ak;
6807 break;
6808 case opScaleNeg:
6809 func = &scaleneg_ak;
6810 break;
6811 case opClip2:
6812 func = &clip2_ak_nova;
6813 break;
6814 case opFold2:
6815 func = &fold2_ak;
6816 break;
6817 case opWrap2:
6818 func = &wrap2_ak;
6819 break;
6820 case opExcess:
6821 func = &excess_ak;
6822 break;
6823 case opRandRange:
6824 func = &rrand_ak;
6825 break;
6826 case opExpRandRange:
6827 func = &exprand_ak;
6828 break;
6829 case opFirstArg:
6830 func = &firstarg_aa;
6831 break;
6832 // case opSecondArg : func = &secondarg_aa; break;
6833 default:
6834 func = &add_ak;
6835 break;
6836 }
6837 break;
6838 case calc_ScalarRate:
6839 switch (unit->mSpecialIndex) {
6840 // case opSilence2 : func = &zero_aa; break;
6841 case opAdd:
6842 func = &add_ai_nova;
6843 break;
6844 case opSub:
6845 func = &sub_ai_nova;
6846 break;
6847 case opMul:
6848 func = &mul_ai_nova;
6849 break;
6850 case opFDiv:
6851 func = &div_ai_nova;
6852 break;
6853 case opIDiv:
6854 func = &idiv_ai;
6855 break;
6856 case opMod:
6857 func = &mod_ai;
6858 break;
6859 case opEQ:
6860 func = &eq_ai_nova;
6861 break;
6862 case opNE:
6863 func = &neq_ai_nova;
6864 break;
6865 case opLT:
6866 func = <_ai_nova;
6867 break;
6868 case opGT:
6869 func = >_ai_nova;
6870 break;
6871 case opLE:
6872 func = &le_ai_nova;
6873 break;
6874 case opGE:
6875 func = &ge_ai_nova;
6876 break;
6877 case opMin:
6878 func = &min_ai_nova;
6879 break;
6880 case opMax:
6881 func = &max_ai_nova;
6882 break;
6883 case opBitAnd:
6884 func = &and_ai;
6885 break;
6886 case opBitOr:
6887 func = &or_ai;
6888 break;
6889 case opBitXor:
6890 func = &xor_ai;
6891 break;
6892 case opShiftRight:
6893 func = &rightShift_ai;
6894 break;
6895 case opShiftLeft:
6896 func = &leftShift_ai;
6897 break;
6898 case opLCM:
6899 func = &lcm_ai;
6900 break;
6901 case opGCD:
6902 func = &gcd_ai;
6903 break;
6904 case opRound:
6905 func = &round_ai;
6906 break;
6907 case opRoundUp:
6908 func = &roundUp_ai;
6909 break;
6910 case opTrunc:
6911 func = &trunc_ai;
6912 break;
6913 case opAtan2:
6914 func = &atan2_ai;
6915 break;
6916 case opHypot:
6917 func = &hypot_ai;
6918 break;
6919 case opHypotx:
6920 func = &hypotx_ai;
6921 break;
6922 case opPow:
6923 func = &pow_ai_nova;
6924 break;
6925 case opRing1:
6926 func = &ring1_ai_nova;
6927 break;
6928 case opRing2:
6929 func = &ring2_ai_nova;
6930 break;
6931 case opRing3:
6932 func = &ring3_ai_nova;
6933 break;
6934 case opRing4:
6935 func = &ring4_ai_nova;
6936 break;
6937 case opDifSqr:
6938 func = &difsqr_ai_nova;
6939 break;
6940 case opSumSqr:
6941 func = &sumsqr_ai_nova;
6942 break;
6943 case opSqrSum:
6944 func = &sqrsum_ai_nova;
6945 break;
6946 case opSqrDif:
6947 func = &sqrdif_ai_nova;
6948 break;
6949 case opAbsDif:
6950 func = &absdif_ai;
6951 break;
6952 case opThresh:
6953 func = &thresh_ai;
6954 break;
6955 case opAMClip:
6956 func = &amclip_ai;
6957 break;
6958 case opScaleNeg:
6959 func = &scaleneg_ai;
6960 break;
6961 case opClip2:
6962 func = &clip2_ai_nova;
6963 break;
6964 case opFold2:
6965 func = &fold2_ai;
6966 break;
6967 case opWrap2:
6968 func = &wrap2_ai;
6969 break;
6970 case opExcess:
6971 func = &excess_ai;
6972 break;
6973 case opRandRange:
6974 func = &rrand_ai;
6975 break;
6976 case opExpRandRange:
6977 func = &exprand_ai;
6978 break;
6979 case opFirstArg:
6980 func = &firstarg_aa;
6981 break;
6982 // case opSecondArg : func = &secondarg_aa; break;
6983 default:
6984 func = &add_ai;
6985 break;
6986 }
6987 }
6988 break;
6989 case calc_BufRate:
6990 if (rateB == calc_FullRate) {
6991 switch (unit->mSpecialIndex) {
6992 // case opSilence2 : func = &zero_aa; break;
6993 case opAdd:
6994 func = &add_ka_nova;
6995 break;
6996 case opSub:
6997 func = &sub_ka_nova;
6998 break;
6999 case opMul:
7000 func = &mul_ka_nova;
7001 break;
7002 case opFDiv:
7003 func = &div_ka_nova;
7004 break;
7005 case opIDiv:
7006 func = &idiv_ka;
7007 break;
7008 case opMod:
7009 func = &mod_ka;
7010 break;
7011 case opEQ:
7012 func = &eq_ka_nova;
7013 break;
7014 case opNE:
7015 func = &neq_ka_nova;
7016 break;
7017 case opLT:
7018 func = <_ka_nova;
7019 break;
7020 case opGT:
7021 func = >_ka_nova;
7022 break;
7023 case opLE:
7024 func = &le_ka_nova;
7025 break;
7026 case opGE:
7027 func = &ge_ka_nova;
7028 break;
7029 case opMin:
7030 func = &min_ka_nova;
7031 break;
7032 case opMax:
7033 func = &max_ka_nova;
7034 break;
7035 case opBitAnd:
7036 func = &and_ka;
7037 break;
7038 case opBitOr:
7039 func = &or_ka;
7040 break;
7041 case opBitXor:
7042 func = &xor_ka;
7043 break;
7044 case opShiftRight:
7045 func = &rightShift_ka;
7046 break;
7047 case opShiftLeft:
7048 func = &leftShift_ka;
7049 break;
7050 case opLCM:
7051 func = &lcm_ka;
7052 break;
7053 case opGCD:
7054 func = &gcd_ka;
7055 break;
7056 case opRound:
7057 func = &round_ka;
7058 break;
7059 case opRoundUp:
7060 func = &roundUp_ka;
7061 break;
7062 case opTrunc:
7063 func = &trunc_ka;
7064 break;
7065 case opAtan2:
7066 func = &atan2_ka;
7067 break;
7068 case opHypot:
7069 func = &hypot_ka;
7070 break;
7071 case opHypotx:
7072 func = &hypotx_ka;
7073 break;
7074 case opPow:
7075 func = &pow_ka_nova;
7076 break;
7077 case opRing1:
7078 func = &ring1_ka;
7079 break;
7080 case opRing2:
7081 func = &ring2_ka;
7082 break;
7083 case opRing3:
7084 func = &ring3_ka;
7085 break;
7086 case opRing4:
7087 func = &ring4_ka;
7088 break;
7089 case opDifSqr:
7090 func = &difsqr_ka_nova;
7091 break;
7092 case opSumSqr:
7093 func = &sumsqr_ka_nova;
7094 break;
7095 case opSqrSum:
7096 func = &sqrsum_ka_nova;
7097 break;
7098 case opSqrDif:
7099 func = &sqrdif_ka_nova;
7100 break;
7101 case opAbsDif:
7102 func = &absdif_ka;
7103 break;
7104 case opThresh:
7105 func = &thresh_ka;
7106 break;
7107 case opAMClip:
7108 func = &amclip_ka;
7109 break;
7110 case opScaleNeg:
7111 func = &scaleneg_ka;
7112 break;
7113 case opClip2:
7114 func = &clip2_ka_nova;
7115 break;
7116 case opFold2:
7117 func = &fold2_ka;
7118 break;
7119 case opWrap2:
7120 func = &wrap2_ka;
7121 break;
7122 case opExcess:
7123 func = &excess_ka;
7124 break;
7125 case opRandRange:
7126 func = &rrand_ka;
7127 break;
7128 case opExpRandRange:
7129 func = &exprand_ka;
7130 break;
7131 // case opFirstArg : func = &firstarg_aa; break;
7132 // case opSecondArg : func = &secondarg_aa; break;
7133 default:
7134 func = &add_ka;
7135 break;
7136 }
7137 } else {
7138 // this should have been caught by mBufLength == 1
7139 func = &zero_aa;
7140 }
7141 break;
7142 case calc_ScalarRate:
7143 if (rateB == calc_FullRate) {
7144 switch (unit->mSpecialIndex) {
7145 // case opSilence2 : func = &zero_aa; break;
7146 case opAdd:
7147 func = &add_ia_nova;
7148 break;
7149 case opSub:
7150 func = &sub_ia_nova;
7151 break;
7152 case opMul:
7153 func = &mul_ia_nova;
7154 break;
7155 case opFDiv:
7156 func = &div_ia_nova;
7157 break;
7158 case opIDiv:
7159 func = &idiv_ia;
7160 break;
7161 case opMod:
7162 func = &mod_ia;
7163 break;
7164 case opEQ:
7165 func = &eq_ia_nova;
7166 break;
7167 case opNE:
7168 func = &neq_ia_nova;
7169 break;
7170 case opLT:
7171 func = <_ia_nova;
7172 break;
7173 case opGT:
7174 func = >_ia_nova;
7175 break;
7176 case opLE:
7177 func = &le_ia_nova;
7178 break;
7179 case opGE:
7180 func = &ge_ia_nova;
7181 break;
7182 case opMin:
7183 func = &min_ia_nova;
7184 break;
7185 case opMax:
7186 func = &max_ia_nova;
7187 break;
7188 case opBitAnd:
7189 func = &and_ia;
7190 break;
7191 case opBitOr:
7192 func = &or_ia;
7193 break;
7194 case opBitXor:
7195 func = &xor_ia;
7196 break;
7197 case opShiftRight:
7198 func = &rightShift_ia;
7199 break;
7200 case opShiftLeft:
7201 func = &leftShift_ia;
7202 break;
7203 case opLCM:
7204 func = &lcm_ia;
7205 break;
7206 case opGCD:
7207 func = &gcd_ia;
7208 break;
7209 case opRound:
7210 func = &round_ia;
7211 break;
7212 case opRoundUp:
7213 func = &roundUp_ia;
7214 break;
7215 case opTrunc:
7216 func = &trunc_ia;
7217 break;
7218 case opAtan2:
7219 func = &atan2_ia;
7220 break;
7221 case opHypot:
7222 func = &hypot_ia;
7223 break;
7224 case opHypotx:
7225 func = &hypotx_ia;
7226 break;
7227 case opPow:
7228 func = &pow_ia_nova;
7229 break;
7230 case opRing1:
7231 func = &ring1_ia_nova;
7232 break;
7233 case opRing2:
7234 func = &ring2_ia_nova;
7235 break;
7236 case opRing3:
7237 func = &ring3_ia_nova;
7238 break;
7239 case opRing4:
7240 func = &ring4_ia_nova;
7241 break;
7242 case opDifSqr:
7243 func = &difsqr_ia_nova;
7244 break;
7245 case opSumSqr:
7246 func = &sumsqr_ia_nova;
7247 break;
7248 case opSqrSum:
7249 func = &sqrsum_ia_nova;
7250 break;
7251 case opSqrDif:
7252 func = &sqrdif_ia_nova;
7253 break;
7254 case opAbsDif:
7255 func = &absdif_ia;
7256 break;
7257 case opThresh:
7258 func = &thresh_ia;
7259 break;
7260 case opAMClip:
7261 func = &amclip_ia;
7262 break;
7263 case opScaleNeg:
7264 func = &scaleneg_ia;
7265 break;
7266 case opClip2:
7267 func = &clip2_ia_nova;
7268 break;
7269 case opFold2:
7270 func = &fold2_ia;
7271 break;
7272 case opWrap2:
7273 func = &wrap2_ia;
7274 break;
7275 case opExcess:
7276 func = &excess_ia;
7277 break;
7278 case opRandRange:
7279 func = &rrand_ia;
7280 break;
7281 case opExpRandRange:
7282 func = &rrand_ia;
7283 break;
7284 // case opFirstArg : func = &firstarg_aa; break;
7285 // case opSecondArg : func = &secondarg_aa; break;
7286 default:
7287 func = &add_ia;
7288 break;
7289 }
7290 } else {
7291 // this should have been caught by mBufLength == 1
7292 func = &zero_aa;
7293 }
7294 break;
7295 }
7296
7297 return func;
7298 }
7299
7300 #endif
7301
ChooseOperatorFunc(BinaryOpUGen * unit)7302 bool ChooseOperatorFunc(BinaryOpUGen* unit) {
7303 // Print("->ChooseOperatorFunc %d\n", unit->mSpecialIndex);
7304 BinaryOpFunc func = &zero_aa;
7305 bool ret = false;
7306
7307 if (BUFLENGTH == 1) {
7308 if (unit->mCalcRate == calc_DemandRate) {
7309 func = ChooseDemandFunc(unit);
7310 } else {
7311 func = ChooseOneSampleFunc(unit);
7312 }
7313 #if defined(NOVA_SIMD)
7314 } else if (boost::alignment::is_aligned(BUFLENGTH, 16)) {
7315 /* select normal function for initialization */
7316 func = ChooseNormalFunc(unit);
7317 func(unit, 1);
7318
7319 /* select simd function */
7320 func = ChooseNovaSimdFunc(unit);
7321 ret = true;
7322 #endif
7323 } else {
7324 func = ChooseNormalFunc(unit);
7325 }
7326 unit->mCalcFunc = (UnitCalcFunc)func;
7327 // Print("<-ChooseOperatorFunc %p\n", func);
7328 // Print("calc %d\n", unit->mCalcRate);
7329 return ret;
7330 }
7331
7332
7333 ////////////////////////////////////////////////////////////////////////////////////////////////////////
7334
7335
PluginLoad(BinaryOp)7336 PluginLoad(BinaryOp) {
7337 ft = inTable;
7338
7339 DefineSimpleUnit(BinaryOpUGen);
7340 }
7341