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