Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : #include "monetdb_config.h"
14 : #include "gdk.h"
15 : #include "gdk_private.h"
16 : #include "gdk_calc_private.h"
17 :
18 : /* ---------------------------------------------------------------------- */
19 : /* multiplication (any numeric type) */
20 :
21 : /* TYPE4 must be a type larger than both TYPE1 and TYPE2 so that
22 : * multiplying into it doesn't cause overflow */
23 : #define MUL_4TYPE(TYPE1, TYPE2, TYPE3, TYPE4, IF) \
24 : static BUN \
25 : mul_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1, \
26 : const TYPE2 *rgt, bool incr2, \
27 : TYPE3 *restrict dst, TYPE3 max, \
28 : struct canditer *restrict ci1, \
29 : struct canditer *restrict ci2, \
30 : oid candoff1, oid candoff2) \
31 : { \
32 : BUN nils = 0; \
33 : BUN i = 0, j = 0, ncand = ci1->ncand; \
34 : lng timeoffset = 0; \
35 : QryCtx *qry_ctx = MT_thread_get_qry_ctx(); \
36 : if (qry_ctx != NULL) { \
37 : timeoffset = (qry_ctx->starttime && qry_ctx->querytimeout) ? (qry_ctx->starttime + qry_ctx->querytimeout) : 0; \
38 : } \
39 : \
40 : if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) { \
41 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
42 : if (incr1) \
43 : i = canditer_next_dense(ci1) - candoff1; \
44 : if (incr2) \
45 : j = canditer_next_dense(ci2) - candoff2; \
46 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
47 : dst[k] = TYPE3##_nil; \
48 : nils++; \
49 : } else { \
50 : MUL##IF##4_WITH_CHECK(lft[i], rgt[j], \
51 : TYPE3, dst[k], \
52 : max, \
53 : TYPE4, \
54 : ON_OVERFLOW(TYPE1, TYPE2, "*")); \
55 : } \
56 : } \
57 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
58 : } else { \
59 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
60 : if (incr1) \
61 : i = canditer_next(ci1) - candoff1; \
62 : if (incr2) \
63 : j = canditer_next(ci2) - candoff2; \
64 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
65 : dst[k] = TYPE3##_nil; \
66 : nils++; \
67 : } else { \
68 : MUL##IF##4_WITH_CHECK(lft[i], rgt[j], \
69 : TYPE3, dst[k], \
70 : max, \
71 : TYPE4, \
72 : ON_OVERFLOW(TYPE1, TYPE2, "*")); \
73 : } \
74 : } \
75 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
76 : } \
77 : return nils; \
78 : }
79 :
80 : #define MUL_3TYPE_enlarge(TYPE1, TYPE2, TYPE3, IF) \
81 : static BUN \
82 : mul_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1, \
83 : const TYPE2 *rgt, bool incr2, \
84 : TYPE3 *restrict dst, TYPE3 max, \
85 : struct canditer *restrict ci1, \
86 : struct canditer *restrict ci2, \
87 : oid candoff1, oid candoff2) \
88 : { \
89 : BUN nils = 0; \
90 : BUN i = 0, j = 0, ncand = ci1->ncand; \
91 : const bool couldoverflow = (max < (TYPE3) GDK_##TYPE1##_max * (TYPE3) GDK_##TYPE2##_max); \
92 : lng timeoffset = 0; \
93 : QryCtx *qry_ctx = MT_thread_get_qry_ctx(); \
94 : if (qry_ctx != NULL) { \
95 : timeoffset = (qry_ctx->starttime && qry_ctx->querytimeout) ? (qry_ctx->starttime + qry_ctx->querytimeout) : 0; \
96 : } \
97 : \
98 : if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) { \
99 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
100 : if (incr1) \
101 : i = canditer_next_dense(ci1) - candoff1; \
102 : if (incr2) \
103 : j = canditer_next_dense(ci2) - candoff2; \
104 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
105 : dst[k] = TYPE3##_nil; \
106 : nils++; \
107 : } else if (couldoverflow) { \
108 : MUL##IF##4_WITH_CHECK(lft[i], rgt[j], \
109 : TYPE3, dst[k], \
110 : max, \
111 : TYPE3, \
112 : ON_OVERFLOW(TYPE1, TYPE2, "*")); \
113 : } else { \
114 : dst[k] = (TYPE3) lft[i] * rgt[j]; \
115 : } \
116 : } \
117 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
118 : } else { \
119 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
120 : if (incr1) \
121 : i = canditer_next(ci1) - candoff1; \
122 : if (incr2) \
123 : j = canditer_next(ci2) - candoff2; \
124 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
125 : dst[k] = TYPE3##_nil; \
126 : nils++; \
127 : } else if (couldoverflow) { \
128 : MUL##IF##4_WITH_CHECK(lft[i], rgt[j], \
129 : TYPE3, dst[k], \
130 : max, \
131 : TYPE3, \
132 : ON_OVERFLOW(TYPE1, TYPE2, "*")); \
133 : } else { \
134 : dst[k] = (TYPE3) lft[i] * rgt[j]; \
135 : } \
136 : } \
137 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
138 : } \
139 : return nils; \
140 : }
141 :
142 : #ifdef HAVE_HGE
143 :
144 : #define MUL_2TYPE_lng(TYPE1, TYPE2) MUL_4TYPE(TYPE1, TYPE2, lng, hge, I)
145 :
146 : #define MUL_2TYPE_hge(TYPE1, TYPE2) \
147 : static BUN \
148 : mul_##TYPE1##_##TYPE2##_hge(const TYPE1 *lft, bool incr1, \
149 : const TYPE2 *rgt, bool incr2, \
150 : hge *restrict dst, hge max, \
151 : struct canditer *restrict ci1, \
152 : struct canditer *restrict ci2, \
153 : oid candoff1, oid candoff2) \
154 : { \
155 : BUN nils = 0; \
156 : BUN i = 0, j = 0, ncand = ci1->ncand; \
157 : lng timeoffset = 0; \
158 : QryCtx *qry_ctx = MT_thread_get_qry_ctx(); \
159 : if (qry_ctx != NULL) { \
160 : timeoffset = (qry_ctx->starttime && qry_ctx->querytimeout) ? (qry_ctx->starttime + qry_ctx->querytimeout) : 0; \
161 : } \
162 : \
163 : if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) { \
164 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
165 : if (incr1) \
166 : i = canditer_next_dense(ci1) - candoff1; \
167 : if (incr2) \
168 : j = canditer_next_dense(ci2) - candoff2; \
169 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
170 : dst[k] = hge_nil; \
171 : nils++; \
172 : } else { \
173 : HGEMUL_CHECK(lft[i], rgt[j], \
174 : dst[k], \
175 : max, \
176 : ON_OVERFLOW(TYPE1, TYPE2, "*")); \
177 : } \
178 : } \
179 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
180 : } else { \
181 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
182 : if (incr1) \
183 : i = canditer_next(ci1) - candoff1; \
184 : if (incr2) \
185 : j = canditer_next(ci2) - candoff2; \
186 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
187 : dst[k] = hge_nil; \
188 : nils++; \
189 : } else { \
190 : HGEMUL_CHECK(lft[i], rgt[j], \
191 : dst[k], \
192 : max, \
193 : ON_OVERFLOW(TYPE1, TYPE2, "*")); \
194 : } \
195 : } \
196 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
197 : } \
198 : return nils; \
199 : }
200 :
201 : #else
202 :
203 : #define MUL_2TYPE_lng(TYPE1, TYPE2) \
204 : static BUN \
205 : mul_##TYPE1##_##TYPE2##_lng(const TYPE1 *lft, bool incr1, \
206 : const TYPE2 *rgt, bool incr2, \
207 : lng *restrict dst, lng max, \
208 : struct canditer *restrict ci1, \
209 : struct canditer *restrict ci2, \
210 : oid candoff1, oid candoff2) \
211 : { \
212 : BUN nils = 0; \
213 : BUN i = 0, j = 0, ncand = ci1->ncand; \
214 : lng timeoffset = 0; \
215 : QryCtx *qry_ctx = MT_thread_get_qry_ctx(); \
216 : if (qry_ctx != NULL) { \
217 : timeoffset = (qry_ctx->starttime && qry_ctx->querytimeout) ? (qry_ctx->starttime + qry_ctx->querytimeout) : 0; \
218 : } \
219 : \
220 : if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) { \
221 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
222 : if (incr1) \
223 : i = canditer_next_dense(ci1) - candoff1; \
224 : if (incr2) \
225 : j = canditer_next_dense(ci2) - candoff2; \
226 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
227 : dst[k] = lng_nil; \
228 : nils++; \
229 : } else { \
230 : LNGMUL_CHECK(lft[i], rgt[j], \
231 : dst[k], \
232 : max, \
233 : ON_OVERFLOW(TYPE1, TYPE2, "*")); \
234 : } \
235 : } \
236 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
237 : } else { \
238 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
239 : if (incr1) \
240 : i = canditer_next(ci1) - candoff1; \
241 : if (incr2) \
242 : j = canditer_next(ci2) - candoff2; \
243 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
244 : dst[k] = lng_nil; \
245 : nils++; \
246 : } else { \
247 : LNGMUL_CHECK(lft[i], rgt[j], \
248 : dst[k], \
249 : max, \
250 : ON_OVERFLOW(TYPE1, TYPE2, "*")); \
251 : } \
252 : } \
253 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
254 : } \
255 : return nils; \
256 : }
257 :
258 : #endif
259 :
260 : #define MUL_2TYPE_float(TYPE1, TYPE2, TYPE3) \
261 : static BUN \
262 : mul_##TYPE1##_##TYPE2##_##TYPE3(const TYPE1 *lft, bool incr1, \
263 : const TYPE2 *rgt, bool incr2, \
264 : TYPE3 *restrict dst, TYPE3 max, \
265 : struct canditer *restrict ci1, \
266 : struct canditer *restrict ci2, \
267 : oid candoff1, oid candoff2) \
268 : { \
269 : BUN nils = 0; \
270 : BUN i = 0, j = 0, ncand = ci1->ncand; \
271 : lng timeoffset = 0; \
272 : QryCtx *qry_ctx = MT_thread_get_qry_ctx(); \
273 : if (qry_ctx != NULL) { \
274 : timeoffset = (qry_ctx->starttime && qry_ctx->querytimeout) ? (qry_ctx->starttime + qry_ctx->querytimeout) : 0; \
275 : } \
276 : \
277 : if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) { \
278 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
279 : if (incr1) \
280 : i = canditer_next_dense(ci1) - candoff1; \
281 : if (incr2) \
282 : j = canditer_next_dense(ci2) - candoff2; \
283 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
284 : dst[k] = TYPE3##_nil; \
285 : nils++; \
286 : } else { \
287 : /* only check for overflow, not for underflow */ \
288 : dst[k] = (TYPE3) (lft[i] * rgt[j]); \
289 : if (isinf(dst[k]) || ABSOLUTE(dst[k]) > max) { \
290 : ON_OVERFLOW(TYPE1, TYPE2, "*"); \
291 : } \
292 : } \
293 : } \
294 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
295 : } else { \
296 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
297 : if (incr1) \
298 : i = canditer_next(ci1) - candoff1; \
299 : if (incr2) \
300 : j = canditer_next(ci2) - candoff2; \
301 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
302 : dst[k] = TYPE3##_nil; \
303 : nils++; \
304 : } else { \
305 : /* only check for overflow, not for underflow */ \
306 : dst[k] = (TYPE3) (lft[i] * rgt[j]); \
307 : if (isinf(dst[k]) || ABSOLUTE(dst[k]) > max) { \
308 : ON_OVERFLOW(TYPE1, TYPE2, "*"); \
309 : } \
310 : } \
311 : } \
312 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
313 : } \
314 : return nils; \
315 : }
316 :
317 : #define MUL_INT_FLT_INT(TYPE1, TYPE2, TYPE3) \
318 : static BUN \
319 : mul_##TYPE1##_##TYPE2##_##TYPE3( \
320 : const TYPE1 *lft, bool incr1, const TYPE2 *rgt, bool incr2, \
321 : TYPE3 *restrict dst, TYPE3 max, \
322 : struct canditer *restrict ci1, struct canditer *restrict ci2, \
323 : oid candoff1, oid candoff2) \
324 : { \
325 : BUN nils = 0; \
326 : BUN i = 0, j = 0, ncand = ci1->ncand; \
327 : lng timeoffset = 0; \
328 : QryCtx *qry_ctx = MT_thread_get_qry_ctx(); \
329 : if (qry_ctx != NULL) { \
330 : timeoffset = (qry_ctx->starttime && qry_ctx->querytimeout) ? (qry_ctx->starttime + qry_ctx->querytimeout) : 0; \
331 : } \
332 : \
333 : if (ci1->tpe == cand_dense && ci2->tpe == cand_dense) { \
334 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
335 : if (incr1) \
336 : i = canditer_next_dense(ci1) - candoff1; \
337 : if (incr2) \
338 : j = canditer_next_dense(ci2) - candoff2; \
339 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
340 : dst[k] = TYPE3##_nil; \
341 : nils++; \
342 : } else if (lft[i] == 0 || rgt[j] == 0) { \
343 : dst[k] = 0; \
344 : } else if (max / fabs(rgt[j]) < abs##TYPE1(lft[i])) { \
345 : ON_OVERFLOW(TYPE1, TYPE2, "*"); \
346 : } else { \
347 : ldouble m = lft[i] * (ldouble) rgt[j]; \
348 : dst[k] = (TYPE3) rounddbl(m); \
349 : } \
350 : } \
351 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
352 : } else { \
353 : TIMEOUT_LOOP_IDX_DECL(k, ncand, timeoffset) { \
354 : if (incr1) \
355 : i = canditer_next(ci1) - candoff1; \
356 : if (incr2) \
357 : j = canditer_next(ci2) - candoff2; \
358 : if (is_##TYPE1##_nil(lft[i]) || is_##TYPE2##_nil(rgt[j])) { \
359 : dst[k] = TYPE3##_nil; \
360 : nils++; \
361 : } else if (lft[i] == 0 || rgt[j] == 0) { \
362 : dst[k] = 0; \
363 : } else if (max / fabs(rgt[j]) < abs##TYPE1(lft[i])) { \
364 : ON_OVERFLOW(TYPE1, TYPE2, "*"); \
365 : } else { \
366 : ldouble m = lft[i] * (ldouble) rgt[j]; \
367 : dst[k] = (TYPE3) rounddbl(m); \
368 : } \
369 : } \
370 : TIMEOUT_CHECK(timeoffset, TIMEOUT_HANDLER(BUN_NONE)); \
371 : } \
372 : return nils; \
373 : }
374 :
375 0 : MUL_INT_FLT_INT(bte, flt, bte)
376 0 : MUL_INT_FLT_INT(bte, flt, sht)
377 0 : MUL_INT_FLT_INT(bte, flt, int)
378 0 : MUL_INT_FLT_INT(bte, flt, lng)
379 0 : MUL_INT_FLT_INT(sht, flt, bte)
380 0 : MUL_INT_FLT_INT(sht, flt, sht)
381 0 : MUL_INT_FLT_INT(sht, flt, int)
382 0 : MUL_INT_FLT_INT(sht, flt, lng)
383 0 : MUL_INT_FLT_INT(int, flt, bte)
384 0 : MUL_INT_FLT_INT(int, flt, sht)
385 4 : MUL_INT_FLT_INT(int, flt, int)
386 4 : MUL_INT_FLT_INT(int, flt, lng)
387 0 : MUL_INT_FLT_INT(lng, flt, bte)
388 0 : MUL_INT_FLT_INT(lng, flt, sht)
389 0 : MUL_INT_FLT_INT(lng, flt, int)
390 8 : MUL_INT_FLT_INT(lng, flt, lng)
391 : #ifdef HAVE_HGE
392 0 : MUL_INT_FLT_INT(bte, flt, hge)
393 0 : MUL_INT_FLT_INT(sht, flt, hge)
394 0 : MUL_INT_FLT_INT(int, flt, hge)
395 0 : MUL_INT_FLT_INT(lng, flt, hge)
396 0 : MUL_INT_FLT_INT(hge, flt, bte)
397 0 : MUL_INT_FLT_INT(hge, flt, sht)
398 0 : MUL_INT_FLT_INT(hge, flt, int)
399 0 : MUL_INT_FLT_INT(hge, flt, lng)
400 0 : MUL_INT_FLT_INT(hge, flt, hge)
401 : #endif
402 :
403 0 : MUL_INT_FLT_INT(bte, dbl, bte)
404 0 : MUL_INT_FLT_INT(bte, dbl, sht)
405 0 : MUL_INT_FLT_INT(bte, dbl, int)
406 0 : MUL_INT_FLT_INT(bte, dbl, lng)
407 0 : MUL_INT_FLT_INT(sht, dbl, bte)
408 0 : MUL_INT_FLT_INT(sht, dbl, sht)
409 0 : MUL_INT_FLT_INT(sht, dbl, int)
410 0 : MUL_INT_FLT_INT(sht, dbl, lng)
411 0 : MUL_INT_FLT_INT(int, dbl, bte)
412 0 : MUL_INT_FLT_INT(int, dbl, sht)
413 28 : MUL_INT_FLT_INT(int, dbl, int)
414 0 : MUL_INT_FLT_INT(int, dbl, lng)
415 0 : MUL_INT_FLT_INT(lng, dbl, bte)
416 0 : MUL_INT_FLT_INT(lng, dbl, sht)
417 0 : MUL_INT_FLT_INT(lng, dbl, int)
418 16 : MUL_INT_FLT_INT(lng, dbl, lng)
419 : #ifdef HAVE_HGE
420 0 : MUL_INT_FLT_INT(bte, dbl, hge)
421 0 : MUL_INT_FLT_INT(sht, dbl, hge)
422 0 : MUL_INT_FLT_INT(int, dbl, hge)
423 0 : MUL_INT_FLT_INT(lng, dbl, hge)
424 0 : MUL_INT_FLT_INT(hge, dbl, bte)
425 0 : MUL_INT_FLT_INT(hge, dbl, sht)
426 0 : MUL_INT_FLT_INT(hge, dbl, int)
427 0 : MUL_INT_FLT_INT(hge, dbl, lng)
428 0 : MUL_INT_FLT_INT(hge, dbl, hge)
429 : #endif
430 :
431 664 : MUL_4TYPE(bte, bte, bte, sht, I)
432 564 : MUL_3TYPE_enlarge(bte, bte, sht, I)
433 53 : MUL_3TYPE_enlarge(bte, bte, int, I)
434 0 : MUL_3TYPE_enlarge(bte, bte, lng, I)
435 : #ifdef HAVE_HGE
436 0 : MUL_3TYPE_enlarge(bte, bte, hge, I)
437 : #endif
438 0 : MUL_3TYPE_enlarge(bte, bte, flt, F)
439 0 : MUL_3TYPE_enlarge(bte, bte, dbl, F)
440 0 : MUL_4TYPE(bte, sht, sht, int, I)
441 8 : MUL_3TYPE_enlarge(bte, sht, int, I)
442 0 : MUL_3TYPE_enlarge(bte, sht, lng, I)
443 : #ifdef HAVE_HGE
444 0 : MUL_3TYPE_enlarge(bte, sht, hge, I)
445 : #endif
446 0 : MUL_3TYPE_enlarge(bte, sht, flt, F)
447 0 : MUL_3TYPE_enlarge(bte, sht, dbl, F)
448 4000360 : MUL_4TYPE(bte, int, int, lng, I)
449 18251 : MUL_3TYPE_enlarge(bte, int, lng, I)
450 : #ifdef HAVE_HGE
451 0 : MUL_3TYPE_enlarge(bte, int, hge, I)
452 : #endif
453 0 : MUL_3TYPE_enlarge(bte, int, flt, F)
454 0 : MUL_3TYPE_enlarge(bte, int, dbl, F)
455 4 : MUL_2TYPE_lng(bte, lng)
456 : #ifdef HAVE_HGE
457 59156 : MUL_3TYPE_enlarge(bte, lng, hge, I)
458 : #endif
459 0 : MUL_3TYPE_enlarge(bte, lng, flt, F)
460 0 : MUL_3TYPE_enlarge(bte, lng, dbl, F)
461 : #ifdef HAVE_HGE
462 115 : MUL_2TYPE_hge(bte, hge)
463 0 : MUL_3TYPE_enlarge(bte, hge, flt, F)
464 0 : MUL_3TYPE_enlarge(bte, hge, dbl, F)
465 : #endif
466 0 : MUL_2TYPE_float(bte, flt, flt)
467 0 : MUL_3TYPE_enlarge(bte, flt, dbl, F)
468 0 : MUL_2TYPE_float(bte, dbl, dbl)
469 108 : MUL_4TYPE(sht, bte, sht, int, I)
470 120 : MUL_3TYPE_enlarge(sht, bte, int, I)
471 3900364 : MUL_3TYPE_enlarge(sht, bte, lng, I)
472 : #ifdef HAVE_HGE
473 0 : MUL_3TYPE_enlarge(sht, bte, hge, I)
474 : #endif
475 0 : MUL_3TYPE_enlarge(sht, bte, flt, F)
476 0 : MUL_3TYPE_enlarge(sht, bte, dbl, F)
477 4 : MUL_4TYPE(sht, sht, sht, int, I)
478 3933136 : MUL_3TYPE_enlarge(sht, sht, int, I)
479 24 : MUL_3TYPE_enlarge(sht, sht, lng, I)
480 : #ifdef HAVE_HGE
481 0 : MUL_3TYPE_enlarge(sht, sht, hge, I)
482 : #endif
483 0 : MUL_3TYPE_enlarge(sht, sht, flt, F)
484 0 : MUL_3TYPE_enlarge(sht, sht, dbl, F)
485 4 : MUL_4TYPE(sht, int, int, lng, I)
486 32 : MUL_3TYPE_enlarge(sht, int, lng, I)
487 : #ifdef HAVE_HGE
488 0 : MUL_3TYPE_enlarge(sht, int, hge, I)
489 : #endif
490 0 : MUL_3TYPE_enlarge(sht, int, flt, F)
491 0 : MUL_3TYPE_enlarge(sht, int, dbl, F)
492 0 : MUL_2TYPE_lng(sht, lng)
493 : #ifdef HAVE_HGE
494 8 : MUL_3TYPE_enlarge(sht, lng, hge, I)
495 : #endif
496 0 : MUL_3TYPE_enlarge(sht, lng, flt, F)
497 0 : MUL_3TYPE_enlarge(sht, lng, dbl, F)
498 : #ifdef HAVE_HGE
499 12 : MUL_2TYPE_hge(sht, hge)
500 0 : MUL_3TYPE_enlarge(sht, hge, flt, F)
501 0 : MUL_3TYPE_enlarge(sht, hge, dbl, F)
502 : #endif
503 0 : MUL_2TYPE_float(sht, flt, flt)
504 0 : MUL_3TYPE_enlarge(sht, flt, dbl, F)
505 0 : MUL_2TYPE_float(sht, dbl, dbl)
506 56922 : MUL_4TYPE(int, bte, int, lng, I)
507 6109110 : MUL_3TYPE_enlarge(int, bte, lng, I)
508 : #ifdef HAVE_HGE
509 0 : MUL_3TYPE_enlarge(int, bte, hge, I)
510 : #endif
511 0 : MUL_3TYPE_enlarge(int, bte, flt, F)
512 0 : MUL_3TYPE_enlarge(int, bte, dbl, F)
513 8058 : MUL_4TYPE(int, sht, int, lng, I)
514 529873 : MUL_3TYPE_enlarge(int, sht, lng, I)
515 : #ifdef HAVE_HGE
516 0 : MUL_3TYPE_enlarge(int, sht, hge, I)
517 : #endif
518 0 : MUL_3TYPE_enlarge(int, sht, flt, F)
519 0 : MUL_3TYPE_enlarge(int, sht, dbl, F)
520 283 : MUL_4TYPE(int, int, int, lng, I)
521 28 : MUL_3TYPE_enlarge(int, int, lng, I)
522 : #ifdef HAVE_HGE
523 19116 : MUL_3TYPE_enlarge(int, int, hge, I)
524 : #endif
525 0 : MUL_3TYPE_enlarge(int, int, flt, F)
526 0 : MUL_3TYPE_enlarge(int, int, dbl, F)
527 0 : MUL_2TYPE_lng(int, lng)
528 : #ifdef HAVE_HGE
529 102 : MUL_3TYPE_enlarge(int, lng, hge, I)
530 : #endif
531 0 : MUL_3TYPE_enlarge(int, lng, flt, F)
532 0 : MUL_3TYPE_enlarge(int, lng, dbl, F)
533 : #ifdef HAVE_HGE
534 31 : MUL_2TYPE_hge(int, hge)
535 0 : MUL_3TYPE_enlarge(int, hge, flt, F)
536 0 : MUL_3TYPE_enlarge(int, hge, dbl, F)
537 : #endif
538 0 : MUL_2TYPE_float(int, flt, flt)
539 0 : MUL_3TYPE_enlarge(int, flt, dbl, F)
540 0 : MUL_2TYPE_float(int, dbl, dbl)
541 2004236 : MUL_2TYPE_lng(lng, bte)
542 : #ifdef HAVE_HGE
543 2119599 : MUL_3TYPE_enlarge(lng, bte, hge, I)
544 : #endif
545 0 : MUL_3TYPE_enlarge(lng, bte, flt, F)
546 0 : MUL_3TYPE_enlarge(lng, bte, dbl, F)
547 12 : MUL_2TYPE_lng(lng, sht)
548 : #ifdef HAVE_HGE
549 16827 : MUL_3TYPE_enlarge(lng, sht, hge, I)
550 : #endif
551 0 : MUL_3TYPE_enlarge(lng, sht, flt, F)
552 0 : MUL_3TYPE_enlarge(lng, sht, dbl, F)
553 112 : MUL_2TYPE_lng(lng, int)
554 : #ifdef HAVE_HGE
555 4033569 : MUL_3TYPE_enlarge(lng, int, hge, I)
556 : #endif
557 0 : MUL_3TYPE_enlarge(lng, int, flt, F)
558 0 : MUL_3TYPE_enlarge(lng, int, dbl, F)
559 130 : MUL_2TYPE_lng(lng, lng)
560 : #ifdef HAVE_HGE
561 20675183 : MUL_3TYPE_enlarge(lng, lng, hge, I)
562 : #endif
563 0 : MUL_3TYPE_enlarge(lng, lng, flt, F)
564 0 : MUL_3TYPE_enlarge(lng, lng, dbl, F)
565 : #ifdef HAVE_HGE
566 27 : MUL_2TYPE_hge(lng, hge)
567 0 : MUL_3TYPE_enlarge(lng, hge, flt, F)
568 0 : MUL_3TYPE_enlarge(lng, hge, dbl, F)
569 : #endif
570 0 : MUL_2TYPE_float(lng, flt, flt)
571 0 : MUL_3TYPE_enlarge(lng, flt, dbl, F)
572 0 : MUL_2TYPE_float(lng, dbl, dbl)
573 : #ifdef HAVE_HGE
574 3775020 : MUL_2TYPE_hge(hge, bte)
575 0 : MUL_3TYPE_enlarge(hge, bte, flt, F)
576 0 : MUL_3TYPE_enlarge(hge, bte, dbl, F)
577 16 : MUL_2TYPE_hge(hge, sht)
578 0 : MUL_3TYPE_enlarge(hge, sht, flt, F)
579 0 : MUL_3TYPE_enlarge(hge, sht, dbl, F)
580 10371 : MUL_2TYPE_hge(hge, int)
581 0 : MUL_3TYPE_enlarge(hge, int, flt, F)
582 0 : MUL_3TYPE_enlarge(hge, int, dbl, F)
583 59429 : MUL_2TYPE_hge(hge, lng)
584 0 : MUL_3TYPE_enlarge(hge, lng, flt, F)
585 0 : MUL_3TYPE_enlarge(hge, lng, dbl, F)
586 197474 : MUL_2TYPE_hge(hge, hge)
587 0 : MUL_3TYPE_enlarge(hge, hge, flt, F)
588 0 : MUL_3TYPE_enlarge(hge, hge, dbl, F)
589 0 : MUL_2TYPE_float(hge, flt, flt)
590 0 : MUL_3TYPE_enlarge(hge, flt, dbl, F)
591 0 : MUL_2TYPE_float(hge, dbl, dbl)
592 : #endif
593 0 : MUL_2TYPE_float(flt, bte, flt)
594 0 : MUL_3TYPE_enlarge(flt, bte, dbl, F)
595 0 : MUL_2TYPE_float(flt, sht, flt)
596 0 : MUL_3TYPE_enlarge(flt, sht, dbl, F)
597 0 : MUL_2TYPE_float(flt, int, flt)
598 0 : MUL_3TYPE_enlarge(flt, int, dbl, F)
599 0 : MUL_2TYPE_float(flt, lng, flt)
600 0 : MUL_3TYPE_enlarge(flt, lng, dbl, F)
601 : #ifdef HAVE_HGE
602 0 : MUL_2TYPE_float(flt, hge, flt)
603 0 : MUL_3TYPE_enlarge(flt, hge, dbl, F)
604 : #endif
605 75 : MUL_2TYPE_float(flt, flt, flt)
606 0 : MUL_3TYPE_enlarge(flt, flt, dbl, F)
607 0 : MUL_2TYPE_float(flt, dbl, dbl)
608 0 : MUL_2TYPE_float(dbl, bte, dbl)
609 0 : MUL_2TYPE_float(dbl, sht, dbl)
610 0 : MUL_2TYPE_float(dbl, int, dbl)
611 0 : MUL_2TYPE_float(dbl, lng, dbl)
612 : #ifdef HAVE_HGE
613 0 : MUL_2TYPE_float(dbl, hge, dbl)
614 : #endif
615 0 : MUL_2TYPE_float(dbl, flt, dbl)
616 708930 : MUL_2TYPE_float(dbl, dbl, dbl)
617 :
618 : static BUN
619 39192 : mul_typeswitchloop(const void *lft, int tp1, bool incr1,
620 : const void *rgt, int tp2, bool incr2,
621 : void *restrict dst, int tp,
622 : struct canditer *restrict ci1,
623 : struct canditer *restrict ci2,
624 : oid candoff1, oid candoff2,
625 : const char *func)
626 : {
627 39192 : BUN nils;
628 :
629 39192 : tp1 = ATOMbasetype(tp1);
630 39192 : tp2 = ATOMbasetype(tp2);
631 39192 : tp = ATOMbasetype(tp);
632 39192 : switch (tp1) {
633 486 : case TYPE_bte:
634 486 : switch (tp2) {
635 379 : case TYPE_bte:
636 379 : switch (tp) {
637 256 : case TYPE_bte:
638 256 : nils = mul_bte_bte_bte(lft, incr1, rgt, incr2,
639 : dst, GDK_bte_max,
640 : ci1, ci2, candoff1, candoff2);
641 256 : break;
642 117 : case TYPE_sht:
643 117 : nils = mul_bte_bte_sht(lft, incr1, rgt, incr2,
644 : dst, GDK_sht_max,
645 : ci1, ci2, candoff1, candoff2);
646 117 : break;
647 6 : case TYPE_int:
648 6 : nils = mul_bte_bte_int(lft, incr1, rgt, incr2,
649 : dst, GDK_int_max,
650 : ci1, ci2, candoff1, candoff2);
651 6 : break;
652 0 : case TYPE_lng:
653 0 : nils = mul_bte_bte_lng(lft, incr1, rgt, incr2,
654 : dst, GDK_lng_max,
655 : ci1, ci2, candoff1, candoff2);
656 0 : break;
657 : #ifdef HAVE_HGE
658 0 : case TYPE_hge:
659 0 : nils = mul_bte_bte_hge(lft, incr1, rgt, incr2,
660 : dst, GDK_hge_max,
661 : ci1, ci2, candoff1, candoff2);
662 0 : break;
663 : #endif
664 0 : case TYPE_flt:
665 0 : nils = mul_bte_bte_flt(lft, incr1, rgt, incr2,
666 : dst, GDK_flt_max,
667 : ci1, ci2, candoff1, candoff2);
668 0 : break;
669 0 : case TYPE_dbl:
670 0 : nils = mul_bte_bte_dbl(lft, incr1, rgt, incr2,
671 : dst, GDK_dbl_max,
672 : ci1, ci2, candoff1, candoff2);
673 0 : break;
674 0 : default:
675 0 : goto unsupported;
676 : }
677 : break;
678 2 : case TYPE_sht:
679 2 : switch (tp) {
680 0 : case TYPE_sht:
681 0 : nils = mul_bte_sht_sht(lft, incr1, rgt, incr2,
682 : dst, GDK_sht_max,
683 : ci1, ci2, candoff1, candoff2);
684 0 : break;
685 2 : case TYPE_int:
686 2 : nils = mul_bte_sht_int(lft, incr1, rgt, incr2,
687 : dst, GDK_int_max,
688 : ci1, ci2, candoff1, candoff2);
689 2 : break;
690 0 : case TYPE_lng:
691 0 : nils = mul_bte_sht_lng(lft, incr1, rgt, incr2,
692 : dst, GDK_lng_max,
693 : ci1, ci2, candoff1, candoff2);
694 0 : break;
695 : #ifdef HAVE_HGE
696 0 : case TYPE_hge:
697 0 : nils = mul_bte_sht_hge(lft, incr1, rgt, incr2,
698 : dst, GDK_hge_max,
699 : ci1, ci2, candoff1, candoff2);
700 0 : break;
701 : #endif
702 0 : case TYPE_flt:
703 0 : nils = mul_bte_sht_flt(lft, incr1, rgt, incr2,
704 : dst, GDK_flt_max,
705 : ci1, ci2, candoff1, candoff2);
706 0 : break;
707 0 : case TYPE_dbl:
708 0 : nils = mul_bte_sht_dbl(lft, incr1, rgt, incr2,
709 : dst, GDK_dbl_max,
710 : ci1, ci2, candoff1, candoff2);
711 0 : break;
712 0 : default:
713 0 : goto unsupported;
714 : }
715 : break;
716 69 : case TYPE_int:
717 69 : switch (tp) {
718 40 : case TYPE_int:
719 40 : nils = mul_bte_int_int(lft, incr1, rgt, incr2,
720 : dst, GDK_int_max,
721 : ci1, ci2, candoff1, candoff2);
722 40 : break;
723 29 : case TYPE_lng:
724 29 : nils = mul_bte_int_lng(lft, incr1, rgt, incr2,
725 : dst, GDK_lng_max,
726 : ci1, ci2, candoff1, candoff2);
727 29 : break;
728 : #ifdef HAVE_HGE
729 0 : case TYPE_hge:
730 0 : nils = mul_bte_int_hge(lft, incr1, rgt, incr2,
731 : dst, GDK_hge_max,
732 : ci1, ci2, candoff1, candoff2);
733 0 : break;
734 : #endif
735 0 : case TYPE_flt:
736 0 : nils = mul_bte_int_flt(lft, incr1, rgt, incr2,
737 : dst, GDK_flt_max,
738 : ci1, ci2, candoff1, candoff2);
739 0 : break;
740 0 : case TYPE_dbl:
741 0 : nils = mul_bte_int_dbl(lft, incr1, rgt, incr2,
742 : dst, GDK_dbl_max,
743 : ci1, ci2, candoff1, candoff2);
744 0 : break;
745 0 : default:
746 0 : goto unsupported;
747 : }
748 : break;
749 25 : case TYPE_lng:
750 25 : switch (tp) {
751 1 : case TYPE_lng:
752 1 : nils = mul_bte_lng_lng(lft, incr1, rgt, incr2,
753 : dst, GDK_lng_max,
754 : ci1, ci2, candoff1, candoff2);
755 1 : break;
756 : #ifdef HAVE_HGE
757 24 : case TYPE_hge:
758 24 : nils = mul_bte_lng_hge(lft, incr1, rgt, incr2,
759 : dst, GDK_hge_max,
760 : ci1, ci2, candoff1, candoff2);
761 24 : break;
762 : #endif
763 0 : case TYPE_flt:
764 0 : nils = mul_bte_lng_flt(lft, incr1, rgt, incr2,
765 : dst, GDK_flt_max,
766 : ci1, ci2, candoff1, candoff2);
767 0 : break;
768 0 : case TYPE_dbl:
769 0 : nils = mul_bte_lng_dbl(lft, incr1, rgt, incr2,
770 : dst, GDK_dbl_max,
771 : ci1, ci2, candoff1, candoff2);
772 0 : break;
773 0 : default:
774 0 : goto unsupported;
775 : }
776 : break;
777 : #ifdef HAVE_HGE
778 11 : case TYPE_hge:
779 11 : switch (tp) {
780 11 : case TYPE_hge:
781 11 : nils = mul_bte_hge_hge(lft, incr1, rgt, incr2,
782 : dst, GDK_hge_max,
783 : ci1, ci2, candoff1, candoff2);
784 11 : break;
785 0 : case TYPE_flt:
786 0 : nils = mul_bte_hge_flt(lft, incr1, rgt, incr2,
787 : dst, GDK_flt_max,
788 : ci1, ci2, candoff1, candoff2);
789 0 : break;
790 0 : case TYPE_dbl:
791 0 : nils = mul_bte_hge_dbl(lft, incr1, rgt, incr2,
792 : dst, GDK_dbl_max,
793 : ci1, ci2, candoff1, candoff2);
794 0 : break;
795 0 : default:
796 0 : goto unsupported;
797 : }
798 : break;
799 : #endif
800 0 : case TYPE_flt:
801 0 : switch (tp) {
802 0 : case TYPE_bte:
803 0 : nils = mul_bte_flt_bte(lft, incr1, rgt, incr2,
804 : dst, GDK_bte_max,
805 : ci1, ci2,
806 : candoff1, candoff2);
807 0 : break;
808 0 : case TYPE_sht:
809 0 : nils = mul_bte_flt_sht(lft, incr1, rgt, incr2,
810 : dst, GDK_sht_max,
811 : ci1, ci2,
812 : candoff1, candoff2);
813 0 : break;
814 0 : case TYPE_int:
815 0 : nils = mul_bte_flt_int(lft, incr1, rgt, incr2,
816 : dst, GDK_int_max,
817 : ci1, ci2,
818 : candoff1, candoff2);
819 0 : break;
820 0 : case TYPE_lng:
821 0 : nils = mul_bte_flt_lng(lft, incr1, rgt, incr2,
822 : dst, GDK_lng_max,
823 : ci1, ci2,
824 : candoff1, candoff2);
825 0 : break;
826 : #ifdef HAVE_HGE
827 0 : case TYPE_hge:
828 0 : nils = mul_bte_flt_hge(lft, incr1, rgt, incr2,
829 : dst, GDK_hge_max,
830 : ci1, ci2,
831 : candoff1, candoff2);
832 0 : break;
833 : #endif
834 0 : case TYPE_flt:
835 0 : nils = mul_bte_flt_flt(lft, incr1, rgt, incr2,
836 : dst, GDK_flt_max,
837 : ci1, ci2, candoff1, candoff2);
838 0 : break;
839 0 : case TYPE_dbl:
840 0 : nils = mul_bte_flt_dbl(lft, incr1, rgt, incr2,
841 : dst, GDK_dbl_max,
842 : ci1, ci2, candoff1, candoff2);
843 0 : break;
844 0 : default:
845 0 : goto unsupported;
846 : }
847 : break;
848 0 : case TYPE_dbl:
849 0 : switch (tp) {
850 0 : case TYPE_bte:
851 0 : nils = mul_bte_dbl_bte(lft, incr1, rgt, incr2,
852 : dst, GDK_bte_max,
853 : ci1, ci2,
854 : candoff1, candoff2);
855 0 : break;
856 0 : case TYPE_sht:
857 0 : nils = mul_bte_dbl_sht(lft, incr1, rgt, incr2,
858 : dst, GDK_sht_max,
859 : ci1, ci2,
860 : candoff1, candoff2);
861 0 : break;
862 0 : case TYPE_int:
863 0 : nils = mul_bte_dbl_int(lft, incr1, rgt, incr2,
864 : dst, GDK_int_max,
865 : ci1, ci2,
866 : candoff1, candoff2);
867 0 : break;
868 0 : case TYPE_lng:
869 0 : nils = mul_bte_dbl_lng(lft, incr1, rgt, incr2,
870 : dst, GDK_lng_max,
871 : ci1, ci2,
872 : candoff1, candoff2);
873 0 : break;
874 : #ifdef HAVE_HGE
875 0 : case TYPE_hge:
876 0 : nils = mul_bte_dbl_hge(lft, incr1, rgt, incr2,
877 : dst, GDK_hge_max,
878 : ci1, ci2,
879 : candoff1, candoff2);
880 0 : break;
881 : #endif
882 0 : case TYPE_dbl:
883 0 : nils = mul_bte_dbl_dbl(lft, incr1, rgt, incr2,
884 : dst, GDK_dbl_max,
885 : ci1, ci2, candoff1, candoff2);
886 0 : break;
887 0 : default:
888 0 : goto unsupported;
889 : }
890 : break;
891 0 : default:
892 0 : goto unsupported;
893 : }
894 : break;
895 159 : case TYPE_sht:
896 159 : switch (tp2) {
897 98 : case TYPE_bte:
898 98 : switch (tp) {
899 27 : case TYPE_sht:
900 27 : nils = mul_sht_bte_sht(lft, incr1, rgt, incr2,
901 : dst, GDK_sht_max,
902 : ci1, ci2, candoff1, candoff2);
903 27 : break;
904 30 : case TYPE_int:
905 30 : nils = mul_sht_bte_int(lft, incr1, rgt, incr2,
906 : dst, GDK_int_max,
907 : ci1, ci2, candoff1, candoff2);
908 30 : break;
909 41 : case TYPE_lng:
910 41 : nils = mul_sht_bte_lng(lft, incr1, rgt, incr2,
911 : dst, GDK_lng_max,
912 : ci1, ci2, candoff1, candoff2);
913 41 : break;
914 : #ifdef HAVE_HGE
915 0 : case TYPE_hge:
916 0 : nils = mul_sht_bte_hge(lft, incr1, rgt, incr2,
917 : dst, GDK_hge_max,
918 : ci1, ci2, candoff1, candoff2);
919 0 : break;
920 : #endif
921 0 : case TYPE_flt:
922 0 : nils = mul_sht_bte_flt(lft, incr1, rgt, incr2,
923 : dst, GDK_flt_max,
924 : ci1, ci2, candoff1, candoff2);
925 0 : break;
926 0 : case TYPE_dbl:
927 0 : nils = mul_sht_bte_dbl(lft, incr1, rgt, incr2,
928 : dst, GDK_dbl_max,
929 : ci1, ci2, candoff1, candoff2);
930 0 : break;
931 0 : default:
932 0 : goto unsupported;
933 : }
934 : break;
935 48 : case TYPE_sht:
936 48 : switch (tp) {
937 1 : case TYPE_sht:
938 1 : nils = mul_sht_sht_sht(lft, incr1, rgt, incr2,
939 : dst, GDK_sht_max,
940 : ci1, ci2, candoff1, candoff2);
941 1 : break;
942 42 : case TYPE_int:
943 42 : nils = mul_sht_sht_int(lft, incr1, rgt, incr2,
944 : dst, GDK_int_max,
945 : ci1, ci2, candoff1, candoff2);
946 42 : break;
947 5 : case TYPE_lng:
948 5 : nils = mul_sht_sht_lng(lft, incr1, rgt, incr2,
949 : dst, GDK_lng_max,
950 : ci1, ci2, candoff1, candoff2);
951 5 : break;
952 : #ifdef HAVE_HGE
953 0 : case TYPE_hge:
954 0 : nils = mul_sht_sht_hge(lft, incr1, rgt, incr2,
955 : dst, GDK_hge_max,
956 : ci1, ci2, candoff1, candoff2);
957 0 : break;
958 : #endif
959 0 : case TYPE_flt:
960 0 : nils = mul_sht_sht_flt(lft, incr1, rgt, incr2,
961 : dst, GDK_flt_max,
962 : ci1, ci2, candoff1, candoff2);
963 0 : break;
964 0 : case TYPE_dbl:
965 0 : nils = mul_sht_sht_dbl(lft, incr1, rgt, incr2,
966 : dst, GDK_dbl_max,
967 : ci1, ci2, candoff1, candoff2);
968 0 : break;
969 0 : default:
970 0 : goto unsupported;
971 : }
972 : break;
973 8 : case TYPE_int:
974 8 : switch (tp) {
975 1 : case TYPE_int:
976 1 : nils = mul_sht_int_int(lft, incr1, rgt, incr2,
977 : dst, GDK_int_max,
978 : ci1, ci2, candoff1, candoff2);
979 1 : break;
980 7 : case TYPE_lng:
981 7 : nils = mul_sht_int_lng(lft, incr1, rgt, incr2,
982 : dst, GDK_lng_max,
983 : ci1, ci2, candoff1, candoff2);
984 7 : break;
985 : #ifdef HAVE_HGE
986 0 : case TYPE_hge:
987 0 : nils = mul_sht_int_hge(lft, incr1, rgt, incr2,
988 : dst, GDK_hge_max,
989 : ci1, ci2, candoff1, candoff2);
990 0 : break;
991 : #endif
992 0 : case TYPE_flt:
993 0 : nils = mul_sht_int_flt(lft, incr1, rgt, incr2,
994 : dst, GDK_flt_max,
995 : ci1, ci2, candoff1, candoff2);
996 0 : break;
997 0 : case TYPE_dbl:
998 0 : nils = mul_sht_int_dbl(lft, incr1, rgt, incr2,
999 : dst, GDK_dbl_max,
1000 : ci1, ci2, candoff1, candoff2);
1001 0 : break;
1002 0 : default:
1003 0 : goto unsupported;
1004 : }
1005 : break;
1006 2 : case TYPE_lng:
1007 2 : switch (tp) {
1008 0 : case TYPE_lng:
1009 0 : nils = mul_sht_lng_lng(lft, incr1, rgt, incr2,
1010 : dst, GDK_lng_max,
1011 : ci1, ci2, candoff1, candoff2);
1012 0 : break;
1013 : #ifdef HAVE_HGE
1014 2 : case TYPE_hge:
1015 2 : nils = mul_sht_lng_hge(lft, incr1, rgt, incr2,
1016 : dst, GDK_hge_max,
1017 : ci1, ci2, candoff1, candoff2);
1018 2 : break;
1019 : #endif
1020 0 : case TYPE_flt:
1021 0 : nils = mul_sht_lng_flt(lft, incr1, rgt, incr2,
1022 : dst, GDK_flt_max,
1023 : ci1, ci2, candoff1, candoff2);
1024 0 : break;
1025 0 : case TYPE_dbl:
1026 0 : nils = mul_sht_lng_dbl(lft, incr1, rgt, incr2,
1027 : dst, GDK_dbl_max,
1028 : ci1, ci2, candoff1, candoff2);
1029 0 : break;
1030 0 : default:
1031 0 : goto unsupported;
1032 : }
1033 : break;
1034 : #ifdef HAVE_HGE
1035 3 : case TYPE_hge:
1036 3 : switch (tp) {
1037 3 : case TYPE_hge:
1038 3 : nils = mul_sht_hge_hge(lft, incr1, rgt, incr2,
1039 : dst, GDK_hge_max,
1040 : ci1, ci2, candoff1, candoff2);
1041 3 : break;
1042 0 : case TYPE_flt:
1043 0 : nils = mul_sht_hge_flt(lft, incr1, rgt, incr2,
1044 : dst, GDK_flt_max,
1045 : ci1, ci2, candoff1, candoff2);
1046 0 : break;
1047 0 : case TYPE_dbl:
1048 0 : nils = mul_sht_hge_dbl(lft, incr1, rgt, incr2,
1049 : dst, GDK_dbl_max,
1050 : ci1, ci2, candoff1, candoff2);
1051 0 : break;
1052 0 : default:
1053 0 : goto unsupported;
1054 : }
1055 : break;
1056 : #endif
1057 0 : case TYPE_flt:
1058 0 : switch (tp) {
1059 0 : case TYPE_bte:
1060 0 : nils = mul_sht_flt_bte(lft, incr1, rgt, incr2,
1061 : dst, GDK_bte_max,
1062 : ci1, ci2,
1063 : candoff1, candoff2);
1064 0 : break;
1065 0 : case TYPE_sht:
1066 0 : nils = mul_sht_flt_sht(lft, incr1, rgt, incr2,
1067 : dst, GDK_sht_max,
1068 : ci1, ci2,
1069 : candoff1, candoff2);
1070 0 : break;
1071 0 : case TYPE_int:
1072 0 : nils = mul_sht_flt_int(lft, incr1, rgt, incr2,
1073 : dst, GDK_int_max,
1074 : ci1, ci2,
1075 : candoff1, candoff2);
1076 0 : break;
1077 0 : case TYPE_lng:
1078 0 : nils = mul_sht_flt_lng(lft, incr1, rgt, incr2,
1079 : dst, GDK_lng_max,
1080 : ci1, ci2,
1081 : candoff1, candoff2);
1082 0 : break;
1083 : #ifdef HAVE_HGE
1084 0 : case TYPE_hge:
1085 0 : nils = mul_sht_flt_hge(lft, incr1, rgt, incr2,
1086 : dst, GDK_hge_max,
1087 : ci1, ci2,
1088 : candoff1, candoff2);
1089 0 : break;
1090 : #endif
1091 0 : case TYPE_flt:
1092 0 : nils = mul_sht_flt_flt(lft, incr1, rgt, incr2,
1093 : dst, GDK_flt_max,
1094 : ci1, ci2, candoff1, candoff2);
1095 0 : break;
1096 0 : case TYPE_dbl:
1097 0 : nils = mul_sht_flt_dbl(lft, incr1, rgt, incr2,
1098 : dst, GDK_dbl_max,
1099 : ci1, ci2, candoff1, candoff2);
1100 0 : break;
1101 0 : default:
1102 0 : goto unsupported;
1103 : }
1104 : break;
1105 0 : case TYPE_dbl:
1106 0 : switch (tp) {
1107 0 : case TYPE_bte:
1108 0 : nils = mul_sht_dbl_bte(lft, incr1, rgt, incr2,
1109 : dst, GDK_bte_max,
1110 : ci1, ci2,
1111 : candoff1, candoff2);
1112 0 : break;
1113 0 : case TYPE_sht:
1114 0 : nils = mul_sht_dbl_sht(lft, incr1, rgt, incr2,
1115 : dst, GDK_sht_max,
1116 : ci1, ci2,
1117 : candoff1, candoff2);
1118 0 : break;
1119 0 : case TYPE_int:
1120 0 : nils = mul_sht_dbl_int(lft, incr1, rgt, incr2,
1121 : dst, GDK_int_max,
1122 : ci1, ci2,
1123 : candoff1, candoff2);
1124 0 : break;
1125 0 : case TYPE_lng:
1126 0 : nils = mul_sht_dbl_lng(lft, incr1, rgt, incr2,
1127 : dst, GDK_lng_max,
1128 : ci1, ci2,
1129 : candoff1, candoff2);
1130 0 : break;
1131 : #ifdef HAVE_HGE
1132 0 : case TYPE_hge:
1133 0 : nils = mul_sht_dbl_hge(lft, incr1, rgt, incr2,
1134 : dst, GDK_hge_max,
1135 : ci1, ci2,
1136 : candoff1, candoff2);
1137 0 : break;
1138 : #endif
1139 0 : case TYPE_dbl:
1140 0 : nils = mul_sht_dbl_dbl(lft, incr1, rgt, incr2,
1141 : dst, GDK_dbl_max,
1142 : ci1, ci2, candoff1, candoff2);
1143 0 : break;
1144 0 : default:
1145 0 : goto unsupported;
1146 : }
1147 : break;
1148 0 : default:
1149 0 : goto unsupported;
1150 : }
1151 : break;
1152 35501 : case TYPE_int:
1153 35501 : switch (tp2) {
1154 31150 : case TYPE_bte:
1155 31150 : switch (tp) {
1156 14230 : case TYPE_int:
1157 14230 : nils = mul_int_bte_int(lft, incr1, rgt, incr2,
1158 : dst, GDK_int_max,
1159 : ci1, ci2, candoff1, candoff2);
1160 14230 : break;
1161 16920 : case TYPE_lng:
1162 16920 : nils = mul_int_bte_lng(lft, incr1, rgt, incr2,
1163 : dst, GDK_lng_max,
1164 : ci1, ci2, candoff1, candoff2);
1165 16920 : break;
1166 : #ifdef HAVE_HGE
1167 0 : case TYPE_hge:
1168 0 : nils = mul_int_bte_hge(lft, incr1, rgt, incr2,
1169 : dst, GDK_hge_max,
1170 : ci1, ci2, candoff1, candoff2);
1171 0 : break;
1172 : #endif
1173 0 : case TYPE_flt:
1174 0 : nils = mul_int_bte_flt(lft, incr1, rgt, incr2,
1175 : dst, GDK_flt_max,
1176 : ci1, ci2, candoff1, candoff2);
1177 0 : break;
1178 0 : case TYPE_dbl:
1179 0 : nils = mul_int_bte_dbl(lft, incr1, rgt, incr2,
1180 : dst, GDK_dbl_max,
1181 : ci1, ci2, candoff1, candoff2);
1182 0 : break;
1183 0 : default:
1184 0 : goto unsupported;
1185 : }
1186 : break;
1187 4162 : case TYPE_sht:
1188 4162 : switch (tp) {
1189 2019 : case TYPE_int:
1190 2019 : nils = mul_int_sht_int(lft, incr1, rgt, incr2,
1191 : dst, GDK_int_max,
1192 : ci1, ci2, candoff1, candoff2);
1193 2019 : break;
1194 2143 : case TYPE_lng:
1195 2143 : nils = mul_int_sht_lng(lft, incr1, rgt, incr2,
1196 : dst, GDK_lng_max,
1197 : ci1, ci2, candoff1, candoff2);
1198 2143 : break;
1199 : #ifdef HAVE_HGE
1200 0 : case TYPE_hge:
1201 0 : nils = mul_int_sht_hge(lft, incr1, rgt, incr2,
1202 : dst, GDK_hge_max,
1203 : ci1, ci2, candoff1, candoff2);
1204 0 : break;
1205 : #endif
1206 0 : case TYPE_flt:
1207 0 : nils = mul_int_sht_flt(lft, incr1, rgt, incr2,
1208 : dst, GDK_flt_max,
1209 : ci1, ci2, candoff1, candoff2);
1210 0 : break;
1211 0 : case TYPE_dbl:
1212 0 : nils = mul_int_sht_dbl(lft, incr1, rgt, incr2,
1213 : dst, GDK_dbl_max,
1214 : ci1, ci2, candoff1, candoff2);
1215 0 : break;
1216 0 : default:
1217 0 : goto unsupported;
1218 : }
1219 : break;
1220 170 : case TYPE_int:
1221 170 : switch (tp) {
1222 73 : case TYPE_int:
1223 73 : nils = mul_int_int_int(lft, incr1, rgt, incr2,
1224 : dst, GDK_int_max,
1225 : ci1, ci2, candoff1, candoff2);
1226 73 : break;
1227 7 : case TYPE_lng:
1228 7 : nils = mul_int_int_lng(lft, incr1, rgt, incr2,
1229 : dst, GDK_lng_max,
1230 : ci1, ci2, candoff1, candoff2);
1231 7 : break;
1232 : #ifdef HAVE_HGE
1233 90 : case TYPE_hge:
1234 90 : nils = mul_int_int_hge(lft, incr1, rgt, incr2,
1235 : dst, GDK_hge_max,
1236 : ci1, ci2, candoff1, candoff2);
1237 90 : break;
1238 : #endif
1239 0 : case TYPE_flt:
1240 0 : nils = mul_int_int_flt(lft, incr1, rgt, incr2,
1241 : dst, GDK_flt_max,
1242 : ci1, ci2, candoff1, candoff2);
1243 0 : break;
1244 0 : case TYPE_dbl:
1245 0 : nils = mul_int_int_dbl(lft, incr1, rgt, incr2,
1246 : dst, GDK_dbl_max,
1247 : ci1, ci2, candoff1, candoff2);
1248 0 : break;
1249 0 : default:
1250 0 : goto unsupported;
1251 : }
1252 : break;
1253 6 : case TYPE_lng:
1254 6 : switch (tp) {
1255 0 : case TYPE_lng:
1256 0 : nils = mul_int_lng_lng(lft, incr1, rgt, incr2,
1257 : dst, GDK_lng_max,
1258 : ci1, ci2, candoff1, candoff2);
1259 0 : break;
1260 : #ifdef HAVE_HGE
1261 6 : case TYPE_hge:
1262 6 : nils = mul_int_lng_hge(lft, incr1, rgt, incr2,
1263 : dst, GDK_hge_max,
1264 : ci1, ci2, candoff1, candoff2);
1265 6 : break;
1266 : #endif
1267 0 : case TYPE_flt:
1268 0 : nils = mul_int_lng_flt(lft, incr1, rgt, incr2,
1269 : dst, GDK_flt_max,
1270 : ci1, ci2, candoff1, candoff2);
1271 0 : break;
1272 0 : case TYPE_dbl:
1273 0 : nils = mul_int_lng_dbl(lft, incr1, rgt, incr2,
1274 : dst, GDK_dbl_max,
1275 : ci1, ci2, candoff1, candoff2);
1276 0 : break;
1277 0 : default:
1278 0 : goto unsupported;
1279 : }
1280 : break;
1281 : #ifdef HAVE_HGE
1282 6 : case TYPE_hge:
1283 6 : switch (tp) {
1284 6 : case TYPE_hge:
1285 6 : nils = mul_int_hge_hge(lft, incr1, rgt, incr2,
1286 : dst, GDK_hge_max,
1287 : ci1, ci2, candoff1, candoff2);
1288 6 : break;
1289 0 : case TYPE_flt:
1290 0 : nils = mul_int_hge_flt(lft, incr1, rgt, incr2,
1291 : dst, GDK_flt_max,
1292 : ci1, ci2, candoff1, candoff2);
1293 0 : break;
1294 0 : case TYPE_dbl:
1295 0 : nils = mul_int_hge_dbl(lft, incr1, rgt, incr2,
1296 : dst, GDK_dbl_max,
1297 : ci1, ci2, candoff1, candoff2);
1298 0 : break;
1299 0 : default:
1300 0 : goto unsupported;
1301 : }
1302 : break;
1303 : #endif
1304 2 : case TYPE_flt:
1305 2 : switch (tp) {
1306 0 : case TYPE_bte:
1307 0 : nils = mul_int_flt_bte(lft, incr1, rgt, incr2,
1308 : dst, GDK_bte_max,
1309 : ci1, ci2,
1310 : candoff1, candoff2);
1311 0 : break;
1312 0 : case TYPE_sht:
1313 0 : nils = mul_int_flt_sht(lft, incr1, rgt, incr2,
1314 : dst, GDK_sht_max,
1315 : ci1, ci2,
1316 : candoff1, candoff2);
1317 0 : break;
1318 1 : case TYPE_int:
1319 1 : nils = mul_int_flt_int(lft, incr1, rgt, incr2,
1320 : dst, GDK_int_max,
1321 : ci1, ci2,
1322 : candoff1, candoff2);
1323 1 : break;
1324 1 : case TYPE_lng:
1325 1 : nils = mul_int_flt_lng(lft, incr1, rgt, incr2,
1326 : dst, GDK_lng_max,
1327 : ci1, ci2,
1328 : candoff1, candoff2);
1329 1 : break;
1330 : #ifdef HAVE_HGE
1331 0 : case TYPE_hge:
1332 0 : nils = mul_int_flt_hge(lft, incr1, rgt, incr2,
1333 : dst, GDK_hge_max,
1334 : ci1, ci2,
1335 : candoff1, candoff2);
1336 0 : break;
1337 : #endif
1338 0 : case TYPE_flt:
1339 0 : nils = mul_int_flt_flt(lft, incr1, rgt, incr2,
1340 : dst, GDK_flt_max,
1341 : ci1, ci2, candoff1, candoff2);
1342 0 : break;
1343 0 : case TYPE_dbl:
1344 0 : nils = mul_int_flt_dbl(lft, incr1, rgt, incr2,
1345 : dst, GDK_dbl_max,
1346 : ci1, ci2, candoff1, candoff2);
1347 0 : break;
1348 0 : default:
1349 0 : goto unsupported;
1350 : }
1351 : break;
1352 5 : case TYPE_dbl:
1353 5 : switch (tp) {
1354 0 : case TYPE_bte:
1355 0 : nils = mul_int_dbl_bte(lft, incr1, rgt, incr2,
1356 : dst, GDK_bte_max,
1357 : ci1, ci2,
1358 : candoff1, candoff2);
1359 0 : break;
1360 0 : case TYPE_sht:
1361 0 : nils = mul_int_dbl_sht(lft, incr1, rgt, incr2,
1362 : dst, GDK_sht_max,
1363 : ci1, ci2,
1364 : candoff1, candoff2);
1365 0 : break;
1366 5 : case TYPE_int:
1367 5 : nils = mul_int_dbl_int(lft, incr1, rgt, incr2,
1368 : dst, GDK_int_max,
1369 : ci1, ci2,
1370 : candoff1, candoff2);
1371 5 : break;
1372 0 : case TYPE_lng:
1373 0 : nils = mul_int_dbl_lng(lft, incr1, rgt, incr2,
1374 : dst, GDK_lng_max,
1375 : ci1, ci2,
1376 : candoff1, candoff2);
1377 0 : break;
1378 : #ifdef HAVE_HGE
1379 0 : case TYPE_hge:
1380 0 : nils = mul_int_dbl_hge(lft, incr1, rgt, incr2,
1381 : dst, GDK_hge_max,
1382 : ci1, ci2,
1383 : candoff1, candoff2);
1384 0 : break;
1385 : #endif
1386 0 : case TYPE_dbl:
1387 0 : nils = mul_int_dbl_dbl(lft, incr1, rgt, incr2,
1388 : dst, GDK_dbl_max,
1389 : ci1, ci2, candoff1, candoff2);
1390 0 : break;
1391 0 : default:
1392 0 : goto unsupported;
1393 : }
1394 : break;
1395 0 : default:
1396 0 : goto unsupported;
1397 : }
1398 : break;
1399 1411 : case TYPE_lng:
1400 1411 : switch (tp2) {
1401 1097 : case TYPE_bte:
1402 1097 : switch (tp) {
1403 1034 : case TYPE_lng:
1404 1034 : nils = mul_lng_bte_lng(lft, incr1, rgt, incr2,
1405 : dst, GDK_lng_max,
1406 : ci1, ci2, candoff1, candoff2);
1407 1034 : break;
1408 : #ifdef HAVE_HGE
1409 63 : case TYPE_hge:
1410 63 : nils = mul_lng_bte_hge(lft, incr1, rgt, incr2,
1411 : dst, GDK_hge_max,
1412 : ci1, ci2, candoff1, candoff2);
1413 63 : break;
1414 : #endif
1415 0 : case TYPE_flt:
1416 0 : nils = mul_lng_bte_flt(lft, incr1, rgt, incr2,
1417 : dst, GDK_flt_max,
1418 : ci1, ci2, candoff1, candoff2);
1419 0 : break;
1420 0 : case TYPE_dbl:
1421 0 : nils = mul_lng_bte_dbl(lft, incr1, rgt, incr2,
1422 : dst, GDK_dbl_max,
1423 : ci1, ci2, candoff1, candoff2);
1424 0 : break;
1425 0 : default:
1426 0 : goto unsupported;
1427 : }
1428 : break;
1429 8 : case TYPE_sht:
1430 8 : switch (tp) {
1431 3 : case TYPE_lng:
1432 3 : nils = mul_lng_sht_lng(lft, incr1, rgt, incr2,
1433 : dst, GDK_lng_max,
1434 : ci1, ci2, candoff1, candoff2);
1435 3 : break;
1436 : #ifdef HAVE_HGE
1437 5 : case TYPE_hge:
1438 5 : nils = mul_lng_sht_hge(lft, incr1, rgt, incr2,
1439 : dst, GDK_hge_max,
1440 : ci1, ci2, candoff1, candoff2);
1441 5 : break;
1442 : #endif
1443 0 : case TYPE_flt:
1444 0 : nils = mul_lng_sht_flt(lft, incr1, rgt, incr2,
1445 : dst, GDK_flt_max,
1446 : ci1, ci2, candoff1, candoff2);
1447 0 : break;
1448 0 : case TYPE_dbl:
1449 0 : nils = mul_lng_sht_dbl(lft, incr1, rgt, incr2,
1450 : dst, GDK_dbl_max,
1451 : ci1, ci2, candoff1, candoff2);
1452 0 : break;
1453 0 : default:
1454 0 : goto unsupported;
1455 : }
1456 : break;
1457 79 : case TYPE_int:
1458 79 : switch (tp) {
1459 28 : case TYPE_lng:
1460 28 : nils = mul_lng_int_lng(lft, incr1, rgt, incr2,
1461 : dst, GDK_lng_max,
1462 : ci1, ci2, candoff1, candoff2);
1463 28 : break;
1464 : #ifdef HAVE_HGE
1465 51 : case TYPE_hge:
1466 51 : nils = mul_lng_int_hge(lft, incr1, rgt, incr2,
1467 : dst, GDK_hge_max,
1468 : ci1, ci2, candoff1, candoff2);
1469 51 : break;
1470 : #endif
1471 0 : case TYPE_flt:
1472 0 : nils = mul_lng_int_flt(lft, incr1, rgt, incr2,
1473 : dst, GDK_flt_max,
1474 : ci1, ci2, candoff1, candoff2);
1475 0 : break;
1476 0 : case TYPE_dbl:
1477 0 : nils = mul_lng_int_dbl(lft, incr1, rgt, incr2,
1478 : dst, GDK_dbl_max,
1479 : ci1, ci2, candoff1, candoff2);
1480 0 : break;
1481 0 : default:
1482 0 : goto unsupported;
1483 : }
1484 : break;
1485 215 : case TYPE_lng:
1486 215 : switch (tp) {
1487 31 : case TYPE_lng:
1488 31 : nils = mul_lng_lng_lng(lft, incr1, rgt, incr2,
1489 : dst, GDK_lng_max,
1490 : ci1, ci2, candoff1, candoff2);
1491 31 : break;
1492 : #ifdef HAVE_HGE
1493 184 : case TYPE_hge:
1494 184 : nils = mul_lng_lng_hge(lft, incr1, rgt, incr2,
1495 : dst, GDK_hge_max,
1496 : ci1, ci2, candoff1, candoff2);
1497 184 : break;
1498 : #endif
1499 0 : case TYPE_flt:
1500 0 : nils = mul_lng_lng_flt(lft, incr1, rgt, incr2,
1501 : dst, GDK_flt_max,
1502 : ci1, ci2, candoff1, candoff2);
1503 0 : break;
1504 0 : case TYPE_dbl:
1505 0 : nils = mul_lng_lng_dbl(lft, incr1, rgt, incr2,
1506 : dst, GDK_dbl_max,
1507 : ci1, ci2, candoff1, candoff2);
1508 0 : break;
1509 0 : default:
1510 0 : goto unsupported;
1511 : }
1512 : break;
1513 : #ifdef HAVE_HGE
1514 6 : case TYPE_hge:
1515 6 : switch (tp) {
1516 6 : case TYPE_hge:
1517 6 : nils = mul_lng_hge_hge(lft, incr1, rgt, incr2,
1518 : dst, GDK_hge_max,
1519 : ci1, ci2, candoff1, candoff2);
1520 6 : break;
1521 0 : case TYPE_flt:
1522 0 : nils = mul_lng_hge_flt(lft, incr1, rgt, incr2,
1523 : dst, GDK_flt_max,
1524 : ci1, ci2, candoff1, candoff2);
1525 0 : break;
1526 0 : case TYPE_dbl:
1527 0 : nils = mul_lng_hge_dbl(lft, incr1, rgt, incr2,
1528 : dst, GDK_dbl_max,
1529 : ci1, ci2, candoff1, candoff2);
1530 0 : break;
1531 0 : default:
1532 0 : goto unsupported;
1533 : }
1534 : break;
1535 : #endif
1536 2 : case TYPE_flt:
1537 2 : switch (tp) {
1538 0 : case TYPE_bte:
1539 0 : nils = mul_lng_flt_bte(lft, incr1, rgt, incr2,
1540 : dst, GDK_bte_max,
1541 : ci1, ci2,
1542 : candoff1, candoff2);
1543 0 : break;
1544 0 : case TYPE_sht:
1545 0 : nils = mul_lng_flt_sht(lft, incr1, rgt, incr2,
1546 : dst, GDK_sht_max,
1547 : ci1, ci2,
1548 : candoff1, candoff2);
1549 0 : break;
1550 0 : case TYPE_int:
1551 0 : nils = mul_lng_flt_int(lft, incr1, rgt, incr2,
1552 : dst, GDK_int_max,
1553 : ci1, ci2,
1554 : candoff1, candoff2);
1555 0 : break;
1556 2 : case TYPE_lng:
1557 2 : nils = mul_lng_flt_lng(lft, incr1, rgt, incr2,
1558 : dst, GDK_lng_max,
1559 : ci1, ci2,
1560 : candoff1, candoff2);
1561 2 : break;
1562 : #ifdef HAVE_HGE
1563 0 : case TYPE_hge:
1564 0 : nils = mul_lng_flt_hge(lft, incr1, rgt, incr2,
1565 : dst, GDK_hge_max,
1566 : ci1, ci2,
1567 : candoff1, candoff2);
1568 0 : break;
1569 : #endif
1570 0 : case TYPE_flt:
1571 0 : nils = mul_lng_flt_flt(lft, incr1, rgt, incr2,
1572 : dst, GDK_flt_max,
1573 : ci1, ci2, candoff1, candoff2);
1574 0 : break;
1575 0 : case TYPE_dbl:
1576 0 : nils = mul_lng_flt_dbl(lft, incr1, rgt, incr2,
1577 : dst, GDK_dbl_max,
1578 : ci1, ci2, candoff1, candoff2);
1579 0 : break;
1580 0 : default:
1581 0 : goto unsupported;
1582 : }
1583 : break;
1584 4 : case TYPE_dbl:
1585 4 : switch (tp) {
1586 0 : case TYPE_bte:
1587 0 : nils = mul_lng_dbl_bte(lft, incr1, rgt, incr2,
1588 : dst, GDK_bte_max,
1589 : ci1, ci2,
1590 : candoff1, candoff2);
1591 0 : break;
1592 0 : case TYPE_sht:
1593 0 : nils = mul_lng_dbl_sht(lft, incr1, rgt, incr2,
1594 : dst, GDK_sht_max,
1595 : ci1, ci2,
1596 : candoff1, candoff2);
1597 0 : break;
1598 0 : case TYPE_int:
1599 0 : nils = mul_lng_dbl_int(lft, incr1, rgt, incr2,
1600 : dst, GDK_int_max,
1601 : ci1, ci2,
1602 : candoff1, candoff2);
1603 0 : break;
1604 4 : case TYPE_lng:
1605 4 : nils = mul_lng_dbl_lng(lft, incr1, rgt, incr2,
1606 : dst, GDK_lng_max,
1607 : ci1, ci2,
1608 : candoff1, candoff2);
1609 4 : break;
1610 : #ifdef HAVE_HGE
1611 0 : case TYPE_hge:
1612 0 : nils = mul_lng_dbl_hge(lft, incr1, rgt, incr2,
1613 : dst, GDK_hge_max,
1614 : ci1, ci2,
1615 : candoff1, candoff2);
1616 0 : break;
1617 : #endif
1618 0 : case TYPE_dbl:
1619 0 : nils = mul_lng_dbl_dbl(lft, incr1, rgt, incr2,
1620 : dst, GDK_dbl_max,
1621 : ci1, ci2, candoff1, candoff2);
1622 0 : break;
1623 0 : default:
1624 0 : goto unsupported;
1625 : }
1626 : break;
1627 0 : default:
1628 0 : goto unsupported;
1629 : }
1630 : break;
1631 : #ifdef HAVE_HGE
1632 266 : case TYPE_hge:
1633 266 : switch (tp2) {
1634 153 : case TYPE_bte:
1635 153 : switch (tp) {
1636 153 : case TYPE_hge:
1637 153 : nils = mul_hge_bte_hge(lft, incr1, rgt, incr2,
1638 : dst, GDK_hge_max,
1639 : ci1, ci2, candoff1, candoff2);
1640 153 : break;
1641 0 : case TYPE_flt:
1642 0 : nils = mul_hge_bte_flt(lft, incr1, rgt, incr2,
1643 : dst, GDK_flt_max,
1644 : ci1, ci2, candoff1, candoff2);
1645 0 : break;
1646 0 : case TYPE_dbl:
1647 0 : nils = mul_hge_bte_dbl(lft, incr1, rgt, incr2,
1648 : dst, GDK_dbl_max,
1649 : ci1, ci2, candoff1, candoff2);
1650 0 : break;
1651 0 : default:
1652 0 : goto unsupported;
1653 : }
1654 : break;
1655 4 : case TYPE_sht:
1656 4 : switch (tp) {
1657 4 : case TYPE_hge:
1658 4 : nils = mul_hge_sht_hge(lft, incr1, rgt, incr2,
1659 : dst, GDK_hge_max,
1660 : ci1, ci2, candoff1, candoff2);
1661 4 : break;
1662 0 : case TYPE_flt:
1663 0 : nils = mul_hge_sht_flt(lft, incr1, rgt, incr2,
1664 : dst, GDK_flt_max,
1665 : ci1, ci2, candoff1, candoff2);
1666 0 : break;
1667 0 : case TYPE_dbl:
1668 0 : nils = mul_hge_sht_dbl(lft, incr1, rgt, incr2,
1669 : dst, GDK_dbl_max,
1670 : ci1, ci2, candoff1, candoff2);
1671 0 : break;
1672 0 : default:
1673 0 : goto unsupported;
1674 : }
1675 : break;
1676 40 : case TYPE_int:
1677 40 : switch (tp) {
1678 40 : case TYPE_hge:
1679 40 : nils = mul_hge_int_hge(lft, incr1, rgt, incr2,
1680 : dst, GDK_hge_max,
1681 : ci1, ci2, candoff1, candoff2);
1682 40 : break;
1683 0 : case TYPE_flt:
1684 0 : nils = mul_hge_int_flt(lft, incr1, rgt, incr2,
1685 : dst, GDK_flt_max,
1686 : ci1, ci2, candoff1, candoff2);
1687 0 : break;
1688 0 : case TYPE_dbl:
1689 0 : nils = mul_hge_int_dbl(lft, incr1, rgt, incr2,
1690 : dst, GDK_dbl_max,
1691 : ci1, ci2, candoff1, candoff2);
1692 0 : break;
1693 0 : default:
1694 0 : goto unsupported;
1695 : }
1696 : break;
1697 21 : case TYPE_lng:
1698 21 : switch (tp) {
1699 21 : case TYPE_hge:
1700 21 : nils = mul_hge_lng_hge(lft, incr1, rgt, incr2,
1701 : dst, GDK_hge_max,
1702 : ci1, ci2, candoff1, candoff2);
1703 21 : break;
1704 0 : case TYPE_flt:
1705 0 : nils = mul_hge_lng_flt(lft, incr1, rgt, incr2,
1706 : dst, GDK_flt_max,
1707 : ci1, ci2, candoff1, candoff2);
1708 0 : break;
1709 0 : case TYPE_dbl:
1710 0 : nils = mul_hge_lng_dbl(lft, incr1, rgt, incr2,
1711 : dst, GDK_dbl_max,
1712 : ci1, ci2, candoff1, candoff2);
1713 0 : break;
1714 0 : default:
1715 0 : goto unsupported;
1716 : }
1717 : break;
1718 48 : case TYPE_hge:
1719 48 : switch (tp) {
1720 48 : case TYPE_hge:
1721 48 : nils = mul_hge_hge_hge(lft, incr1, rgt, incr2,
1722 : dst, GDK_hge_max,
1723 : ci1, ci2, candoff1, candoff2);
1724 48 : break;
1725 0 : case TYPE_flt:
1726 0 : nils = mul_hge_hge_flt(lft, incr1, rgt, incr2,
1727 : dst, GDK_flt_max,
1728 : ci1, ci2, candoff1, candoff2);
1729 0 : break;
1730 0 : case TYPE_dbl:
1731 0 : nils = mul_hge_hge_dbl(lft, incr1, rgt, incr2,
1732 : dst, GDK_dbl_max,
1733 : ci1, ci2, candoff1, candoff2);
1734 0 : break;
1735 0 : default:
1736 0 : goto unsupported;
1737 : }
1738 : break;
1739 0 : case TYPE_flt:
1740 0 : switch (tp) {
1741 0 : case TYPE_bte:
1742 0 : nils = mul_hge_flt_bte(lft, incr1, rgt, incr2,
1743 : dst, GDK_bte_max,
1744 : ci1, ci2,
1745 : candoff1, candoff2);
1746 0 : break;
1747 0 : case TYPE_sht:
1748 0 : nils = mul_hge_flt_sht(lft, incr1, rgt, incr2,
1749 : dst, GDK_sht_max,
1750 : ci1, ci2,
1751 : candoff1, candoff2);
1752 0 : break;
1753 0 : case TYPE_int:
1754 0 : nils = mul_hge_flt_int(lft, incr1, rgt, incr2,
1755 : dst, GDK_int_max,
1756 : ci1, ci2,
1757 : candoff1, candoff2);
1758 0 : break;
1759 0 : case TYPE_lng:
1760 0 : nils = mul_hge_flt_lng(lft, incr1, rgt, incr2,
1761 : dst, GDK_lng_max,
1762 : ci1, ci2,
1763 : candoff1, candoff2);
1764 0 : break;
1765 0 : case TYPE_hge:
1766 0 : nils = mul_hge_flt_hge(lft, incr1, rgt, incr2,
1767 : dst, GDK_hge_max,
1768 : ci1, ci2,
1769 : candoff1, candoff2);
1770 0 : break;
1771 0 : case TYPE_flt:
1772 0 : nils = mul_hge_flt_flt(lft, incr1, rgt, incr2,
1773 : dst, GDK_flt_max,
1774 : ci1, ci2, candoff1, candoff2);
1775 0 : break;
1776 0 : case TYPE_dbl:
1777 0 : nils = mul_hge_flt_dbl(lft, incr1, rgt, incr2,
1778 : dst, GDK_dbl_max,
1779 : ci1, ci2, candoff1, candoff2);
1780 0 : break;
1781 0 : default:
1782 0 : goto unsupported;
1783 : }
1784 : break;
1785 0 : case TYPE_dbl:
1786 0 : switch (tp) {
1787 0 : case TYPE_bte:
1788 0 : nils = mul_hge_dbl_bte(lft, incr1, rgt, incr2,
1789 : dst, GDK_bte_max,
1790 : ci1, ci2,
1791 : candoff1, candoff2);
1792 0 : break;
1793 0 : case TYPE_sht:
1794 0 : nils = mul_hge_dbl_sht(lft, incr1, rgt, incr2,
1795 : dst, GDK_sht_max,
1796 : ci1, ci2,
1797 : candoff1, candoff2);
1798 0 : break;
1799 0 : case TYPE_int:
1800 0 : nils = mul_hge_dbl_int(lft, incr1, rgt, incr2,
1801 : dst, GDK_int_max,
1802 : ci1, ci2,
1803 : candoff1, candoff2);
1804 0 : break;
1805 0 : case TYPE_lng:
1806 0 : nils = mul_hge_dbl_lng(lft, incr1, rgt, incr2,
1807 : dst, GDK_lng_max,
1808 : ci1, ci2,
1809 : candoff1, candoff2);
1810 0 : break;
1811 0 : case TYPE_hge:
1812 0 : nils = mul_hge_dbl_hge(lft, incr1, rgt, incr2,
1813 : dst, GDK_hge_max,
1814 : ci1, ci2,
1815 : candoff1, candoff2);
1816 0 : break;
1817 0 : case TYPE_dbl:
1818 0 : nils = mul_hge_dbl_dbl(lft, incr1, rgt, incr2,
1819 : dst, GDK_dbl_max,
1820 : ci1, ci2, candoff1, candoff2);
1821 0 : break;
1822 0 : default:
1823 0 : goto unsupported;
1824 : }
1825 : break;
1826 0 : default:
1827 0 : goto unsupported;
1828 : }
1829 : break;
1830 : #endif
1831 17 : case TYPE_flt:
1832 17 : switch (tp2) {
1833 0 : case TYPE_bte:
1834 0 : switch (tp) {
1835 0 : case TYPE_flt:
1836 0 : nils = mul_flt_bte_flt(lft, incr1, rgt, incr2,
1837 : dst, GDK_flt_max,
1838 : ci1, ci2, candoff1, candoff2);
1839 0 : break;
1840 0 : case TYPE_dbl:
1841 0 : nils = mul_flt_bte_dbl(lft, incr1, rgt, incr2,
1842 : dst, GDK_dbl_max,
1843 : ci1, ci2, candoff1, candoff2);
1844 0 : break;
1845 0 : default:
1846 0 : goto unsupported;
1847 : }
1848 : break;
1849 0 : case TYPE_sht:
1850 0 : switch (tp) {
1851 0 : case TYPE_flt:
1852 0 : nils = mul_flt_sht_flt(lft, incr1, rgt, incr2,
1853 : dst, GDK_flt_max,
1854 : ci1, ci2, candoff1, candoff2);
1855 0 : break;
1856 0 : case TYPE_dbl:
1857 0 : nils = mul_flt_sht_dbl(lft, incr1, rgt, incr2,
1858 : dst, GDK_dbl_max,
1859 : ci1, ci2, candoff1, candoff2);
1860 0 : break;
1861 0 : default:
1862 0 : goto unsupported;
1863 : }
1864 : break;
1865 0 : case TYPE_int:
1866 0 : switch (tp) {
1867 0 : case TYPE_flt:
1868 0 : nils = mul_flt_int_flt(lft, incr1, rgt, incr2,
1869 : dst, GDK_flt_max,
1870 : ci1, ci2, candoff1, candoff2);
1871 0 : break;
1872 0 : case TYPE_dbl:
1873 0 : nils = mul_flt_int_dbl(lft, incr1, rgt, incr2,
1874 : dst, GDK_dbl_max,
1875 : ci1, ci2, candoff1, candoff2);
1876 0 : break;
1877 0 : default:
1878 0 : goto unsupported;
1879 : }
1880 : break;
1881 0 : case TYPE_lng:
1882 0 : switch (tp) {
1883 0 : case TYPE_flt:
1884 0 : nils = mul_flt_lng_flt(lft, incr1, rgt, incr2,
1885 : dst, GDK_flt_max,
1886 : ci1, ci2, candoff1, candoff2);
1887 0 : break;
1888 0 : case TYPE_dbl:
1889 0 : nils = mul_flt_lng_dbl(lft, incr1, rgt, incr2,
1890 : dst, GDK_dbl_max,
1891 : ci1, ci2, candoff1, candoff2);
1892 0 : break;
1893 0 : default:
1894 0 : goto unsupported;
1895 : }
1896 : break;
1897 : #ifdef HAVE_HGE
1898 0 : case TYPE_hge:
1899 0 : switch (tp) {
1900 0 : case TYPE_flt:
1901 0 : nils = mul_flt_hge_flt(lft, incr1, rgt, incr2,
1902 : dst, GDK_flt_max,
1903 : ci1, ci2, candoff1, candoff2);
1904 0 : break;
1905 0 : case TYPE_dbl:
1906 0 : nils = mul_flt_hge_dbl(lft, incr1, rgt, incr2,
1907 : dst, GDK_dbl_max,
1908 : ci1, ci2, candoff1, candoff2);
1909 0 : break;
1910 0 : default:
1911 0 : goto unsupported;
1912 : }
1913 : break;
1914 : #endif
1915 17 : case TYPE_flt:
1916 17 : switch (tp) {
1917 17 : case TYPE_flt:
1918 17 : nils = mul_flt_flt_flt(lft, incr1, rgt, incr2,
1919 : dst, GDK_flt_max,
1920 : ci1, ci2, candoff1, candoff2);
1921 17 : break;
1922 0 : case TYPE_dbl:
1923 0 : nils = mul_flt_flt_dbl(lft, incr1, rgt, incr2,
1924 : dst, GDK_dbl_max,
1925 : ci1, ci2, candoff1, candoff2);
1926 0 : break;
1927 0 : default:
1928 0 : goto unsupported;
1929 : }
1930 : break;
1931 0 : case TYPE_dbl:
1932 0 : switch (tp) {
1933 0 : case TYPE_dbl:
1934 0 : nils = mul_flt_dbl_dbl(lft, incr1, rgt, incr2,
1935 : dst, GDK_dbl_max,
1936 : ci1, ci2, candoff1, candoff2);
1937 0 : break;
1938 0 : default:
1939 0 : goto unsupported;
1940 : }
1941 0 : break;
1942 0 : default:
1943 0 : goto unsupported;
1944 : }
1945 : break;
1946 1352 : case TYPE_dbl:
1947 1352 : switch (tp2) {
1948 0 : case TYPE_bte:
1949 0 : switch (tp) {
1950 0 : case TYPE_dbl:
1951 0 : nils = mul_dbl_bte_dbl(lft, incr1, rgt, incr2,
1952 : dst, GDK_dbl_max,
1953 : ci1, ci2, candoff1, candoff2);
1954 0 : break;
1955 0 : default:
1956 0 : goto unsupported;
1957 : }
1958 0 : break;
1959 0 : case TYPE_sht:
1960 0 : switch (tp) {
1961 0 : case TYPE_dbl:
1962 0 : nils = mul_dbl_sht_dbl(lft, incr1, rgt, incr2,
1963 : dst, GDK_dbl_max,
1964 : ci1, ci2, candoff1, candoff2);
1965 0 : break;
1966 0 : default:
1967 0 : goto unsupported;
1968 : }
1969 0 : break;
1970 0 : case TYPE_int:
1971 0 : switch (tp) {
1972 0 : case TYPE_dbl:
1973 0 : nils = mul_dbl_int_dbl(lft, incr1, rgt, incr2,
1974 : dst, GDK_dbl_max,
1975 : ci1, ci2, candoff1, candoff2);
1976 0 : break;
1977 0 : default:
1978 0 : goto unsupported;
1979 : }
1980 0 : break;
1981 0 : case TYPE_lng:
1982 0 : switch (tp) {
1983 0 : case TYPE_dbl:
1984 0 : nils = mul_dbl_lng_dbl(lft, incr1, rgt, incr2,
1985 : dst, GDK_dbl_max,
1986 : ci1, ci2, candoff1, candoff2);
1987 0 : break;
1988 0 : default:
1989 0 : goto unsupported;
1990 : }
1991 0 : break;
1992 : #ifdef HAVE_HGE
1993 0 : case TYPE_hge:
1994 0 : switch (tp) {
1995 0 : case TYPE_dbl:
1996 0 : nils = mul_dbl_hge_dbl(lft, incr1, rgt, incr2,
1997 : dst, GDK_dbl_max,
1998 : ci1, ci2, candoff1, candoff2);
1999 0 : break;
2000 0 : default:
2001 0 : goto unsupported;
2002 : }
2003 0 : break;
2004 : #endif
2005 0 : case TYPE_flt:
2006 0 : switch (tp) {
2007 0 : case TYPE_dbl:
2008 0 : nils = mul_dbl_flt_dbl(lft, incr1, rgt, incr2,
2009 : dst, GDK_dbl_max,
2010 : ci1, ci2, candoff1, candoff2);
2011 0 : break;
2012 0 : default:
2013 0 : goto unsupported;
2014 : }
2015 0 : break;
2016 1352 : case TYPE_dbl:
2017 1352 : switch (tp) {
2018 1352 : case TYPE_dbl:
2019 1352 : nils = mul_dbl_dbl_dbl(lft, incr1, rgt, incr2,
2020 : dst, GDK_dbl_max,
2021 : ci1, ci2, candoff1, candoff2);
2022 1352 : break;
2023 0 : default:
2024 0 : goto unsupported;
2025 : }
2026 1352 : break;
2027 0 : default:
2028 0 : goto unsupported;
2029 : }
2030 : break;
2031 0 : default:
2032 0 : goto unsupported;
2033 : }
2034 :
2035 : return nils;
2036 :
2037 0 : unsupported:
2038 0 : GDKerror("%s: type combination mul(%s,%s)->%s) not supported.\n",
2039 : func, ATOMname(tp1), ATOMname(tp2), ATOMname(tp));
2040 0 : return BUN_NONE;
2041 : }
2042 :
2043 : BAT *
2044 1740 : BATcalcmuldivmod(BAT *b1, BAT *b2, BAT *s1, BAT *s2, int tp,
2045 : BUN (*typeswitchloop)(const void *, int, bool,
2046 : const void *, int, bool,
2047 : void *restrict, int,
2048 : struct canditer *restrict,
2049 : struct canditer *restrict,
2050 : oid, oid, const char *),
2051 : const char *func)
2052 : {
2053 1740 : lng t0 = 0;
2054 1740 : BAT *bn;
2055 1740 : BUN nils;
2056 1740 : struct canditer ci1, ci2;
2057 :
2058 1740 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
2059 :
2060 1740 : BATcheck(b1, NULL);
2061 1740 : BATcheck(b2, NULL);
2062 :
2063 1740 : canditer_init(&ci1, b1, s1);
2064 1740 : canditer_init(&ci2, b2, s2);
2065 1740 : if (ci1.ncand != ci2.ncand || ci1.hseq != ci2.hseq) {
2066 0 : GDKerror("%s: inputs not the same size.\n", func);
2067 0 : return NULL;
2068 : }
2069 :
2070 1740 : bn = COLnew(ci1.hseq, tp, ci1.ncand, TRANSIENT);
2071 1740 : if (bn == NULL)
2072 : return NULL;
2073 1740 : if (ci1.ncand == 0)
2074 : return bn;
2075 :
2076 1600 : BATiter b1i = bat_iterator(b1);
2077 1600 : BATiter b2i = bat_iterator(b2);
2078 3200 : nils = (*typeswitchloop)(b1i.base, b1i.type, true,
2079 1600 : b2i.base, b2i.type, true,
2080 1600 : Tloc(bn, 0), tp,
2081 : &ci1, &ci2, b1->hseqbase, b2->hseqbase, func);
2082 1600 : bat_iterator_end(&b1i);
2083 1600 : bat_iterator_end(&b2i);
2084 :
2085 1600 : if (nils >= BUN_NONE) {
2086 2 : BBPunfix(bn->batCacheid);
2087 2 : return NULL;
2088 : }
2089 :
2090 1598 : BATsetcount(bn, ci1.ncand);
2091 :
2092 1598 : bn->tsorted = ci1.ncand <= 1 || nils == ci1.ncand;
2093 1598 : bn->trevsorted = ci1.ncand <= 1 || nils == ci1.ncand;
2094 1598 : bn->tkey = ci1.ncand <= 1;
2095 1598 : bn->tnil = nils != 0;
2096 1598 : bn->tnonil = nils == 0;
2097 :
2098 1598 : TRC_DEBUG(ALGO, "%s: b1=" ALGOBATFMT ",b2=" ALGOBATFMT
2099 : ",s1=" ALGOOPTBATFMT ",s2=" ALGOOPTBATFMT
2100 : " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
2101 : func, ALGOBATPAR(b1), ALGOBATPAR(b2),
2102 : ALGOOPTBATPAR(s1), ALGOOPTBATPAR(s2),
2103 : ALGOOPTBATPAR(bn), GDKusec() - t0);
2104 :
2105 : return bn;
2106 : }
2107 :
2108 : BAT *
2109 1493 : BATcalcmul(BAT *b1, BAT *b2, BAT *s1, BAT *s2, int tp)
2110 : {
2111 1493 : return BATcalcmuldivmod(b1, b2, s1, s2, tp,
2112 : mul_typeswitchloop, __func__);
2113 : }
2114 :
2115 : BAT *
2116 25598 : BATcalcmulcst(BAT *b, const ValRecord *v, BAT *s, int tp)
2117 : {
2118 25598 : lng t0 = 0;
2119 25598 : BAT *bn;
2120 25598 : BUN nils;
2121 25598 : struct canditer ci;
2122 :
2123 25598 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
2124 :
2125 25598 : BATcheck(b, NULL);
2126 :
2127 25598 : canditer_init(&ci, b, s);
2128 :
2129 25598 : bn = COLnew(ci.hseq, tp, ci.ncand, TRANSIENT);
2130 25598 : if (bn == NULL)
2131 : return NULL;
2132 25598 : if (ci.ncand == 0)
2133 : return bn;
2134 :
2135 19513 : BATiter bi = bat_iterator(b);
2136 39021 : nils = mul_typeswitchloop(bi.base, bi.type, true,
2137 19510 : VALptr(v), v->vtype, false,
2138 19510 : Tloc(bn, 0), tp,
2139 : &ci,
2140 19510 : &(struct canditer){.tpe=cand_dense, .ncand=ci.ncand},
2141 : b->hseqbase, 0, __func__);
2142 :
2143 19511 : if (nils == BUN_NONE) {
2144 2 : BBPunfix(bn->batCacheid);
2145 2 : bat_iterator_end(&bi);
2146 2 : return NULL;
2147 : }
2148 :
2149 19509 : BATsetcount(bn, ci.ncand);
2150 :
2151 : /* if the input is sorted, and no overflow occurred, the result
2152 : * is also sorted, or reverse sorted if the constant is
2153 : * negative */
2154 19509 : ValRecord sign;
2155 :
2156 19509 : VARcalcsign(&sign, v);
2157 19527 : bn->tsorted = (sign.val.btval >= 0 && bi.sorted && nils == 0) ||
2158 55 : (sign.val.btval <= 0 && bi.revsorted && nils == 0) ||
2159 31209 : ci.ncand <= 1 || nils == ci.ncand;
2160 19527 : bn->trevsorted = (sign.val.btval >= 0 && bi.revsorted && nils == 0) ||
2161 55 : (sign.val.btval <= 0 && bi.sorted && nils == 0) ||
2162 36446 : ci.ncand <= 1 || nils == ci.ncand;
2163 19511 : bn->tkey = ci.ncand <= 1;
2164 19511 : bn->tnil = nils != 0;
2165 19511 : bn->tnonil = nils == 0;
2166 19511 : bat_iterator_end(&bi);
2167 :
2168 19511 : TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
2169 : " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
2170 : ALGOBATPAR(b), ALGOOPTBATPAR(s),
2171 : ALGOOPTBATPAR(bn), GDKusec() - t0);
2172 :
2173 : return bn;
2174 : }
2175 :
2176 : BAT *
2177 33 : BATcalccstmul(const ValRecord *v, BAT *b, BAT *s, int tp)
2178 : {
2179 33 : lng t0 = 0;
2180 33 : BAT *bn;
2181 33 : BUN nils;
2182 33 : struct canditer ci;
2183 :
2184 33 : TRC_DEBUG_IF(ALGO) t0 = GDKusec();
2185 :
2186 33 : BATcheck(b, NULL);
2187 :
2188 33 : canditer_init(&ci, b, s);
2189 :
2190 33 : bn = COLnew(ci.hseq, tp, ci.ncand, TRANSIENT);
2191 33 : if (bn == NULL)
2192 : return NULL;
2193 33 : if (ci.ncand == 0)
2194 : return bn;
2195 :
2196 26 : BATiter bi = bat_iterator(b);
2197 52 : nils = mul_typeswitchloop(VALptr(v), v->vtype, false,
2198 26 : bi.base, bi.type, true,
2199 26 : Tloc(bn, 0), tp,
2200 26 : &(struct canditer){.tpe=cand_dense, .ncand=ci.ncand},
2201 : &ci,
2202 : 0, b->hseqbase, __func__);
2203 :
2204 26 : if (nils == BUN_NONE) {
2205 0 : BBPunfix(bn->batCacheid);
2206 0 : bat_iterator_end(&bi);
2207 0 : return NULL;
2208 : }
2209 :
2210 26 : BATsetcount(bn, ci.ncand);
2211 :
2212 : /* if the input is sorted, and no overflow occurred, the result
2213 : * is also sorted, or reverse sorted if the constant is
2214 : * negative */
2215 26 : ValRecord sign;
2216 :
2217 26 : VARcalcsign(&sign, v);
2218 27 : bn->tsorted = (sign.val.btval >= 0 && bi.sorted && nils == 0) ||
2219 1 : (sign.val.btval <= 0 && bi.revsorted && nils == 0) ||
2220 43 : ci.ncand <= 1 || nils == ci.ncand;
2221 27 : bn->trevsorted = (sign.val.btval >= 0 && bi.revsorted && nils == 0) ||
2222 1 : (sign.val.btval <= 0 && bi.sorted && nils == 0) ||
2223 44 : ci.ncand <= 1 || nils == ci.ncand;
2224 26 : bn->tkey = ci.ncand <= 1;
2225 26 : bn->tnil = nils != 0;
2226 26 : bn->tnonil = nils == 0;
2227 26 : bat_iterator_end(&bi);
2228 :
2229 26 : TRC_DEBUG(ALGO, "b=" ALGOBATFMT ",s=" ALGOOPTBATFMT
2230 : " -> " ALGOOPTBATFMT " " LLFMT "usec\n",
2231 : ALGOBATPAR(b), ALGOOPTBATPAR(s),
2232 : ALGOOPTBATPAR(bn), GDKusec() - t0);
2233 :
2234 : return bn;
2235 : }
2236 :
2237 : gdk_return
2238 18256 : VARcalcmul(ValPtr ret, const ValRecord *lft, const ValRecord *rgt)
2239 : {
2240 18256 : if (mul_typeswitchloop(VALptr(lft), lft->vtype, false,
2241 18256 : VALptr(rgt), rgt->vtype, false,
2242 : VALget(ret), ret->vtype,
2243 18256 : &(struct canditer){.tpe=cand_dense, .ncand=1},
2244 18256 : &(struct canditer){.tpe=cand_dense, .ncand=1},
2245 : 0, 0, __func__) == BUN_NONE)
2246 140 : return GDK_FAIL;
2247 18116 : return GDK_SUCCEED;
2248 : }
|
