1 //------------------------------------------------------------------------------ 2 // GB_AxB_compare_factory.c: switch factory for C=A*B with comparator ops 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 // A template file #include'd in GB_AxB_factory.c, which calls 50 or 55 11 // semirings, with 5 monoids (lor, land, eq, lxor, any) and 10 or 11 types (the 12 // 10 real, non-boolean times, plus boolean). 13 14 // The multiply operator is a comparator: EQ, NE, GT, LT, GE, LE. 15 // z=f(x,y): x and x are either boolean or non-boolean. z is boolean. 16 17 // Since z is boolean, the only monoids available are OR, AND, XOR, EQ, and 18 // ANY. All the other four (max==plus==or, min==times==and) are redundant. 19 // Those opcodes have been renamed, and handled by the OR and AND workers 20 // defined here. 21 22 // There is one special case to consider. For boolean x, y, and z, the 23 // function z=NE(x,y) is the same as z=XOR(x,y). If z is boolean, the multiply 24 // operator NE has already been renamed XOR by GB_AxB_semiring_builtin, and 25 // thus NE will never use the boolean case, below. Thus it is removed with the 26 // #ifndef GB_NO_BOOLEAN, resulting in 50 semirings for the NE muliply 27 // operator. 28 29 ASSERT (zcode == GB_BOOL_code) ; 30 { 31 32 // C = A*B where C is boolean, but A and B are non-boolean. 33 // The result of the compare(A,B) operation is boolean. 34 // There are 4 monoids available: OR, AND, XOR, EQ 35 36 switch (add_opcode) 37 { 38 39 case GB_LOR_opcode : 40 41 switch (xcode) 42 { 43 #ifndef GB_NO_BOOLEAN 44 case GB_BOOL_code : GB_AxB_WORKER (_lor, GB_MNAME, _bool ) 45 #endif 46 case GB_INT8_code : GB_AxB_WORKER (_lor, GB_MNAME, _int8 ) 47 case GB_INT16_code : GB_AxB_WORKER (_lor, GB_MNAME, _int16 ) 48 case GB_INT32_code : GB_AxB_WORKER (_lor, GB_MNAME, _int32 ) 49 case GB_INT64_code : GB_AxB_WORKER (_lor, GB_MNAME, _int64 ) 50 case GB_UINT8_code : GB_AxB_WORKER (_lor, GB_MNAME, _uint8 ) 51 case GB_UINT16_code : GB_AxB_WORKER (_lor, GB_MNAME, _uint16) 52 case GB_UINT32_code : GB_AxB_WORKER (_lor, GB_MNAME, _uint32) 53 case GB_UINT64_code : GB_AxB_WORKER (_lor, GB_MNAME, _uint64) 54 case GB_FP32_code : GB_AxB_WORKER (_lor, GB_MNAME, _fp32 ) 55 case GB_FP64_code : GB_AxB_WORKER (_lor, GB_MNAME, _fp64 ) 56 default: ; 57 } 58 break ; 59 60 case GB_LAND_opcode : 61 62 switch (xcode) 63 { 64 // 10 real, non-boolean types, plus boolean 65 #ifndef GB_NO_BOOLEAN 66 case GB_BOOL_code : GB_AxB_WORKER (_land, GB_MNAME, _bool ) 67 #endif 68 case GB_INT8_code : GB_AxB_WORKER (_land, GB_MNAME, _int8 ) 69 case GB_INT16_code : GB_AxB_WORKER (_land, GB_MNAME, _int16 ) 70 case GB_INT32_code : GB_AxB_WORKER (_land, GB_MNAME, _int32 ) 71 case GB_INT64_code : GB_AxB_WORKER (_land, GB_MNAME, _int64 ) 72 case GB_UINT8_code : GB_AxB_WORKER (_land, GB_MNAME, _uint8 ) 73 case GB_UINT16_code : GB_AxB_WORKER (_land, GB_MNAME, _uint16) 74 case GB_UINT32_code : GB_AxB_WORKER (_land, GB_MNAME, _uint32) 75 case GB_UINT64_code : GB_AxB_WORKER (_land, GB_MNAME, _uint64) 76 case GB_FP32_code : GB_AxB_WORKER (_land, GB_MNAME, _fp32 ) 77 case GB_FP64_code : GB_AxB_WORKER (_land, GB_MNAME, _fp64 ) 78 default: ; 79 } 80 break ; 81 82 case GB_LXOR_opcode : 83 84 switch (xcode) 85 { 86 #ifndef GB_NO_BOOLEAN 87 case GB_BOOL_code : GB_AxB_WORKER (_lxor, GB_MNAME, _bool ) 88 #endif 89 case GB_INT8_code : GB_AxB_WORKER (_lxor, GB_MNAME, _int8 ) 90 case GB_INT16_code : GB_AxB_WORKER (_lxor, GB_MNAME, _int16 ) 91 case GB_INT32_code : GB_AxB_WORKER (_lxor, GB_MNAME, _int32 ) 92 case GB_INT64_code : GB_AxB_WORKER (_lxor, GB_MNAME, _int64 ) 93 case GB_UINT8_code : GB_AxB_WORKER (_lxor, GB_MNAME, _uint8 ) 94 case GB_UINT16_code : GB_AxB_WORKER (_lxor, GB_MNAME, _uint16) 95 case GB_UINT32_code : GB_AxB_WORKER (_lxor, GB_MNAME, _uint32) 96 case GB_UINT64_code : GB_AxB_WORKER (_lxor, GB_MNAME, _uint64) 97 case GB_FP32_code : GB_AxB_WORKER (_lxor, GB_MNAME, _fp32 ) 98 case GB_FP64_code : GB_AxB_WORKER (_lxor, GB_MNAME, _fp64 ) 99 default: ; 100 } 101 break ; 102 103 case GB_EQ_opcode : 104 105 switch (xcode) 106 { 107 #ifndef GB_NO_BOOLEAN 108 case GB_BOOL_code : GB_AxB_WORKER (_eq, GB_MNAME, _bool ) 109 #endif 110 case GB_INT8_code : GB_AxB_WORKER (_eq, GB_MNAME, _int8 ) 111 case GB_INT16_code : GB_AxB_WORKER (_eq, GB_MNAME, _int16 ) 112 case GB_INT32_code : GB_AxB_WORKER (_eq, GB_MNAME, _int32 ) 113 case GB_INT64_code : GB_AxB_WORKER (_eq, GB_MNAME, _int64 ) 114 case GB_UINT8_code : GB_AxB_WORKER (_eq, GB_MNAME, _uint8 ) 115 case GB_UINT16_code : GB_AxB_WORKER (_eq, GB_MNAME, _uint16) 116 case GB_UINT32_code : GB_AxB_WORKER (_eq, GB_MNAME, _uint32) 117 case GB_UINT64_code : GB_AxB_WORKER (_eq, GB_MNAME, _uint64) 118 case GB_FP32_code : GB_AxB_WORKER (_eq, GB_MNAME, _fp32 ) 119 case GB_FP64_code : GB_AxB_WORKER (_eq, GB_MNAME, _fp64 ) 120 default: ; 121 } 122 break ; 123 124 case GB_ANY_opcode : 125 126 switch (xcode) 127 { 128 #ifndef GB_NO_BOOLEAN 129 case GB_BOOL_code : GB_AxB_WORKER (_any, GB_MNAME, _bool ) 130 #endif 131 case GB_INT8_code : GB_AxB_WORKER (_any, GB_MNAME, _int8 ) 132 case GB_INT16_code : GB_AxB_WORKER (_any, GB_MNAME, _int16 ) 133 case GB_INT32_code : GB_AxB_WORKER (_any, GB_MNAME, _int32 ) 134 case GB_INT64_code : GB_AxB_WORKER (_any, GB_MNAME, _int64 ) 135 case GB_UINT8_code : GB_AxB_WORKER (_any, GB_MNAME, _uint8 ) 136 case GB_UINT16_code : GB_AxB_WORKER (_any, GB_MNAME, _uint16) 137 case GB_UINT32_code : GB_AxB_WORKER (_any, GB_MNAME, _uint32) 138 case GB_UINT64_code : GB_AxB_WORKER (_any, GB_MNAME, _uint64) 139 case GB_FP32_code : GB_AxB_WORKER (_any, GB_MNAME, _fp32 ) 140 case GB_FP64_code : GB_AxB_WORKER (_any, GB_MNAME, _fp64 ) 141 default: ; 142 } 143 break ; 144 145 default: ; 146 } 147 } 148 149 #undef GB_NO_BOOLEAN 150 #undef GB_MNAME 151 152