1 //------------------------------------------------------------------------------ 2 // GB_binop_factory: switch factory for built-in methods for C=binop(A,B) 3 //------------------------------------------------------------------------------ 4 5 // SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved. 6 // SPDX-License-Identifier: Apache-2.0 7 8 //------------------------------------------------------------------------------ 9 10 // The #include'ing file defines the GB_BINOP_WORKER macro, and opcode, xcode, 11 // ycode, and zcode, to call one of 388 builtin binary operators. The binary 12 // operators are all named GrB_[OPNAME]_[XTYPE], according to the opcode/ 13 // opname, and the xtype of the operator. The type of z and y are not in the 14 // name. Except for the GxB_BSHIFT_[XTYPE] operators (where y always has type 15 // int8), the types of x and y are the same. 16 17 { 18 //-------------------------------------------------------------------------- 19 // launch the switch factory 20 //-------------------------------------------------------------------------- 21 22 // this switch factory does not handle positional operators 23 ASSERT (!GB_OPCODE_IS_POSITIONAL (opcode)) ; 24 25 switch (opcode) 26 { 27 28 29 //---------------------------------------------------------------------- 30 case GB_MIN_opcode : // z = min(x,y) 31 //---------------------------------------------------------------------- 32 33 // MIN == TIMES == AND for boolean 34 switch (xcode) 35 { 36 case GB_INT8_code : GB_BINOP_WORKER (_min, _int8 ) 37 case GB_INT16_code : GB_BINOP_WORKER (_min, _int16 ) 38 case GB_INT32_code : GB_BINOP_WORKER (_min, _int32 ) 39 case GB_INT64_code : GB_BINOP_WORKER (_min, _int64 ) 40 case GB_UINT8_code : GB_BINOP_WORKER (_min, _uint8 ) 41 case GB_UINT16_code : GB_BINOP_WORKER (_min, _uint16) 42 case GB_UINT32_code : GB_BINOP_WORKER (_min, _uint32) 43 case GB_UINT64_code : GB_BINOP_WORKER (_min, _uint64) 44 case GB_FP32_code : GB_BINOP_WORKER (_min, _fp32 ) 45 case GB_FP64_code : GB_BINOP_WORKER (_min, _fp64 ) 46 default: ; 47 } 48 break ; 49 50 //---------------------------------------------------------------------- 51 case GB_MAX_opcode : // z = max(x,y) 52 //---------------------------------------------------------------------- 53 54 // MAX == PLUS == OR for boolean 55 switch (xcode) 56 { 57 case GB_INT8_code : GB_BINOP_WORKER (_max, _int8 ) 58 case GB_INT16_code : GB_BINOP_WORKER (_max, _int16 ) 59 case GB_INT32_code : GB_BINOP_WORKER (_max, _int32 ) 60 case GB_INT64_code : GB_BINOP_WORKER (_max, _int64 ) 61 case GB_UINT8_code : GB_BINOP_WORKER (_max, _uint8 ) 62 case GB_UINT16_code : GB_BINOP_WORKER (_max, _uint16) 63 case GB_UINT32_code : GB_BINOP_WORKER (_max, _uint32) 64 case GB_UINT64_code : GB_BINOP_WORKER (_max, _uint64) 65 case GB_FP32_code : GB_BINOP_WORKER (_max, _fp32 ) 66 case GB_FP64_code : GB_BINOP_WORKER (_max, _fp64 ) 67 default: ; 68 } 69 break ; 70 71 //---------------------------------------------------------------------- 72 case GB_PLUS_opcode : // z = x + y 73 //---------------------------------------------------------------------- 74 75 // MAX == PLUS == OR for boolean 76 switch (xcode) 77 { 78 case GB_INT8_code : GB_BINOP_WORKER (_plus, _int8 ) 79 case GB_INT16_code : GB_BINOP_WORKER (_plus, _int16 ) 80 case GB_INT32_code : GB_BINOP_WORKER (_plus, _int32 ) 81 case GB_INT64_code : GB_BINOP_WORKER (_plus, _int64 ) 82 case GB_UINT8_code : GB_BINOP_WORKER (_plus, _uint8 ) 83 case GB_UINT16_code : GB_BINOP_WORKER (_plus, _uint16) 84 case GB_UINT32_code : GB_BINOP_WORKER (_plus, _uint32) 85 case GB_UINT64_code : GB_BINOP_WORKER (_plus, _uint64) 86 case GB_FP32_code : GB_BINOP_WORKER (_plus, _fp32 ) 87 case GB_FP64_code : GB_BINOP_WORKER (_plus, _fp64 ) 88 case GB_FC32_code : GB_BINOP_WORKER (_plus, _fc32 ) 89 case GB_FC64_code : GB_BINOP_WORKER (_plus, _fc64 ) 90 default: ; 91 } 92 break ; 93 94 //---------------------------------------------------------------------- 95 case GB_MINUS_opcode : // z = x - y 96 //---------------------------------------------------------------------- 97 98 // MINUS == RMINUS == NE == ISNE == XOR for boolean 99 switch (xcode) 100 { 101 case GB_INT8_code : GB_BINOP_WORKER (_minus, _int8 ) 102 case GB_INT16_code : GB_BINOP_WORKER (_minus, _int16 ) 103 case GB_INT32_code : GB_BINOP_WORKER (_minus, _int32 ) 104 case GB_INT64_code : GB_BINOP_WORKER (_minus, _int64 ) 105 case GB_UINT8_code : GB_BINOP_WORKER (_minus, _uint8 ) 106 case GB_UINT16_code : GB_BINOP_WORKER (_minus, _uint16) 107 case GB_UINT32_code : GB_BINOP_WORKER (_minus, _uint32) 108 case GB_UINT64_code : GB_BINOP_WORKER (_minus, _uint64) 109 case GB_FP32_code : GB_BINOP_WORKER (_minus, _fp32 ) 110 case GB_FP64_code : GB_BINOP_WORKER (_minus, _fp64 ) 111 case GB_FC32_code : GB_BINOP_WORKER (_minus, _fc32 ) 112 case GB_FC64_code : GB_BINOP_WORKER (_minus, _fc64 ) 113 default: ; 114 } 115 break ; 116 117 //---------------------------------------------------------------------- 118 case GB_RMINUS_opcode : // z = y - x (reverse minus) 119 //---------------------------------------------------------------------- 120 121 // MINUS == RMINUS == NE == ISNE == XOR for boolean 122 switch (xcode) 123 { 124 case GB_INT8_code : GB_BINOP_WORKER (_rminus, _int8 ) 125 case GB_INT16_code : GB_BINOP_WORKER (_rminus, _int16 ) 126 case GB_INT32_code : GB_BINOP_WORKER (_rminus, _int32 ) 127 case GB_INT64_code : GB_BINOP_WORKER (_rminus, _int64 ) 128 case GB_UINT8_code : GB_BINOP_WORKER (_rminus, _uint8 ) 129 case GB_UINT16_code : GB_BINOP_WORKER (_rminus, _uint16) 130 case GB_UINT32_code : GB_BINOP_WORKER (_rminus, _uint32) 131 case GB_UINT64_code : GB_BINOP_WORKER (_rminus, _uint64) 132 case GB_FP32_code : GB_BINOP_WORKER (_rminus, _fp32 ) 133 case GB_FP64_code : GB_BINOP_WORKER (_rminus, _fp64 ) 134 case GB_FC32_code : GB_BINOP_WORKER (_rminus, _fc32 ) 135 case GB_FC64_code : GB_BINOP_WORKER (_rminus, _fc64 ) 136 default: ; 137 } 138 break ; 139 140 //---------------------------------------------------------------------- 141 case GB_TIMES_opcode : // z = x * y 142 //---------------------------------------------------------------------- 143 144 // MIN == TIMES == AND for boolean 145 switch (xcode) 146 { 147 case GB_INT8_code : GB_BINOP_WORKER (_times, _int8 ) 148 case GB_INT16_code : GB_BINOP_WORKER (_times, _int16 ) 149 case GB_INT32_code : GB_BINOP_WORKER (_times, _int32 ) 150 case GB_INT64_code : GB_BINOP_WORKER (_times, _int64 ) 151 case GB_UINT8_code : GB_BINOP_WORKER (_times, _uint8 ) 152 case GB_UINT16_code : GB_BINOP_WORKER (_times, _uint16) 153 case GB_UINT32_code : GB_BINOP_WORKER (_times, _uint32) 154 case GB_UINT64_code : GB_BINOP_WORKER (_times, _uint64) 155 case GB_FP32_code : GB_BINOP_WORKER (_times, _fp32 ) 156 case GB_FP64_code : GB_BINOP_WORKER (_times, _fp64 ) 157 case GB_FC32_code : GB_BINOP_WORKER (_times, _fc32 ) 158 case GB_FC64_code : GB_BINOP_WORKER (_times, _fc64 ) 159 default: ; 160 } 161 break ; 162 163 //---------------------------------------------------------------------- 164 case GB_DIV_opcode : // z = x / y 165 //---------------------------------------------------------------------- 166 167 // FIRST == DIV for boolean 168 switch (xcode) 169 { 170 case GB_INT8_code : GB_BINOP_WORKER (_div, _int8 ) 171 case GB_INT16_code : GB_BINOP_WORKER (_div, _int16 ) 172 case GB_INT32_code : GB_BINOP_WORKER (_div, _int32 ) 173 case GB_INT64_code : GB_BINOP_WORKER (_div, _int64 ) 174 case GB_UINT8_code : GB_BINOP_WORKER (_div, _uint8 ) 175 case GB_UINT16_code : GB_BINOP_WORKER (_div, _uint16) 176 case GB_UINT32_code : GB_BINOP_WORKER (_div, _uint32) 177 case GB_UINT64_code : GB_BINOP_WORKER (_div, _uint64) 178 case GB_FP32_code : GB_BINOP_WORKER (_div, _fp32 ) 179 case GB_FP64_code : GB_BINOP_WORKER (_div, _fp64 ) 180 case GB_FC32_code : GB_BINOP_WORKER (_div, _fc32 ) 181 case GB_FC64_code : GB_BINOP_WORKER (_div, _fc64 ) 182 default: ; 183 } 184 break ; 185 186 //---------------------------------------------------------------------- 187 case GB_RDIV_opcode : // z = y / x (reverse division) 188 //---------------------------------------------------------------------- 189 190 // SECOND == RDIV for boolean 191 switch (xcode) 192 { 193 case GB_INT8_code : GB_BINOP_WORKER (_rdiv, _int8 ) 194 case GB_INT16_code : GB_BINOP_WORKER (_rdiv, _int16 ) 195 case GB_INT32_code : GB_BINOP_WORKER (_rdiv, _int32 ) 196 case GB_INT64_code : GB_BINOP_WORKER (_rdiv, _int64 ) 197 case GB_UINT8_code : GB_BINOP_WORKER (_rdiv, _uint8 ) 198 case GB_UINT16_code : GB_BINOP_WORKER (_rdiv, _uint16) 199 case GB_UINT32_code : GB_BINOP_WORKER (_rdiv, _uint32) 200 case GB_UINT64_code : GB_BINOP_WORKER (_rdiv, _uint64) 201 case GB_FP32_code : GB_BINOP_WORKER (_rdiv, _fp32 ) 202 case GB_FP64_code : GB_BINOP_WORKER (_rdiv, _fp64 ) 203 case GB_FC32_code : GB_BINOP_WORKER (_rdiv, _fc32 ) 204 case GB_FC64_code : GB_BINOP_WORKER (_rdiv, _fc64 ) 205 default: ; 206 } 207 break ; 208 209 #ifndef GB_BINOP_SUBSET 210 211 // These operators are not used in C+=A+B by GB_dense_eWise3_accum 212 // when all 3 matrices are dense. 213 214 #ifndef GB_NO_FIRST 215 216 //---------------------------------------------------------------------- 217 case GB_FIRST_opcode : // z = x 218 //---------------------------------------------------------------------- 219 220 switch (xcode) 221 { 222 case GB_BOOL_code : GB_BINOP_WORKER (_first, _bool ) 223 case GB_INT8_code : GB_BINOP_WORKER (_first, _int8 ) 224 case GB_INT16_code : GB_BINOP_WORKER (_first, _int16 ) 225 case GB_INT32_code : GB_BINOP_WORKER (_first, _int32 ) 226 case GB_INT64_code : GB_BINOP_WORKER (_first, _int64 ) 227 case GB_UINT8_code : GB_BINOP_WORKER (_first, _uint8 ) 228 case GB_UINT16_code : GB_BINOP_WORKER (_first, _uint16) 229 case GB_UINT32_code : GB_BINOP_WORKER (_first, _uint32) 230 case GB_UINT64_code : GB_BINOP_WORKER (_first, _uint64) 231 case GB_FP32_code : GB_BINOP_WORKER (_first, _fp32 ) 232 case GB_FP64_code : GB_BINOP_WORKER (_first, _fp64 ) 233 case GB_FC32_code : GB_BINOP_WORKER (_first, _fc32 ) 234 case GB_FC64_code : GB_BINOP_WORKER (_first, _fc64 ) 235 default: ; 236 } 237 break ; 238 #endif 239 240 #ifndef GB_NO_SECOND 241 242 //---------------------------------------------------------------------- 243 case GB_SECOND_opcode : // z = y 244 case GB_ANY_opcode : // z = y 245 //---------------------------------------------------------------------- 246 247 switch (xcode) 248 { 249 case GB_BOOL_code : GB_BINOP_WORKER (_second, _bool ) 250 case GB_INT8_code : GB_BINOP_WORKER (_second, _int8 ) 251 case GB_INT16_code : GB_BINOP_WORKER (_second, _int16 ) 252 case GB_INT32_code : GB_BINOP_WORKER (_second, _int32 ) 253 case GB_INT64_code : GB_BINOP_WORKER (_second, _int64 ) 254 case GB_UINT8_code : GB_BINOP_WORKER (_second, _uint8 ) 255 case GB_UINT16_code : GB_BINOP_WORKER (_second, _uint16) 256 case GB_UINT32_code : GB_BINOP_WORKER (_second, _uint32) 257 case GB_UINT64_code : GB_BINOP_WORKER (_second, _uint64) 258 case GB_FP32_code : GB_BINOP_WORKER (_second, _fp32 ) 259 case GB_FP64_code : GB_BINOP_WORKER (_second, _fp64 ) 260 case GB_FC32_code : GB_BINOP_WORKER (_second, _fc32 ) 261 case GB_FC64_code : GB_BINOP_WORKER (_second, _fc64 ) 262 default: ; 263 } 264 break ; 265 #endif 266 267 #ifndef GB_NO_PAIR 268 269 //---------------------------------------------------------------------- 270 case GB_PAIR_opcode : // z = 1 271 //---------------------------------------------------------------------- 272 273 switch (xcode) 274 { 275 case GB_BOOL_code : GB_BINOP_WORKER (_pair, _bool ) 276 case GB_INT8_code : GB_BINOP_WORKER (_pair, _int8 ) 277 case GB_INT16_code : GB_BINOP_WORKER (_pair, _int16 ) 278 case GB_INT32_code : GB_BINOP_WORKER (_pair, _int32 ) 279 case GB_INT64_code : GB_BINOP_WORKER (_pair, _int64 ) 280 case GB_UINT8_code : GB_BINOP_WORKER (_pair, _uint8 ) 281 case GB_UINT16_code : GB_BINOP_WORKER (_pair, _uint16) 282 case GB_UINT32_code : GB_BINOP_WORKER (_pair, _uint32) 283 case GB_UINT64_code : GB_BINOP_WORKER (_pair, _uint64) 284 case GB_FP32_code : GB_BINOP_WORKER (_pair, _fp32 ) 285 case GB_FP64_code : GB_BINOP_WORKER (_pair, _fp64 ) 286 case GB_FC32_code : GB_BINOP_WORKER (_pair, _fc32 ) 287 case GB_FC64_code : GB_BINOP_WORKER (_pair, _fc64 ) 288 default: ; 289 } 290 break ; 291 #endif 292 293 //---------------------------------------------------------------------- 294 case GB_ISEQ_opcode : // z = (x == y) 295 //---------------------------------------------------------------------- 296 297 // ISEQ == EQ for boolean 298 switch (xcode) 299 { 300 case GB_INT8_code : GB_BINOP_WORKER (_iseq, _int8 ) 301 case GB_INT16_code : GB_BINOP_WORKER (_iseq, _int16 ) 302 case GB_INT32_code : GB_BINOP_WORKER (_iseq, _int32 ) 303 case GB_INT64_code : GB_BINOP_WORKER (_iseq, _int64 ) 304 case GB_UINT8_code : GB_BINOP_WORKER (_iseq, _uint8 ) 305 case GB_UINT16_code : GB_BINOP_WORKER (_iseq, _uint16) 306 case GB_UINT32_code : GB_BINOP_WORKER (_iseq, _uint32) 307 case GB_UINT64_code : GB_BINOP_WORKER (_iseq, _uint64) 308 case GB_FP32_code : GB_BINOP_WORKER (_iseq, _fp32 ) 309 case GB_FP64_code : GB_BINOP_WORKER (_iseq, _fp64 ) 310 #ifndef GB_BINOP_IS_SEMIRING_MULTIPLIER 311 // ISEQ does not appear in a builtin complex semiring 312 case GB_FC32_code : GB_BINOP_WORKER (_iseq, _fc32 ) 313 case GB_FC64_code : GB_BINOP_WORKER (_iseq, _fc64 ) 314 #endif 315 default: ; 316 } 317 break ; 318 319 //---------------------------------------------------------------------- 320 case GB_ISNE_opcode : // z = (x != y) 321 //---------------------------------------------------------------------- 322 323 // MINUS == RMINUS == NE == ISNE == XOR for boolean 324 switch (xcode) 325 { 326 case GB_INT8_code : GB_BINOP_WORKER (_isne, _int8 ) 327 case GB_INT16_code : GB_BINOP_WORKER (_isne, _int16 ) 328 case GB_INT32_code : GB_BINOP_WORKER (_isne, _int32 ) 329 case GB_INT64_code : GB_BINOP_WORKER (_isne, _int64 ) 330 case GB_UINT8_code : GB_BINOP_WORKER (_isne, _uint8 ) 331 case GB_UINT16_code : GB_BINOP_WORKER (_isne, _uint16) 332 case GB_UINT32_code : GB_BINOP_WORKER (_isne, _uint32) 333 case GB_UINT64_code : GB_BINOP_WORKER (_isne, _uint64) 334 case GB_FP32_code : GB_BINOP_WORKER (_isne, _fp32 ) 335 case GB_FP64_code : GB_BINOP_WORKER (_isne, _fp64 ) 336 #ifndef GB_BINOP_IS_SEMIRING_MULTIPLIER 337 // ISNE does not appear in a builtin complex semiring 338 case GB_FC32_code : GB_BINOP_WORKER (_isne, _fc32 ) 339 case GB_FC64_code : GB_BINOP_WORKER (_isne, _fc64 ) 340 #endif 341 default: ; 342 } 343 break ; 344 345 //---------------------------------------------------------------------- 346 case GB_ISGT_opcode : // z = (x > y) 347 //---------------------------------------------------------------------- 348 349 // ISGT == GT for boolean. no complex case 350 switch (xcode) 351 { 352 case GB_INT8_code : GB_BINOP_WORKER (_isgt, _int8 ) 353 case GB_INT16_code : GB_BINOP_WORKER (_isgt, _int16 ) 354 case GB_INT32_code : GB_BINOP_WORKER (_isgt, _int32 ) 355 case GB_INT64_code : GB_BINOP_WORKER (_isgt, _int64 ) 356 case GB_UINT8_code : GB_BINOP_WORKER (_isgt, _uint8 ) 357 case GB_UINT16_code : GB_BINOP_WORKER (_isgt, _uint16) 358 case GB_UINT32_code : GB_BINOP_WORKER (_isgt, _uint32) 359 case GB_UINT64_code : GB_BINOP_WORKER (_isgt, _uint64) 360 case GB_FP32_code : GB_BINOP_WORKER (_isgt, _fp32 ) 361 case GB_FP64_code : GB_BINOP_WORKER (_isgt, _fp64 ) 362 default: ; 363 } 364 break ; 365 366 //---------------------------------------------------------------------- 367 case GB_ISLT_opcode : // z = (x < y) 368 //---------------------------------------------------------------------- 369 370 // ISLT == LT for boolean. no complex case 371 switch (xcode) 372 { 373 case GB_INT8_code : GB_BINOP_WORKER (_islt, _int8 ) 374 case GB_INT16_code : GB_BINOP_WORKER (_islt, _int16 ) 375 case GB_INT32_code : GB_BINOP_WORKER (_islt, _int32 ) 376 case GB_INT64_code : GB_BINOP_WORKER (_islt, _int64 ) 377 case GB_UINT8_code : GB_BINOP_WORKER (_islt, _uint8 ) 378 case GB_UINT16_code : GB_BINOP_WORKER (_islt, _uint16) 379 case GB_UINT32_code : GB_BINOP_WORKER (_islt, _uint32) 380 case GB_UINT64_code : GB_BINOP_WORKER (_islt, _uint64) 381 case GB_FP32_code : GB_BINOP_WORKER (_islt, _fp32 ) 382 case GB_FP64_code : GB_BINOP_WORKER (_islt, _fp64 ) 383 default: ; 384 } 385 break ; 386 387 //---------------------------------------------------------------------- 388 case GB_ISGE_opcode : // z = (x >= y) 389 //---------------------------------------------------------------------- 390 391 // POW == ISGE == GE for boolean. no complex case. 392 switch (xcode) 393 { 394 case GB_INT8_code : GB_BINOP_WORKER (_isge, _int8 ) 395 case GB_INT16_code : GB_BINOP_WORKER (_isge, _int16 ) 396 case GB_INT32_code : GB_BINOP_WORKER (_isge, _int32 ) 397 case GB_INT64_code : GB_BINOP_WORKER (_isge, _int64 ) 398 case GB_UINT8_code : GB_BINOP_WORKER (_isge, _uint8 ) 399 case GB_UINT16_code : GB_BINOP_WORKER (_isge, _uint16) 400 case GB_UINT32_code : GB_BINOP_WORKER (_isge, _uint32) 401 case GB_UINT64_code : GB_BINOP_WORKER (_isge, _uint64) 402 case GB_FP32_code : GB_BINOP_WORKER (_isge, _fp32 ) 403 case GB_FP64_code : GB_BINOP_WORKER (_isge, _fp64 ) 404 default: ; 405 } 406 break ; 407 408 //---------------------------------------------------------------------- 409 case GB_ISLE_opcode : // z = (x <= y) 410 //---------------------------------------------------------------------- 411 412 // ISLE == LE for boolean. no complex case 413 switch (xcode) 414 { 415 case GB_INT8_code : GB_BINOP_WORKER (_isle, _int8 ) 416 case GB_INT16_code : GB_BINOP_WORKER (_isle, _int16 ) 417 case GB_INT32_code : GB_BINOP_WORKER (_isle, _int32 ) 418 case GB_INT64_code : GB_BINOP_WORKER (_isle, _int64 ) 419 case GB_UINT8_code : GB_BINOP_WORKER (_isle, _uint8 ) 420 case GB_UINT16_code : GB_BINOP_WORKER (_isle, _uint16) 421 case GB_UINT32_code : GB_BINOP_WORKER (_isle, _uint32) 422 case GB_UINT64_code : GB_BINOP_WORKER (_isle, _uint64) 423 case GB_FP32_code : GB_BINOP_WORKER (_isle, _fp32 ) 424 case GB_FP64_code : GB_BINOP_WORKER (_isle, _fp64 ) 425 default: ; 426 } 427 break ; 428 429 //---------------------------------------------------------------------- 430 case GB_EQ_opcode : // z = (x == y) 431 //---------------------------------------------------------------------- 432 433 switch (xcode) 434 { 435 case GB_BOOL_code : GB_BINOP_WORKER (_eq, _bool ) 436 case GB_INT8_code : GB_BINOP_WORKER (_eq, _int8 ) 437 case GB_INT16_code : GB_BINOP_WORKER (_eq, _int16 ) 438 case GB_INT32_code : GB_BINOP_WORKER (_eq, _int32 ) 439 case GB_INT64_code : GB_BINOP_WORKER (_eq, _int64 ) 440 case GB_UINT8_code : GB_BINOP_WORKER (_eq, _uint8 ) 441 case GB_UINT16_code : GB_BINOP_WORKER (_eq, _uint16) 442 case GB_UINT32_code : GB_BINOP_WORKER (_eq, _uint32) 443 case GB_UINT64_code : GB_BINOP_WORKER (_eq, _uint64) 444 case GB_FP32_code : GB_BINOP_WORKER (_eq, _fp32 ) 445 case GB_FP64_code : GB_BINOP_WORKER (_eq, _fp64 ) 446 #ifndef GB_BINOP_IS_SEMIRING_MULTIPLIER 447 // EQ does not appear in a builtin complex semiring 448 case GB_FC32_code : GB_BINOP_WORKER (_eq, _fc32 ) 449 case GB_FC64_code : GB_BINOP_WORKER (_eq, _fc64 ) 450 #endif 451 default: ; 452 } 453 break ; 454 455 //---------------------------------------------------------------------- 456 case GB_NE_opcode : // z = (x != y) 457 //---------------------------------------------------------------------- 458 459 // MINUS == RMINUS == NE == ISNE == XOR for boolean 460 switch (xcode) 461 { 462 case GB_INT8_code : GB_BINOP_WORKER (_ne, _int8 ) 463 case GB_INT16_code : GB_BINOP_WORKER (_ne, _int16 ) 464 case GB_INT32_code : GB_BINOP_WORKER (_ne, _int32 ) 465 case GB_INT64_code : GB_BINOP_WORKER (_ne, _int64 ) 466 case GB_UINT8_code : GB_BINOP_WORKER (_ne, _uint8 ) 467 case GB_UINT16_code : GB_BINOP_WORKER (_ne, _uint16) 468 case GB_UINT32_code : GB_BINOP_WORKER (_ne, _uint32) 469 case GB_UINT64_code : GB_BINOP_WORKER (_ne, _uint64) 470 case GB_FP32_code : GB_BINOP_WORKER (_ne, _fp32 ) 471 case GB_FP64_code : GB_BINOP_WORKER (_ne, _fp64 ) 472 #ifndef GB_BINOP_IS_SEMIRING_MULTIPLIER 473 // NE does not appear in a builtin complex semiring 474 case GB_FC32_code : GB_BINOP_WORKER (_ne, _fc32 ) 475 case GB_FC64_code : GB_BINOP_WORKER (_ne, _fc64 ) 476 #endif 477 default: ; 478 } 479 break ; 480 481 //---------------------------------------------------------------------- 482 case GB_GT_opcode : // z = (x > y) 483 //---------------------------------------------------------------------- 484 485 // no complex case 486 switch (xcode) 487 { 488 case GB_BOOL_code : GB_BINOP_WORKER (_gt, _bool ) 489 case GB_INT8_code : GB_BINOP_WORKER (_gt, _int8 ) 490 case GB_INT16_code : GB_BINOP_WORKER (_gt, _int16 ) 491 case GB_INT32_code : GB_BINOP_WORKER (_gt, _int32 ) 492 case GB_INT64_code : GB_BINOP_WORKER (_gt, _int64 ) 493 case GB_UINT8_code : GB_BINOP_WORKER (_gt, _uint8 ) 494 case GB_UINT16_code : GB_BINOP_WORKER (_gt, _uint16) 495 case GB_UINT32_code : GB_BINOP_WORKER (_gt, _uint32) 496 case GB_UINT64_code : GB_BINOP_WORKER (_gt, _uint64) 497 case GB_FP32_code : GB_BINOP_WORKER (_gt, _fp32 ) 498 case GB_FP64_code : GB_BINOP_WORKER (_gt, _fp64 ) 499 default: ; 500 } 501 break ; 502 503 //---------------------------------------------------------------------- 504 case GB_LT_opcode : // z = (x < y) 505 //---------------------------------------------------------------------- 506 507 // no complex case 508 switch (xcode) 509 { 510 case GB_BOOL_code : GB_BINOP_WORKER (_lt, _bool ) 511 case GB_INT8_code : GB_BINOP_WORKER (_lt, _int8 ) 512 case GB_INT16_code : GB_BINOP_WORKER (_lt, _int16 ) 513 case GB_INT32_code : GB_BINOP_WORKER (_lt, _int32 ) 514 case GB_INT64_code : GB_BINOP_WORKER (_lt, _int64 ) 515 case GB_UINT8_code : GB_BINOP_WORKER (_lt, _uint8 ) 516 case GB_UINT16_code : GB_BINOP_WORKER (_lt, _uint16) 517 case GB_UINT32_code : GB_BINOP_WORKER (_lt, _uint32) 518 case GB_UINT64_code : GB_BINOP_WORKER (_lt, _uint64) 519 case GB_FP32_code : GB_BINOP_WORKER (_lt, _fp32 ) 520 case GB_FP64_code : GB_BINOP_WORKER (_lt, _fp64 ) 521 default: ; 522 } 523 break ; 524 525 //---------------------------------------------------------------------- 526 case GB_GE_opcode : // z = (x >= y) 527 //---------------------------------------------------------------------- 528 529 // no complex case 530 switch (xcode) 531 { 532 case GB_BOOL_code : GB_BINOP_WORKER (_ge, _bool ) 533 case GB_INT8_code : GB_BINOP_WORKER (_ge, _int8 ) 534 case GB_INT16_code : GB_BINOP_WORKER (_ge, _int16 ) 535 case GB_INT32_code : GB_BINOP_WORKER (_ge, _int32 ) 536 case GB_INT64_code : GB_BINOP_WORKER (_ge, _int64 ) 537 case GB_UINT8_code : GB_BINOP_WORKER (_ge, _uint8 ) 538 case GB_UINT16_code : GB_BINOP_WORKER (_ge, _uint16) 539 case GB_UINT32_code : GB_BINOP_WORKER (_ge, _uint32) 540 case GB_UINT64_code : GB_BINOP_WORKER (_ge, _uint64) 541 case GB_FP32_code : GB_BINOP_WORKER (_ge, _fp32 ) 542 case GB_FP64_code : GB_BINOP_WORKER (_ge, _fp64 ) 543 default: ; 544 } 545 break ; 546 547 //---------------------------------------------------------------------- 548 case GB_LE_opcode : // z = (x <= y) 549 //---------------------------------------------------------------------- 550 551 // no complex case 552 switch (xcode) 553 { 554 case GB_BOOL_code : GB_BINOP_WORKER (_le, _bool ) 555 case GB_INT8_code : GB_BINOP_WORKER (_le, _int8 ) 556 case GB_INT16_code : GB_BINOP_WORKER (_le, _int16 ) 557 case GB_INT32_code : GB_BINOP_WORKER (_le, _int32 ) 558 case GB_INT64_code : GB_BINOP_WORKER (_le, _int64 ) 559 case GB_UINT8_code : GB_BINOP_WORKER (_le, _uint8 ) 560 case GB_UINT16_code : GB_BINOP_WORKER (_le, _uint16) 561 case GB_UINT32_code : GB_BINOP_WORKER (_le, _uint32) 562 case GB_UINT64_code : GB_BINOP_WORKER (_le, _uint64) 563 case GB_FP32_code : GB_BINOP_WORKER (_le, _fp32 ) 564 case GB_FP64_code : GB_BINOP_WORKER (_le, _fp64 ) 565 default: ; 566 } 567 break ; 568 569 //---------------------------------------------------------------------- 570 case GB_LOR_opcode : // z = x || y 571 //---------------------------------------------------------------------- 572 573 // no complex case 574 switch (xcode) 575 { 576 case GB_BOOL_code : GB_BINOP_WORKER (_lor, _bool ) 577 case GB_INT8_code : GB_BINOP_WORKER (_lor, _int8 ) 578 case GB_INT16_code : GB_BINOP_WORKER (_lor, _int16 ) 579 case GB_INT32_code : GB_BINOP_WORKER (_lor, _int32 ) 580 case GB_INT64_code : GB_BINOP_WORKER (_lor, _int64 ) 581 case GB_UINT8_code : GB_BINOP_WORKER (_lor, _uint8 ) 582 case GB_UINT16_code : GB_BINOP_WORKER (_lor, _uint16) 583 case GB_UINT32_code : GB_BINOP_WORKER (_lor, _uint32) 584 case GB_UINT64_code : GB_BINOP_WORKER (_lor, _uint64) 585 case GB_FP32_code : GB_BINOP_WORKER (_lor, _fp32 ) 586 case GB_FP64_code : GB_BINOP_WORKER (_lor, _fp64 ) 587 default: ; 588 } 589 break ; 590 591 //---------------------------------------------------------------------- 592 case GB_LAND_opcode : // z = x && y 593 //---------------------------------------------------------------------- 594 595 // no complex case 596 switch (xcode) 597 { 598 case GB_BOOL_code : GB_BINOP_WORKER (_land, _bool ) 599 case GB_INT8_code : GB_BINOP_WORKER (_land, _int8 ) 600 case GB_INT16_code : GB_BINOP_WORKER (_land, _int16 ) 601 case GB_INT32_code : GB_BINOP_WORKER (_land, _int32 ) 602 case GB_INT64_code : GB_BINOP_WORKER (_land, _int64 ) 603 case GB_UINT8_code : GB_BINOP_WORKER (_land, _uint8 ) 604 case GB_UINT16_code : GB_BINOP_WORKER (_land, _uint16) 605 case GB_UINT32_code : GB_BINOP_WORKER (_land, _uint32) 606 case GB_UINT64_code : GB_BINOP_WORKER (_land, _uint64) 607 case GB_FP32_code : GB_BINOP_WORKER (_land, _fp32 ) 608 case GB_FP64_code : GB_BINOP_WORKER (_land, _fp64 ) 609 default: ; 610 } 611 break ; 612 613 //---------------------------------------------------------------------- 614 case GB_LXOR_opcode : // z = x != y 615 //---------------------------------------------------------------------- 616 617 // no complex case 618 switch (xcode) 619 { 620 case GB_BOOL_code : GB_BINOP_WORKER (_lxor, _bool ) 621 case GB_INT8_code : GB_BINOP_WORKER (_lxor, _int8 ) 622 case GB_INT16_code : GB_BINOP_WORKER (_lxor, _int16 ) 623 case GB_INT32_code : GB_BINOP_WORKER (_lxor, _int32 ) 624 case GB_INT64_code : GB_BINOP_WORKER (_lxor, _int64 ) 625 case GB_UINT8_code : GB_BINOP_WORKER (_lxor, _uint8 ) 626 case GB_UINT16_code : GB_BINOP_WORKER (_lxor, _uint16) 627 case GB_UINT32_code : GB_BINOP_WORKER (_lxor, _uint32) 628 case GB_UINT64_code : GB_BINOP_WORKER (_lxor, _uint64) 629 case GB_FP32_code : GB_BINOP_WORKER (_lxor, _fp32 ) 630 case GB_FP64_code : GB_BINOP_WORKER (_lxor, _fp64 ) 631 default: ; 632 } 633 break ; 634 635 #ifndef GB_BINOP_IS_SEMIRING_MULTIPLIER 636 637 // pow, atan2, hypot, ... are not used as multiplicative operators in 638 // any semiring, so they are not called by GB_AxB_rowscale or 639 // GB_AxB_colscale. 640 641 //---------------------------------------------------------------------- 642 case GB_POW_opcode : // z = x ^ y 643 //---------------------------------------------------------------------- 644 645 // POW == ISGE == GE for boolean 646 switch (xcode) 647 { 648 case GB_INT8_code : GB_BINOP_WORKER (_pow, _int8 ) 649 case GB_INT16_code : GB_BINOP_WORKER (_pow, _int16 ) 650 case GB_INT32_code : GB_BINOP_WORKER (_pow, _int32 ) 651 case GB_INT64_code : GB_BINOP_WORKER (_pow, _int64 ) 652 case GB_UINT8_code : GB_BINOP_WORKER (_pow, _uint8 ) 653 case GB_UINT16_code : GB_BINOP_WORKER (_pow, _uint16) 654 case GB_UINT32_code : GB_BINOP_WORKER (_pow, _uint32) 655 case GB_UINT64_code : GB_BINOP_WORKER (_pow, _uint64) 656 case GB_FP32_code : GB_BINOP_WORKER (_pow, _fp32 ) 657 case GB_FP64_code : GB_BINOP_WORKER (_pow, _fp64 ) 658 case GB_FC32_code : GB_BINOP_WORKER (_pow, _fc32 ) 659 case GB_FC64_code : GB_BINOP_WORKER (_pow, _fc64 ) 660 default: ; 661 } 662 break ; 663 664 //---------------------------------------------------------------------- 665 case GB_ATAN2_opcode : // z = atan2 (x,y) 666 //---------------------------------------------------------------------- 667 668 switch (xcode) 669 { 670 case GB_FP32_code : GB_BINOP_WORKER (_atan2, _fp32) 671 case GB_FP64_code : GB_BINOP_WORKER (_atan2, _fp64) 672 default: ; 673 } 674 break ; 675 676 //---------------------------------------------------------------------- 677 case GB_HYPOT_opcode : // z = hypot (x,y) 678 //---------------------------------------------------------------------- 679 680 switch (xcode) 681 { 682 case GB_FP32_code : GB_BINOP_WORKER (_hypot, _fp32) 683 case GB_FP64_code : GB_BINOP_WORKER (_hypot, _fp64) 684 default: ; 685 } 686 break ; 687 688 //---------------------------------------------------------------------- 689 case GB_FMOD_opcode : // z = fmod (x,y) 690 //---------------------------------------------------------------------- 691 692 switch (xcode) 693 { 694 case GB_FP32_code : GB_BINOP_WORKER (_fmod, _fp32) 695 case GB_FP64_code : GB_BINOP_WORKER (_fmod, _fp64) 696 default: ; 697 } 698 break ; 699 700 //---------------------------------------------------------------------- 701 case GB_REMAINDER_opcode : // z = remainder (x,y) 702 //---------------------------------------------------------------------- 703 704 switch (xcode) 705 { 706 case GB_FP32_code : GB_BINOP_WORKER (_remainder, _fp32) 707 case GB_FP64_code : GB_BINOP_WORKER (_remainder, _fp64) 708 default: ; 709 } 710 break ; 711 712 //---------------------------------------------------------------------- 713 case GB_LDEXP_opcode : // z = ldexp (x,y) 714 //---------------------------------------------------------------------- 715 716 switch (xcode) 717 { 718 case GB_FP32_code : GB_BINOP_WORKER (_ldexp, _fp32) 719 case GB_FP64_code : GB_BINOP_WORKER (_ldexp, _fp64) 720 default: ; 721 } 722 break ; 723 724 //---------------------------------------------------------------------- 725 case GB_COPYSIGN_opcode : // z = copysign (x,y) 726 //---------------------------------------------------------------------- 727 728 switch (xcode) 729 { 730 case GB_FP32_code : GB_BINOP_WORKER (_copysign, _fp32) 731 case GB_FP64_code : GB_BINOP_WORKER (_copysign, _fp64) 732 default: ; 733 } 734 break ; 735 736 //---------------------------------------------------------------------- 737 case GB_CMPLX_opcode : // z = cmplx (x,y) 738 //---------------------------------------------------------------------- 739 740 switch (xcode) 741 { 742 case GB_FP32_code : GB_BINOP_WORKER (_cmplx, _fp32) 743 case GB_FP64_code : GB_BINOP_WORKER (_cmplx, _fp64) 744 default: ; 745 } 746 break ; 747 748 //---------------------------------------------------------------------- 749 case GB_BGET_opcode : // z = bitget (x,y) 750 //---------------------------------------------------------------------- 751 752 switch (xcode) 753 { 754 case GB_INT8_code : GB_BINOP_WORKER (_bget, _int8 ) 755 case GB_INT16_code : GB_BINOP_WORKER (_bget, _int16) 756 case GB_INT32_code : GB_BINOP_WORKER (_bget, _int32) 757 case GB_INT64_code : GB_BINOP_WORKER (_bget, _int64) 758 case GB_UINT8_code : GB_BINOP_WORKER (_bget, _uint8 ) 759 case GB_UINT16_code : GB_BINOP_WORKER (_bget, _uint16) 760 case GB_UINT32_code : GB_BINOP_WORKER (_bget, _uint32) 761 case GB_UINT64_code : GB_BINOP_WORKER (_bget, _uint64) 762 default: ; 763 } 764 break ; 765 766 //---------------------------------------------------------------------- 767 case GB_BSET_opcode : // z = bitset (x,y) 768 //---------------------------------------------------------------------- 769 770 switch (xcode) 771 { 772 case GB_INT8_code : GB_BINOP_WORKER (_bset, _int8 ) 773 case GB_INT16_code : GB_BINOP_WORKER (_bset, _int16) 774 case GB_INT32_code : GB_BINOP_WORKER (_bset, _int32) 775 case GB_INT64_code : GB_BINOP_WORKER (_bset, _int64) 776 case GB_UINT8_code : GB_BINOP_WORKER (_bset, _uint8 ) 777 case GB_UINT16_code : GB_BINOP_WORKER (_bset, _uint16) 778 case GB_UINT32_code : GB_BINOP_WORKER (_bset, _uint32) 779 case GB_UINT64_code : GB_BINOP_WORKER (_bset, _uint64) 780 default: ; 781 } 782 break ; 783 784 //---------------------------------------------------------------------- 785 case GB_BCLR_opcode : // z = bitclr (x,y) 786 //---------------------------------------------------------------------- 787 788 switch (xcode) 789 { 790 case GB_INT8_code : GB_BINOP_WORKER (_bclr, _int8 ) 791 case GB_INT16_code : GB_BINOP_WORKER (_bclr, _int16) 792 case GB_INT32_code : GB_BINOP_WORKER (_bclr, _int32) 793 case GB_INT64_code : GB_BINOP_WORKER (_bclr, _int64) 794 case GB_UINT8_code : GB_BINOP_WORKER (_bclr, _uint8 ) 795 case GB_UINT16_code : GB_BINOP_WORKER (_bclr, _uint16) 796 case GB_UINT32_code : GB_BINOP_WORKER (_bclr, _uint32) 797 case GB_UINT64_code : GB_BINOP_WORKER (_bclr, _uint64) 798 default: ; 799 } 800 break ; 801 802 //---------------------------------------------------------------------- 803 case GB_BSHIFT_opcode : // z = bitshift (x,y) 804 //---------------------------------------------------------------------- 805 806 // y is always int8; z and x have int* or uint* type 807 switch (xcode) 808 { 809 case GB_INT8_code : GB_BINOP_WORKER (_bshift, _int8 ) 810 case GB_INT16_code : GB_BINOP_WORKER (_bshift, _int16) 811 case GB_INT32_code : GB_BINOP_WORKER (_bshift, _int32) 812 case GB_INT64_code : GB_BINOP_WORKER (_bshift, _int64) 813 case GB_UINT8_code : GB_BINOP_WORKER (_bshift, _uint8 ) 814 case GB_UINT16_code : GB_BINOP_WORKER (_bshift, _uint16) 815 case GB_UINT32_code : GB_BINOP_WORKER (_bshift, _uint32) 816 case GB_UINT64_code : GB_BINOP_WORKER (_bshift, _uint64) 817 default: ; 818 } 819 break ; 820 821 #endif 822 823 //---------------------------------------------------------------------- 824 case GB_BOR_opcode : // z = (x | y), bitwise or 825 //---------------------------------------------------------------------- 826 827 switch (xcode) 828 { 829 #ifndef GB_BINOP_IS_SEMIRING_MULTIPLIER 830 // BOR for signed integers is not in any builtin semiring 831 case GB_INT8_code : GB_BINOP_WORKER (_bor, _int8 ) 832 case GB_INT16_code : GB_BINOP_WORKER (_bor, _int16) 833 case GB_INT32_code : GB_BINOP_WORKER (_bor, _int32) 834 case GB_INT64_code : GB_BINOP_WORKER (_bor, _int64) 835 #endif 836 case GB_UINT8_code : GB_BINOP_WORKER (_bor, _uint8 ) 837 case GB_UINT16_code : GB_BINOP_WORKER (_bor, _uint16) 838 case GB_UINT32_code : GB_BINOP_WORKER (_bor, _uint32) 839 case GB_UINT64_code : GB_BINOP_WORKER (_bor, _uint64) 840 default: ; 841 } 842 break ; 843 844 //---------------------------------------------------------------------- 845 case GB_BAND_opcode : // z = (x & y), bitwise and 846 //---------------------------------------------------------------------- 847 848 switch (xcode) 849 { 850 #ifndef GB_BINOP_IS_SEMIRING_MULTIPLIER 851 // BAND for signed integers is not in any builtin semiring 852 case GB_INT8_code : GB_BINOP_WORKER (_band, _int8 ) 853 case GB_INT16_code : GB_BINOP_WORKER (_band, _int16) 854 case GB_INT32_code : GB_BINOP_WORKER (_band, _int32) 855 case GB_INT64_code : GB_BINOP_WORKER (_band, _int64) 856 #endif 857 case GB_UINT8_code : GB_BINOP_WORKER (_band, _uint8 ) 858 case GB_UINT16_code : GB_BINOP_WORKER (_band, _uint16) 859 case GB_UINT32_code : GB_BINOP_WORKER (_band, _uint32) 860 case GB_UINT64_code : GB_BINOP_WORKER (_band, _uint64) 861 default: ; 862 } 863 break ; 864 865 //---------------------------------------------------------------------- 866 case GB_BXOR_opcode : // z = (x ^ y), bitwise xor 867 //---------------------------------------------------------------------- 868 869 switch (xcode) 870 { 871 #ifndef GB_BINOP_IS_SEMIRING_MULTIPLIER 872 // BXOR for signed integers is not in any builtin semiring 873 case GB_INT8_code : GB_BINOP_WORKER (_bxor, _int8 ) 874 case GB_INT16_code : GB_BINOP_WORKER (_bxor, _int16) 875 case GB_INT32_code : GB_BINOP_WORKER (_bxor, _int32) 876 case GB_INT64_code : GB_BINOP_WORKER (_bxor, _int64) 877 #endif 878 case GB_UINT8_code : GB_BINOP_WORKER (_bxor, _uint8 ) 879 case GB_UINT16_code : GB_BINOP_WORKER (_bxor, _uint16) 880 case GB_UINT32_code : GB_BINOP_WORKER (_bxor, _uint32) 881 case GB_UINT64_code : GB_BINOP_WORKER (_bxor, _uint64) 882 default: ; 883 } 884 break ; 885 886 //---------------------------------------------------------------------- 887 case GB_BXNOR_opcode : // z = ~(x ^ y), bitwise xnor 888 //---------------------------------------------------------------------- 889 890 switch (xcode) 891 { 892 #ifndef GB_BINOP_IS_SEMIRING_MULTIPLIER 893 // BXNOR for signed integers is not in any builtin semiring 894 case GB_INT8_code : GB_BINOP_WORKER (_bxnor, _int8 ) 895 case GB_INT16_code : GB_BINOP_WORKER (_bxnor, _int16) 896 case GB_INT32_code : GB_BINOP_WORKER (_bxnor, _int32) 897 case GB_INT64_code : GB_BINOP_WORKER (_bxnor, _int64) 898 #endif 899 case GB_UINT8_code : GB_BINOP_WORKER (_bxnor, _uint8 ) 900 case GB_UINT16_code : GB_BINOP_WORKER (_bxnor, _uint16) 901 case GB_UINT32_code : GB_BINOP_WORKER (_bxnor, _uint32) 902 case GB_UINT64_code : GB_BINOP_WORKER (_bxnor, _uint64) 903 default: ; 904 } 905 break ; 906 907 #endif 908 909 default: ; 910 } 911 } 912 913 #undef GB_NO_FIRST 914 #undef GB_NO_SECOND 915 #undef GB_NO_PAIR 916 917