1 //------------------------------------------------------------------------------ 2 // GB_ops.c: built-in types, functions, operators, and other externs 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 // This file defines the predefined built-in types, descriptors, unary 11 // operators, binary operators, monoids, and semirings. 12 13 #include "GB.h" 14 15 //------------------------------------------------------------------------------ 16 // built-in types 17 //------------------------------------------------------------------------------ 18 19 // extern predefined type objects but opaque to the user 20 struct GB_Type_opaque 21 GB_OPAQUE (BOOL) = {GB_MAGIC, 0, sizeof (bool) , GB_BOOL_code , "bool" }, 22 GB_OPAQUE (INT8) = {GB_MAGIC, 0, sizeof (int8_t) , GB_INT8_code , "int8_t" }, 23 GB_OPAQUE (UINT8) = {GB_MAGIC, 0, sizeof (uint8_t) , GB_UINT8_code , "uint8_t" }, 24 GB_OPAQUE (INT16) = {GB_MAGIC, 0, sizeof (int16_t) , GB_INT16_code , "int16_t" }, 25 GB_OPAQUE (UINT16) = {GB_MAGIC, 0, sizeof (uint16_t) , GB_UINT16_code, "uint16_t" }, 26 GB_OPAQUE (INT32) = {GB_MAGIC, 0, sizeof (int32_t) , GB_INT32_code , "int32_t" }, 27 GB_OPAQUE (UINT32) = {GB_MAGIC, 0, sizeof (uint32_t) , GB_UINT32_code, "uint32_t" }, 28 GB_OPAQUE (INT64) = {GB_MAGIC, 0, sizeof (int64_t) , GB_INT64_code , "int64_t" }, 29 GB_OPAQUE (UINT64) = {GB_MAGIC, 0, sizeof (uint64_t) , GB_UINT64_code, "uint64_t" }, 30 GB_OPAQUE (FP32) = {GB_MAGIC, 0, sizeof (float) , GB_FP32_code , "float" }, 31 GB_OPAQUE (FP64) = {GB_MAGIC, 0, sizeof (double) , GB_FP64_code , "double" }, 32 GB_OPAQUE (FC32) = {GB_MAGIC, 0, sizeof (GxB_FC32_t), GB_FC32_code , "float complex" }, 33 GB_OPAQUE (FC64) = {GB_MAGIC, 0, sizeof (GxB_FC64_t), GB_FC64_code , "double complex"} ; 34 35 // extern predefined types (handles to opaque types) 36 GrB_Type 37 GrB_BOOL = & GB_OPAQUE (BOOL) , 38 GrB_INT8 = & GB_OPAQUE (INT8) , 39 GrB_UINT8 = & GB_OPAQUE (UINT8) , 40 GrB_INT16 = & GB_OPAQUE (INT16) , 41 GrB_UINT16 = & GB_OPAQUE (UINT16) , 42 GrB_INT32 = & GB_OPAQUE (INT32) , 43 GrB_UINT32 = & GB_OPAQUE (UINT32) , 44 GrB_INT64 = & GB_OPAQUE (INT64) , 45 GrB_UINT64 = & GB_OPAQUE (UINT64) , 46 GrB_FP32 = & GB_OPAQUE (FP32) , 47 GrB_FP64 = & GB_OPAQUE (FP64) , 48 GxB_FC32 = & GB_OPAQUE (FC32) , 49 GxB_FC64 = & GB_OPAQUE (FC64) ; 50 51 //------------------------------------------------------------------------------ 52 // built-in descriptors 53 //------------------------------------------------------------------------------ 54 55 #define o ((GrB_Desc_Value) GxB_DEFAULT) 56 57 #define GB_DESC(name,out,mask,in0,in1) \ 58 struct GB_Descriptor_opaque GB_OPAQUE (desc_ ## name) = \ 59 { \ 60 GB_MAGIC, 0, /* initialized */ \ 61 "", 0, /* logger */ \ 62 (double) GxB_DEFAULT, /* chunk */ \ 63 (GrB_Desc_Value) (out), \ 64 (GrB_Desc_Value) (mask), \ 65 (GrB_Desc_Value) (in0), \ 66 (GrB_Desc_Value) (in1), \ 67 o, o, /* default: axb, #threads */ \ 68 0 /* no sort */ \ 69 } ; \ 70 GrB_Descriptor GRB (DESC_ ## name) = & GB_OPAQUE (desc_ ## name) ; 71 72 // name outp structure complement in0 in1 73 74 // GrB_NULL , o , o + o , o , o 75 GB_DESC (T1 , o , o + o , o , GrB_TRAN ) 76 GB_DESC (T0 , o , o + o , GrB_TRAN, o ) 77 GB_DESC (T0T1 , o , o + o , GrB_TRAN, GrB_TRAN ) 78 79 GB_DESC (C , o , o + GrB_COMP, o , o ) 80 GB_DESC (CT1 , o , o + GrB_COMP, o , GrB_TRAN ) 81 GB_DESC (CT0 , o , o + GrB_COMP, GrB_TRAN, o ) 82 GB_DESC (CT0T1 , o , o + GrB_COMP, GrB_TRAN, GrB_TRAN ) 83 84 GB_DESC (S , o , GrB_STRUCTURE + o , o , o ) 85 GB_DESC (ST1 , o , GrB_STRUCTURE + o , o , GrB_TRAN ) 86 GB_DESC (ST0 , o , GrB_STRUCTURE + o , GrB_TRAN, o ) 87 GB_DESC (ST0T1 , o , GrB_STRUCTURE + o , GrB_TRAN, GrB_TRAN ) 88 89 GB_DESC (SC , o , GrB_STRUCTURE + GrB_COMP, o , o ) 90 GB_DESC (SCT1 , o , GrB_STRUCTURE + GrB_COMP, o , GrB_TRAN ) 91 GB_DESC (SCT0 , o , GrB_STRUCTURE + GrB_COMP, GrB_TRAN, o ) 92 GB_DESC (SCT0T1 , o , GrB_STRUCTURE + GrB_COMP, GrB_TRAN, GrB_TRAN ) 93 94 GB_DESC (R , GrB_REPLACE, o + o , o , o ) 95 GB_DESC (RT1 , GrB_REPLACE, o + o , o , GrB_TRAN ) 96 GB_DESC (RT0 , GrB_REPLACE, o + o , GrB_TRAN, o ) 97 GB_DESC (RT0T1 , GrB_REPLACE, o + o , GrB_TRAN, GrB_TRAN ) 98 99 GB_DESC (RC , GrB_REPLACE, o + GrB_COMP, o , o ) 100 GB_DESC (RCT1 , GrB_REPLACE, o + GrB_COMP, o , GrB_TRAN ) 101 GB_DESC (RCT0 , GrB_REPLACE, o + GrB_COMP, GrB_TRAN, o ) 102 GB_DESC (RCT0T1 , GrB_REPLACE, o + GrB_COMP, GrB_TRAN, GrB_TRAN ) 103 104 GB_DESC (RS , GrB_REPLACE, GrB_STRUCTURE + o , o , o ) 105 GB_DESC (RST1 , GrB_REPLACE, GrB_STRUCTURE + o , o , GrB_TRAN ) 106 GB_DESC (RST0 , GrB_REPLACE, GrB_STRUCTURE + o , GrB_TRAN, o ) 107 GB_DESC (RST0T1 , GrB_REPLACE, GrB_STRUCTURE + o , GrB_TRAN, GrB_TRAN ) 108 109 GB_DESC (RSC , GrB_REPLACE, GrB_STRUCTURE + GrB_COMP, o , o ) 110 GB_DESC (RSCT1 , GrB_REPLACE, GrB_STRUCTURE + GrB_COMP, o , GrB_TRAN ) 111 GB_DESC (RSCT0 , GrB_REPLACE, GrB_STRUCTURE + GrB_COMP, GrB_TRAN, o ) 112 GB_DESC (RSCT0T1, GrB_REPLACE, GrB_STRUCTURE + GrB_COMP, GrB_TRAN, GrB_TRAN ) 113 114 #undef o 115 116 //------------------------------------------------------------------------------ 117 // built-in unary and binary operators 118 //------------------------------------------------------------------------------ 119 120 #if defined __INTEL_COMPILER 121 // disable icc warnings 122 // 144: initialize with incompatible pointer 123 #pragma warning (disable: 144 ) 124 #elif defined __GNUC__ 125 #if !defined ( __cplusplus ) 126 #pragma GCC diagnostic ignored "-Wincompatible-pointer-types" 127 #endif 128 #endif 129 130 #if ( _MSC_VER && !__INTEL_COMPILER ) 131 // disable MS Visual Studio warnings 132 GB_PRAGMA (warning (disable : 4146 )) 133 #endif 134 135 #define GB_OP(op) GB_EVAL3 (op, _, GB_XTYPE) 136 137 // helper macros to define unary operators 138 #define GB_OP1zx(op,str,z_t,ztype,x_t,xtype) \ 139 extern void GB_FUNC_T (op, xtype) (z_t *z, const x_t *x) ; \ 140 struct GB_UnaryOp_opaque GB_OPAQUE (GB_OP (op)) = \ 141 { \ 142 GB_MAGIC, 0, \ 143 & GB_OPAQUE (xtype), \ 144 & GB_OPAQUE (ztype), \ 145 (GxB_unary_function) (& GB_FUNC_T (op, xtype)), \ 146 str, \ 147 GB_ ## op ## _opcode \ 148 } ; 149 150 #define GRB_OP1z(op,str,z_t,ztype) \ 151 GB_OP1zx (op, str, z_t, ztype, GB_TYPE, GB_XTYPE) \ 152 GrB_UnaryOp GRB (GB_OP (op)) = & GB_OPAQUE (GB_OP (op)) ; 153 154 #define GRB_OP1(op,str) GRB_OP1z (op, str, GB_TYPE, GB_XTYPE) 155 156 #define GXB_OP1z(op,str,z_t,ztype) \ 157 GB_OP1zx (op, str, z_t, ztype, GB_TYPE, GB_XTYPE) \ 158 GrB_UnaryOp GXB (GB_OP (op)) = & GB_OPAQUE (GB_OP (op)) ; 159 160 #define GXB_OP1(op,str) GXB_OP1z (op, str, GB_TYPE, GB_XTYPE) 161 162 #define GXB_OP1_RENAME(op) \ 163 GrB_UnaryOp GXB (GB_OP (op)) = & GB_OPAQUE (GB_OP (op)) ; 164 165 // helper macros to define binary operators 166 #define GB_OP2zxy(op,str,z_t,ztype,x_t,xtype,y_t,ytype) \ 167 extern void GB_FUNC_T(op,xtype) (z_t *z, const x_t *x, const y_t *y) ; \ 168 struct GB_BinaryOp_opaque GB_OPAQUE (GB_OP (op)) = \ 169 { \ 170 GB_MAGIC, 0, \ 171 & GB_OPAQUE (xtype), \ 172 & GB_OPAQUE (ytype), \ 173 & GB_OPAQUE (ztype), \ 174 (GxB_binary_function) (& GB_FUNC_T (op, xtype)), \ 175 str, \ 176 GB_ ## op ## _opcode \ 177 } ; 178 179 #define GRB_OP2z(op,str,z_t,ztype) \ 180 GB_OP2zxy (op, str, z_t, ztype, GB_TYPE, GB_XTYPE, GB_TYPE, GB_XTYPE) \ 181 GrB_BinaryOp GRB (GB_OP (op)) = & GB_OPAQUE (GB_OP (op)) ; 182 183 #define GRB_OP2(op,str) GRB_OP2z (op, str, GB_TYPE, GB_XTYPE) 184 185 #define GXB_OP2z(op,str,z_t,ztype) \ 186 GB_OP2zxy (op, str, z_t, ztype, GB_TYPE, GB_XTYPE, GB_TYPE, GB_XTYPE) \ 187 GrB_BinaryOp GXB (GB_OP (op)) = & GB_OPAQUE (GB_OP (op)) ; 188 189 #define GXB_OP2(op,str) GXB_OP2z (op, str, GB_TYPE, GB_XTYPE) 190 191 #define GXB_OP2shift(op,str) \ 192 GB_OP2zxy (op, str, GB_TYPE, GB_XTYPE, GB_TYPE, GB_XTYPE, int8_t, INT8) \ 193 GrB_BinaryOp GXB (GB_OP (op)) = & GB_OPAQUE (GB_OP (op)) ; 194 195 #define GB_TYPE bool 196 #define GB_XTYPE BOOL 197 #include "GB_ops_template.c" 198 199 #define GB_TYPE int8_t 200 #define GB_XTYPE INT8 201 #define GB_SIGNED_INT 202 #include "GB_ops_template.c" 203 204 #define GB_TYPE uint8_t 205 #define GB_XTYPE UINT8 206 #define GB_UNSIGNED_INT 207 #include "GB_ops_template.c" 208 209 #define GB_TYPE int16_t 210 #define GB_XTYPE INT16 211 #define GB_SIGNED_INT 212 #include "GB_ops_template.c" 213 214 #define GB_TYPE uint16_t 215 #define GB_XTYPE UINT16 216 #define GB_UNSIGNED_INT 217 #include "GB_ops_template.c" 218 219 #define GB_TYPE int32_t 220 #define GB_XTYPE INT32 221 #define GB_SIGNED_INT 222 #include "GB_ops_template.c" 223 224 #define GB_TYPE uint32_t 225 #define GB_XTYPE UINT32 226 #define GB_UNSIGNED_INT 227 #include "GB_ops_template.c" 228 229 #define GB_TYPE int64_t 230 #define GB_XTYPE INT64 231 #define GB_SIGNED_INT 232 #include "GB_ops_template.c" 233 234 #define GB_TYPE uint64_t 235 #define GB_XTYPE UINT64 236 #define GB_UNSIGNED_INT 237 #include "GB_ops_template.c" 238 239 #define GB_TYPE float 240 #define GB_XTYPE FP32 241 #define GB_FLOAT 242 #define GB_FLOATING_POINT 243 #include "GB_ops_template.c" 244 245 #define GB_TYPE double 246 #define GB_XTYPE FP64 247 #define GB_DOUBLE 248 #define GB_FLOATING_POINT 249 #include "GB_ops_template.c" 250 251 #define GB_TYPE GxB_FC32_t 252 #define GB_XTYPE FC32 253 #define GB_FLOAT_COMPLEX 254 #define GB_COMPLEX 255 #define GB_FLOATING_POINT 256 #include "GB_ops_template.c" 257 258 #define GB_TYPE GxB_FC64_t 259 #define GB_XTYPE FC64 260 #define GB_DOUBLE_COMPLEX 261 #define GB_COMPLEX 262 #define GB_FLOATING_POINT 263 #include "GB_ops_template.c" 264 265 //------------------------------------------------------------------------------ 266 // special cases for functions and operators 267 //------------------------------------------------------------------------------ 268 269 // 5 special cases: 270 // purely boolean operators: these do not have _BOOL in their name 271 // They are not created by the templates above. 272 GrB_UnaryOp GrB_LNOT = & GB_OPAQUE (LNOT_BOOL) ; 273 GrB_BinaryOp GrB_LOR = & GB_OPAQUE (LOR_BOOL) ; 274 GrB_BinaryOp GrB_LAND = & GB_OPAQUE (LAND_BOOL) ; 275 GrB_BinaryOp GrB_LXOR = & GB_OPAQUE (LXOR_BOOL) ; 276 GrB_BinaryOp GrB_LXNOR = & GB_OPAQUE (EQ_BOOL) ; 277 278 //------------------------------------------------------------------------------ 279 // positional unary and binary operators 280 //------------------------------------------------------------------------------ 281 282 // The function pointer inside a positional operator cannot be called directly, 283 // since it does not depend on the values of its two arguments. The operator 284 // can only be implemented via its opcode. 285 286 // helper macros to define positional unary operators 287 #define GXB_OP1_POS(op,str,type) \ 288 struct GB_UnaryOp_opaque GB_OPAQUE (op ## _ ## type) = \ 289 { \ 290 GB_MAGIC, 0, \ 291 & GB_OPAQUE (type), \ 292 & GB_OPAQUE (type), \ 293 NULL, /* op->function is NULL; it cannot be called */ \ 294 str, \ 295 GB_ ## op ## _opcode \ 296 } ; \ 297 GrB_UnaryOp GXB (op ## _ ## type) = & GB_OPAQUE (op ## _ ## type) ; 298 299 // helper macros to define positional binary operators 300 #define GXB_OP2_POS(op,str,type) \ 301 struct GB_BinaryOp_opaque GB_OPAQUE (op ## _ ## type) = \ 302 { \ 303 GB_MAGIC, 0, \ 304 & GB_OPAQUE (type), \ 305 & GB_OPAQUE (type), \ 306 & GB_OPAQUE (type), \ 307 NULL, /* op->function is NULL; it cannot be called */ \ 308 str, \ 309 GB_ ## op ## _opcode \ 310 } ; \ 311 GrB_BinaryOp GXB (op ## _ ## type) = & GB_OPAQUE (op ## _ ## type) ; 312 313 GXB_OP1_POS (POSITIONI , "positioni" , INT32) ; 314 GXB_OP1_POS (POSITIONI , "positioni" , INT64) ; 315 GXB_OP1_POS (POSITIONI1, "positioni1", INT32) ; 316 GXB_OP1_POS (POSITIONI1, "positioni1", INT64) ; 317 GXB_OP1_POS (POSITIONJ , "positionj" , INT32) ; 318 GXB_OP1_POS (POSITIONJ , "positionj" , INT64) ; 319 GXB_OP1_POS (POSITIONJ1, "positionj1", INT32) ; 320 GXB_OP1_POS (POSITIONJ1, "positionj1", INT64) ; 321 322 GXB_OP2_POS (FIRSTI , "firsti" , INT32) ; 323 GXB_OP2_POS (FIRSTI , "firsti" , INT64) ; 324 GXB_OP2_POS (FIRSTI1 , "firsti1" , INT32) ; 325 GXB_OP2_POS (FIRSTI1 , "firsti1" , INT64) ; 326 GXB_OP2_POS (FIRSTJ , "firstj" , INT32) ; 327 GXB_OP2_POS (FIRSTJ , "firstj" , INT64) ; 328 GXB_OP2_POS (FIRSTJ1 , "firstj1" , INT32) ; 329 GXB_OP2_POS (FIRSTJ1 , "firstj1" , INT64) ; 330 331 GXB_OP2_POS (SECONDI , "secondi" , INT32) ; 332 GXB_OP2_POS (SECONDI , "secondi" , INT64) ; 333 GXB_OP2_POS (SECONDI1 , "secondi1" , INT32) ; 334 GXB_OP2_POS (SECONDI1 , "secondi1" , INT64) ; 335 GXB_OP2_POS (SECONDJ , "secondj" , INT32) ; 336 GXB_OP2_POS (SECONDJ , "secondj" , INT64) ; 337 GXB_OP2_POS (SECONDJ1 , "secondj1" , INT32) ; 338 GXB_OP2_POS (SECONDJ1 , "secondj1" , INT64) ; 339 340 //------------------------------------------------------------------------------ 341 // built-in select operators 342 //------------------------------------------------------------------------------ 343 344 struct GB_SelectOp_opaque GB_OPAQUE (TRIL ) = { GB_MAGIC, 0, NULL, NULL, NULL, "tril" , GB_TRIL_opcode } ; 345 struct GB_SelectOp_opaque GB_OPAQUE (TRIU ) = { GB_MAGIC, 0, NULL, NULL, NULL, "triu" , GB_TRIU_opcode } ; 346 struct GB_SelectOp_opaque GB_OPAQUE (DIAG ) = { GB_MAGIC, 0, NULL, NULL, NULL, "diag" , GB_DIAG_opcode } ; 347 struct GB_SelectOp_opaque GB_OPAQUE (OFFDIAG ) = { GB_MAGIC, 0, NULL, NULL, NULL, "offdiag" , GB_OFFDIAG_opcode } ; 348 struct GB_SelectOp_opaque GB_OPAQUE (NONZERO ) = { GB_MAGIC, 0, NULL, NULL, NULL, "nonzero" , GB_NONZERO_opcode } ; 349 struct GB_SelectOp_opaque GB_OPAQUE (EQ_ZERO ) = { GB_MAGIC, 0, NULL, NULL, NULL, "eq_zero" , GB_EQ_ZERO_opcode } ; 350 struct GB_SelectOp_opaque GB_OPAQUE (GT_ZERO ) = { GB_MAGIC, 0, NULL, NULL, NULL, "gt_zero" , GB_GT_ZERO_opcode } ; 351 struct GB_SelectOp_opaque GB_OPAQUE (GE_ZERO ) = { GB_MAGIC, 0, NULL, NULL, NULL, "ge_zero" , GB_GE_ZERO_opcode } ; 352 struct GB_SelectOp_opaque GB_OPAQUE (LT_ZERO ) = { GB_MAGIC, 0, NULL, NULL, NULL, "lt_zero" , GB_LT_ZERO_opcode } ; 353 struct GB_SelectOp_opaque GB_OPAQUE (LE_ZERO ) = { GB_MAGIC, 0, NULL, NULL, NULL, "le_zero" , GB_LE_ZERO_opcode } ; 354 struct GB_SelectOp_opaque GB_OPAQUE (NE_THUNK) = { GB_MAGIC, 0, NULL, NULL, NULL, "ne_thunk", GB_NE_THUNK_opcode } ; 355 struct GB_SelectOp_opaque GB_OPAQUE (EQ_THUNK) = { GB_MAGIC, 0, NULL, NULL, NULL, "eq_thunk", GB_EQ_THUNK_opcode } ; 356 struct GB_SelectOp_opaque GB_OPAQUE (GT_THUNK) = { GB_MAGIC, 0, NULL, NULL, NULL, "gt_thunk", GB_GT_THUNK_opcode } ; 357 struct GB_SelectOp_opaque GB_OPAQUE (GE_THUNK) = { GB_MAGIC, 0, NULL, NULL, NULL, "ge_thunk", GB_GE_THUNK_opcode } ; 358 struct GB_SelectOp_opaque GB_OPAQUE (LT_THUNK) = { GB_MAGIC, 0, NULL, NULL, NULL, "lt_thunk", GB_LT_THUNK_opcode } ; 359 struct GB_SelectOp_opaque GB_OPAQUE (LE_THUNK) = { GB_MAGIC, 0, NULL, NULL, NULL, "le_thunk", GB_LE_THUNK_opcode } ; 360 361 GxB_SelectOp GxB_TRIL = & GB_OPAQUE (TRIL) ; 362 GxB_SelectOp GxB_TRIU = & GB_OPAQUE (TRIU) ; 363 GxB_SelectOp GxB_DIAG = & GB_OPAQUE (DIAG) ; 364 GxB_SelectOp GxB_OFFDIAG = & GB_OPAQUE (OFFDIAG) ; 365 366 GxB_SelectOp GxB_NONZERO = & GB_OPAQUE (NONZERO) ; 367 GxB_SelectOp GxB_EQ_ZERO = & GB_OPAQUE (EQ_ZERO) ; 368 GxB_SelectOp GxB_GT_ZERO = & GB_OPAQUE (GT_ZERO) ; 369 GxB_SelectOp GxB_GE_ZERO = & GB_OPAQUE (GE_ZERO) ; 370 GxB_SelectOp GxB_LT_ZERO = & GB_OPAQUE (LT_ZERO) ; 371 GxB_SelectOp GxB_LE_ZERO = & GB_OPAQUE (LE_ZERO) ; 372 373 GxB_SelectOp GxB_NE_THUNK = & GB_OPAQUE (NE_THUNK) ; 374 GxB_SelectOp GxB_EQ_THUNK = & GB_OPAQUE (EQ_THUNK) ; 375 GxB_SelectOp GxB_GT_THUNK = & GB_OPAQUE (GT_THUNK) ; 376 GxB_SelectOp GxB_GE_THUNK = & GB_OPAQUE (GE_THUNK) ; 377 GxB_SelectOp GxB_LT_THUNK = & GB_OPAQUE (LT_THUNK) ; 378 GxB_SelectOp GxB_LE_THUNK = & GB_OPAQUE (LE_THUNK) ; 379 380 //------------------------------------------------------------------------------ 381 // GrB_ALL 382 //------------------------------------------------------------------------------ 383 384 // The GrB_ALL pointer is never deferenced. It is passed in as an argument to 385 // indicate that all indices are to be used, as in the colon in C = A(:,j). 386 387 GrB_Index GB_OPAQUE (ALL) = 0 ; 388 const GrB_Index *GrB_ALL = & GB_OPAQUE (ALL) ; 389 390 // the default hyper_switch is defined in GB_defaults.h 391 const double GxB_HYPER_DEFAULT = GB_HYPER_SWITCH_DEFAULT ; 392 393 // set GxB_HYPER_SWITCH to either of these to ensure matrix is always, or never, 394 // stored in hypersparse format, respectively. 395 const double GxB_ALWAYS_HYPER = GB_ALWAYS_HYPER ; 396 const double GxB_NEVER_HYPER = GB_NEVER_HYPER ; 397 const GxB_Format_Value GxB_FORMAT_DEFAULT = GB_FORMAT_DEFAULT ; 398 399 //------------------------------------------------------------------------------ 400 // predefined built-in monoids 401 //------------------------------------------------------------------------------ 402 403 #if ( _MSC_VER && !__INTEL_COMPILER ) 404 #define GB_FC32_ONE {1.0f, 0.0f} 405 #define GB_FC64_ONE {1.0 , 0.0 } 406 #define GB_FC32_ZERO {0.0f, 0.0f} 407 #define GB_FC64_ZERO {0.0 , 0.0 } 408 #else 409 #define GB_FC32_ONE GxB_CMPLXF (1,0) 410 #define GB_FC64_ONE GxB_CMPLX (1,0) 411 #define GB_FC32_ZERO GxB_CMPLXF (0,0) 412 #define GB_FC64_ZERO GxB_CMPLX (0,0) 413 #endif 414 415 // helper macro to define built-in monoids (no terminal value) 416 #define GB_MONOID_DEF(op,ztype,identity) \ 417 ztype GB_OPAQUE (GB_EVAL2 (identity_, op)) = identity ; \ 418 struct GB_Monoid_opaque GB_OPAQUE (GB_EVAL2 (op, _MONOID)) = \ 419 { \ 420 GB_MAGIC, 0, \ 421 & GB_OPAQUE (op), \ 422 & GB_OPAQUE (GB_EVAL2 (identity_, op)), \ 423 NULL, \ 424 0, 0 \ 425 } ; \ 426 GrB_Monoid GXB (GB_EVAL2 (op, _MONOID)) = \ 427 & GB_OPAQUE (GB_EVAL2 (op, _MONOID)) ; 428 429 // helper macro to define built-in monoids (with terminal value) 430 #define GB_MONOID_DEFT(op,ztype,identity,terminal) \ 431 ztype GB_OPAQUE (GB_EVAL2 (identity_, op)) = identity ; \ 432 ztype GB_OPAQUE (GB_EVAL2 (terminal_, op)) = terminal ; \ 433 struct GB_Monoid_opaque GB_OPAQUE (GB_EVAL2 (op, _MONOID)) = \ 434 { \ 435 GB_MAGIC, 0, \ 436 & GB_OPAQUE (op), \ 437 & GB_OPAQUE (GB_EVAL2 (identity_, op)), \ 438 & GB_OPAQUE (GB_EVAL2 (terminal_, op)), \ 439 0, 0 \ 440 } ; \ 441 GrB_Monoid GXB (GB_EVAL2 (op, _MONOID)) = \ 442 & GB_OPAQUE (GB_EVAL2 (op, _MONOID)) ; 443 444 // macro to construct GrB_* monoids in the updated specification 445 #define GB_MONOID_GRB(op,type) \ 446 GrB_Monoid GRB (GB_EVAL3 (op, _MONOID_, type)) = \ 447 & GB_OPAQUE (GB_EVAL4 (op, _, type, _MONOID)) ; 448 449 // MIN monoids: 450 GB_MONOID_DEFT ( MIN_INT8 , int8_t , INT8_MAX , INT8_MIN ) 451 GB_MONOID_DEFT ( MIN_INT16 , int16_t , INT16_MAX , INT16_MIN ) 452 GB_MONOID_DEFT ( MIN_INT32 , int32_t , INT32_MAX , INT32_MIN ) 453 GB_MONOID_DEFT ( MIN_INT64 , int64_t , INT64_MAX , INT64_MIN ) 454 GB_MONOID_DEFT ( MIN_UINT8 , uint8_t , UINT8_MAX , 0 ) 455 GB_MONOID_DEFT ( MIN_UINT16 , uint16_t , UINT16_MAX , 0 ) 456 GB_MONOID_DEFT ( MIN_UINT32 , uint32_t , UINT32_MAX , 0 ) 457 GB_MONOID_DEFT ( MIN_UINT64 , uint64_t , UINT64_MAX , 0 ) 458 GB_MONOID_DEFT ( MIN_FP32 , float , INFINITY , -INFINITY ) 459 GB_MONOID_DEFT ( MIN_FP64 , double , INFINITY , -INFINITY ) 460 461 GB_MONOID_GRB ( MIN, INT8 ) 462 GB_MONOID_GRB ( MIN, INT16 ) 463 GB_MONOID_GRB ( MIN, INT32 ) 464 GB_MONOID_GRB ( MIN, INT64 ) 465 GB_MONOID_GRB ( MIN, UINT8 ) 466 GB_MONOID_GRB ( MIN, UINT16 ) 467 GB_MONOID_GRB ( MIN, UINT32 ) 468 GB_MONOID_GRB ( MIN, UINT64 ) 469 GB_MONOID_GRB ( MIN, FP32 ) 470 GB_MONOID_GRB ( MIN, FP64 ) 471 472 // MAX monoids: 473 GB_MONOID_DEFT ( MAX_INT8 , int8_t , INT8_MIN , INT8_MAX ) 474 GB_MONOID_DEFT ( MAX_INT16 , int16_t , INT16_MIN , INT16_MAX ) 475 GB_MONOID_DEFT ( MAX_INT32 , int32_t , INT32_MIN , INT32_MAX ) 476 GB_MONOID_DEFT ( MAX_INT64 , int64_t , INT64_MIN , INT64_MAX ) 477 GB_MONOID_DEFT ( MAX_UINT8 , uint8_t , 0 , UINT8_MAX ) 478 GB_MONOID_DEFT ( MAX_UINT16 , uint16_t , 0 , UINT16_MAX) 479 GB_MONOID_DEFT ( MAX_UINT32 , uint32_t , 0 , UINT32_MAX) 480 GB_MONOID_DEFT ( MAX_UINT64 , uint64_t , 0 , UINT64_MAX) 481 GB_MONOID_DEFT ( MAX_FP32 , float , -INFINITY , INFINITY ) 482 GB_MONOID_DEFT ( MAX_FP64 , double , -INFINITY , INFINITY ) 483 484 GB_MONOID_GRB ( MAX, INT8 ) 485 GB_MONOID_GRB ( MAX, INT16 ) 486 GB_MONOID_GRB ( MAX, INT32 ) 487 GB_MONOID_GRB ( MAX, INT64 ) 488 GB_MONOID_GRB ( MAX, UINT8 ) 489 GB_MONOID_GRB ( MAX, UINT16 ) 490 GB_MONOID_GRB ( MAX, UINT32 ) 491 GB_MONOID_GRB ( MAX, UINT64 ) 492 GB_MONOID_GRB ( MAX, FP32 ) 493 GB_MONOID_GRB ( MAX, FP64 ) 494 495 // PLUS monoids: 496 GB_MONOID_DEF ( PLUS_INT8 , int8_t , 0 ) 497 GB_MONOID_DEF ( PLUS_INT16 , int16_t , 0 ) 498 GB_MONOID_DEF ( PLUS_INT32 , int32_t , 0 ) 499 GB_MONOID_DEF ( PLUS_INT64 , int64_t , 0 ) 500 GB_MONOID_DEF ( PLUS_UINT8 , uint8_t , 0 ) 501 GB_MONOID_DEF ( PLUS_UINT16 , uint16_t , 0 ) 502 GB_MONOID_DEF ( PLUS_UINT32 , uint32_t , 0 ) 503 GB_MONOID_DEF ( PLUS_UINT64 , uint64_t , 0 ) 504 GB_MONOID_DEF ( PLUS_FP32 , float , 0 ) 505 GB_MONOID_DEF ( PLUS_FP64 , double , 0 ) 506 GB_MONOID_DEF ( PLUS_FC32 , GxB_FC32_t, GB_FC32_ZERO) 507 GB_MONOID_DEF ( PLUS_FC64 , GxB_FC64_t, GB_FC64_ZERO) 508 509 GB_MONOID_GRB ( PLUS, INT8 ) 510 GB_MONOID_GRB ( PLUS, INT16 ) 511 GB_MONOID_GRB ( PLUS, INT32 ) 512 GB_MONOID_GRB ( PLUS, INT64 ) 513 GB_MONOID_GRB ( PLUS, UINT8 ) 514 GB_MONOID_GRB ( PLUS, UINT16 ) 515 GB_MONOID_GRB ( PLUS, UINT32 ) 516 GB_MONOID_GRB ( PLUS, UINT64 ) 517 GB_MONOID_GRB ( PLUS, FP32 ) 518 GB_MONOID_GRB ( PLUS, FP64 ) 519 520 // TIMES monoids: 521 GB_MONOID_DEFT ( TIMES_INT8 , int8_t , 1 , 0) 522 GB_MONOID_DEFT ( TIMES_INT16 , int16_t , 1 , 0) 523 GB_MONOID_DEFT ( TIMES_INT32 , int32_t , 1 , 0) 524 GB_MONOID_DEFT ( TIMES_INT64 , int64_t , 1 , 0) 525 GB_MONOID_DEFT ( TIMES_UINT8 , uint8_t , 1 , 0) 526 GB_MONOID_DEFT ( TIMES_UINT16 , uint16_t , 1 , 0) 527 GB_MONOID_DEFT ( TIMES_UINT32 , uint32_t , 1 , 0) 528 GB_MONOID_DEFT ( TIMES_UINT64 , uint64_t , 1 , 0) 529 GB_MONOID_DEF ( TIMES_FP32 , float , 1 ) 530 GB_MONOID_DEF ( TIMES_FP64 , double , 1 ) 531 GB_MONOID_DEF ( TIMES_FC32 , GxB_FC32_t, GB_FC32_ONE ) 532 GB_MONOID_DEF ( TIMES_FC64 , GxB_FC64_t, GB_FC64_ONE ) 533 534 GB_MONOID_GRB ( TIMES, INT8 ) 535 GB_MONOID_GRB ( TIMES, INT16 ) 536 GB_MONOID_GRB ( TIMES, INT32 ) 537 GB_MONOID_GRB ( TIMES, INT64 ) 538 GB_MONOID_GRB ( TIMES, UINT8 ) 539 GB_MONOID_GRB ( TIMES, UINT16 ) 540 GB_MONOID_GRB ( TIMES, UINT32 ) 541 GB_MONOID_GRB ( TIMES, UINT64 ) 542 GB_MONOID_GRB ( TIMES, FP32 ) 543 GB_MONOID_GRB ( TIMES, FP64 ) 544 545 // ANY monoids: 546 GB_MONOID_DEFT ( ANY_INT8 , int8_t , 0 , 0) 547 GB_MONOID_DEFT ( ANY_INT16 , int16_t , 0 , 0) 548 GB_MONOID_DEFT ( ANY_INT32 , int32_t , 0 , 0) 549 GB_MONOID_DEFT ( ANY_INT64 , int64_t , 0 , 0) 550 GB_MONOID_DEFT ( ANY_UINT8 , uint8_t , 0 , 0) 551 GB_MONOID_DEFT ( ANY_UINT16 , uint16_t , 0 , 0) 552 GB_MONOID_DEFT ( ANY_UINT32 , uint32_t , 0 , 0) 553 GB_MONOID_DEFT ( ANY_UINT64 , uint64_t , 0 , 0) 554 GB_MONOID_DEFT ( ANY_FP32 , float , 0 , 0) 555 GB_MONOID_DEFT ( ANY_FP64 , double , 0 , 0) 556 GB_MONOID_DEFT ( ANY_FC32 , GxB_FC32_t, GB_FC32_ZERO, GB_FC32_ZERO) 557 GB_MONOID_DEFT ( ANY_FC64 , GxB_FC64_t, GB_FC64_ZERO, GB_FC64_ZERO) 558 559 // Boolean monoids: 560 GB_MONOID_DEFT ( ANY_BOOL , bool , false , false) 561 GB_MONOID_DEFT ( LOR_BOOL , bool , false , true ) 562 GB_MONOID_DEFT ( LAND_BOOL , bool , true , false) 563 GB_MONOID_DEF ( LXOR_BOOL , bool , false ) 564 GB_MONOID_DEF ( EQ_BOOL , bool , true ) 565 // GrB_LXNOR_BOOL_MONIOD is the same as GrB_EQ_BOOL_MONIOD: 566 GrB_Monoid GxB_LXNOR_BOOL_MONOID = & GB_OPAQUE (EQ_BOOL_MONOID) ; 567 568 GB_MONOID_GRB ( LOR , BOOL ) 569 GB_MONOID_GRB ( LAND , BOOL ) 570 GB_MONOID_GRB ( LXOR , BOOL ) 571 GrB_Monoid GrB_LXNOR_MONOID_BOOL = & GB_OPAQUE (EQ_BOOL_MONOID) ; 572 573 // BOR monoids (bitwise or): 574 GB_MONOID_DEFT ( BOR_UINT8 , uint8_t , 0, 0xFF ) 575 GB_MONOID_DEFT ( BOR_UINT16 , uint16_t , 0, 0xFFFF ) 576 GB_MONOID_DEFT ( BOR_UINT32 , uint32_t , 0, 0xFFFFFFFF ) 577 GB_MONOID_DEFT ( BOR_UINT64 , uint64_t , 0, 0xFFFFFFFFFFFFFFFF ) 578 579 // BAND monoids (bitwise and): 580 GB_MONOID_DEFT ( BAND_UINT8 , uint8_t , 0xFF , 0 ) 581 GB_MONOID_DEFT ( BAND_UINT16 , uint16_t , 0xFFFF , 0 ) 582 GB_MONOID_DEFT ( BAND_UINT32 , uint32_t , 0xFFFFFFFF , 0 ) 583 GB_MONOID_DEFT ( BAND_UINT64 , uint64_t , 0xFFFFFFFFFFFFFFFF, 0 ) 584 585 // BXOR monoids (bitwise xor): 586 GB_MONOID_DEF ( BXOR_UINT8 , uint8_t , 0) 587 GB_MONOID_DEF ( BXOR_UINT16 , uint16_t , 0) 588 GB_MONOID_DEF ( BXOR_UINT32 , uint32_t , 0) 589 GB_MONOID_DEF ( BXOR_UINT64 , uint64_t , 0) 590 591 // BXNOR monoids (bitwise xnor): 592 GB_MONOID_DEF ( BXNOR_UINT8 , uint8_t , 0xFF ) 593 GB_MONOID_DEF ( BXNOR_UINT16 , uint16_t , 0xFFFF ) 594 GB_MONOID_DEF ( BXNOR_UINT32 , uint32_t , 0xFFFFFFFF ) 595 GB_MONOID_DEF ( BXNOR_UINT64 , uint64_t , 0xFFFFFFFFFFFFFFFF ) 596 597 //------------------------------------------------------------------------------ 598 // predefined built-in semirings 599 //------------------------------------------------------------------------------ 600 601 #define GB_SEMIRING_NAME(add,mult) \ 602 GB_EVAL5 (add, _, mult, _, GB_XTYPE) 603 604 // helper macro to define semirings: all x,y,z types the same 605 #define GXB_SEMIRING(add,mult) \ 606 struct GB_Semiring_opaque GB_OPAQUE (GB_SEMIRING_NAME(add, mult)) = \ 607 { \ 608 GB_MAGIC, 0, \ 609 & GB_OPAQUE (GB_EVAL4 (add, _, GB_XTYPE, _MONOID)), \ 610 & GB_OPAQUE (GB_EVAL3 (mult, _, GB_XTYPE)), \ 611 } ; \ 612 GrB_Semiring GXB (GB_SEMIRING_NAME (add, mult)) = \ 613 & GB_OPAQUE (GB_SEMIRING_NAME (add, mult)) ; 614 615 // helper macro to define semirings: x,y types the same, z boolean 616 #define GB_SEMIRING_COMPARE_DEFINE(add,mult) \ 617 struct GB_Semiring_opaque GB_OPAQUE (GB_SEMIRING_NAME(add, mult)) = \ 618 { \ 619 GB_MAGIC, 0, \ 620 & GB_OPAQUE (GB_EVAL2 (add, _BOOL_MONOID)), \ 621 & GB_OPAQUE (GB_EVAL3 (mult, _, GB_XTYPE)), \ 622 } ; 623 624 #define GXB_SEMIRING_COMPARE(add,mult) \ 625 GB_SEMIRING_COMPARE_DEFINE (add, mult) \ 626 GrB_Semiring GXB (GB_SEMIRING_NAME (add, mult)) = \ 627 & GB_OPAQUE (GB_SEMIRING_NAME (add, mult)) ; 628 629 #define GB_XTYPE BOOL 630 #define GB_BOOLEAN 631 #include "GB_semiring_template.c" 632 633 #define GB_XTYPE INT8 634 #include "GB_semiring_template.c" 635 636 #define GB_XTYPE UINT8 637 #define GB_UNSIGNED_INT 638 #include "GB_semiring_template.c" 639 640 #define GB_XTYPE INT16 641 #include "GB_semiring_template.c" 642 643 #define GB_XTYPE UINT16 644 #define GB_UNSIGNED_INT 645 #include "GB_semiring_template.c" 646 647 #define GB_XTYPE INT32 648 #define GB_POSITIONAL 649 #include "GB_semiring_template.c" 650 651 #define GB_UNSIGNED_INT 652 #define GB_XTYPE UINT32 653 #include "GB_semiring_template.c" 654 655 #define GB_POSITIONAL 656 #define GB_XTYPE INT64 657 #include "GB_semiring_template.c" 658 659 #define GB_UNSIGNED_INT 660 #define GB_XTYPE UINT64 661 #include "GB_semiring_template.c" 662 663 #define GB_XTYPE FP32 664 #include "GB_semiring_template.c" 665 666 #define GB_XTYPE FP64 667 #include "GB_semiring_template.c" 668 669 #define GB_COMPLEX 670 #define GB_XTYPE FC32 671 #include "GB_semiring_template.c" 672 673 #define GB_COMPLEX 674 #define GB_XTYPE FC64 675 #include "GB_semiring_template.c" 676 677 //------------------------------------------------------------------------------ 678 // 124 predefined built-in semirings in the v1.3 C API 679 //------------------------------------------------------------------------------ 680 681 // These predefined semirings have been added to the spec, as of v1.3. 682 // They are identical to the GxB* semirings of the same name, except for 683 // GrB_LXNOR_LOR_SEMIRING_BOOL, which is identical to GxB_EQ_LOR_BOOL. 684 685 #define GRB_SEMIRING(add,mult,xtype) \ 686 GrB_Semiring GRB (GB_EVAL5 (add, _, mult, _SEMIRING_, xtype)) = \ 687 & GB_OPAQUE (GB_EVAL5 (add, _, mult, _, xtype)) ; 688 689 //-------------------------------------------------------------------------- 690 // 4 boolean semirings 691 //-------------------------------------------------------------------------- 692 693 GRB_SEMIRING (LOR, LAND, BOOL) 694 GRB_SEMIRING (LAND, LOR, BOOL) 695 GRB_SEMIRING (LXOR, LAND, BOOL) 696 GrB_Semiring GRB (LXNOR_LOR_SEMIRING_BOOL) = & GB_OPAQUE (EQ_LOR_BOOL) ; 697 698 //-------------------------------------------------------------------------- 699 // 20 semirings with PLUS monoids 700 //-------------------------------------------------------------------------- 701 702 GRB_SEMIRING (PLUS, TIMES, INT8) 703 GRB_SEMIRING (PLUS, TIMES, INT16) 704 GRB_SEMIRING (PLUS, TIMES, INT32) 705 GRB_SEMIRING (PLUS, TIMES, INT64) 706 GRB_SEMIRING (PLUS, TIMES, UINT8) 707 GRB_SEMIRING (PLUS, TIMES, UINT16) 708 GRB_SEMIRING (PLUS, TIMES, UINT32) 709 GRB_SEMIRING (PLUS, TIMES, UINT64) 710 GRB_SEMIRING (PLUS, TIMES, FP32) 711 GRB_SEMIRING (PLUS, TIMES, FP64) 712 713 GRB_SEMIRING (PLUS, MIN, INT8) 714 GRB_SEMIRING (PLUS, MIN, INT16) 715 GRB_SEMIRING (PLUS, MIN, INT32) 716 GRB_SEMIRING (PLUS, MIN, INT64) 717 GRB_SEMIRING (PLUS, MIN, UINT8) 718 GRB_SEMIRING (PLUS, MIN, UINT16) 719 GRB_SEMIRING (PLUS, MIN, UINT32) 720 GRB_SEMIRING (PLUS, MIN, UINT64) 721 GRB_SEMIRING (PLUS, MIN, FP32) 722 GRB_SEMIRING (PLUS, MIN, FP64) 723 724 //-------------------------------------------------------------------------- 725 // 50 semirings with MIN monoids 726 //-------------------------------------------------------------------------- 727 728 GRB_SEMIRING (MIN, PLUS, INT8) 729 GRB_SEMIRING (MIN, PLUS, INT16) 730 GRB_SEMIRING (MIN, PLUS, INT32) 731 GRB_SEMIRING (MIN, PLUS, INT64) 732 GRB_SEMIRING (MIN, PLUS, UINT8) 733 GRB_SEMIRING (MIN, PLUS, UINT16) 734 GRB_SEMIRING (MIN, PLUS, UINT32) 735 GRB_SEMIRING (MIN, PLUS, UINT64) 736 GRB_SEMIRING (MIN, PLUS, FP32) 737 GRB_SEMIRING (MIN, PLUS, FP64) 738 739 GRB_SEMIRING (MIN, TIMES, INT8) 740 GRB_SEMIRING (MIN, TIMES, INT16) 741 GRB_SEMIRING (MIN, TIMES, INT32) 742 GRB_SEMIRING (MIN, TIMES, INT64) 743 GRB_SEMIRING (MIN, TIMES, UINT8) 744 GRB_SEMIRING (MIN, TIMES, UINT16) 745 GRB_SEMIRING (MIN, TIMES, UINT32) 746 GRB_SEMIRING (MIN, TIMES, UINT64) 747 GRB_SEMIRING (MIN, TIMES, FP32) 748 GRB_SEMIRING (MIN, TIMES, FP64) 749 750 GRB_SEMIRING (MIN, FIRST, INT8) 751 GRB_SEMIRING (MIN, FIRST, INT16) 752 GRB_SEMIRING (MIN, FIRST, INT32) 753 GRB_SEMIRING (MIN, FIRST, INT64) 754 GRB_SEMIRING (MIN, FIRST, UINT8) 755 GRB_SEMIRING (MIN, FIRST, UINT16) 756 GRB_SEMIRING (MIN, FIRST, UINT32) 757 GRB_SEMIRING (MIN, FIRST, UINT64) 758 GRB_SEMIRING (MIN, FIRST, FP32) 759 GRB_SEMIRING (MIN, FIRST, FP64) 760 761 GRB_SEMIRING (MIN, SECOND, INT8) 762 GRB_SEMIRING (MIN, SECOND, INT16) 763 GRB_SEMIRING (MIN, SECOND, INT32) 764 GRB_SEMIRING (MIN, SECOND, INT64) 765 GRB_SEMIRING (MIN, SECOND, UINT8) 766 GRB_SEMIRING (MIN, SECOND, UINT16) 767 GRB_SEMIRING (MIN, SECOND, UINT32) 768 GRB_SEMIRING (MIN, SECOND, UINT64) 769 GRB_SEMIRING (MIN, SECOND, FP32) 770 GRB_SEMIRING (MIN, SECOND, FP64) 771 772 GRB_SEMIRING (MIN, MAX, INT8) 773 GRB_SEMIRING (MIN, MAX, INT16) 774 GRB_SEMIRING (MIN, MAX, INT32) 775 GRB_SEMIRING (MIN, MAX, INT64) 776 GRB_SEMIRING (MIN, MAX, UINT8) 777 GRB_SEMIRING (MIN, MAX, UINT16) 778 GRB_SEMIRING (MIN, MAX, UINT32) 779 GRB_SEMIRING (MIN, MAX, UINT64) 780 GRB_SEMIRING (MIN, MAX, FP32) 781 GRB_SEMIRING (MIN, MAX, FP64) 782 783 //-------------------------------------------------------------------------- 784 // 50 semirings with MAX monoids 785 //-------------------------------------------------------------------------- 786 787 GRB_SEMIRING (MAX, PLUS, INT8) 788 GRB_SEMIRING (MAX, PLUS, INT16) 789 GRB_SEMIRING (MAX, PLUS, INT32) 790 GRB_SEMIRING (MAX, PLUS, INT64) 791 GRB_SEMIRING (MAX, PLUS, UINT8) 792 GRB_SEMIRING (MAX, PLUS, UINT16) 793 GRB_SEMIRING (MAX, PLUS, UINT32) 794 GRB_SEMIRING (MAX, PLUS, UINT64) 795 GRB_SEMIRING (MAX, PLUS, FP32) 796 GRB_SEMIRING (MAX, PLUS, FP64) 797 798 GRB_SEMIRING (MAX, TIMES, INT8) 799 GRB_SEMIRING (MAX, TIMES, INT16) 800 GRB_SEMIRING (MAX, TIMES, INT32) 801 GRB_SEMIRING (MAX, TIMES, INT64) 802 GRB_SEMIRING (MAX, TIMES, UINT8) 803 GRB_SEMIRING (MAX, TIMES, UINT16) 804 GRB_SEMIRING (MAX, TIMES, UINT32) 805 GRB_SEMIRING (MAX, TIMES, UINT64) 806 GRB_SEMIRING (MAX, TIMES, FP32) 807 GRB_SEMIRING (MAX, TIMES, FP64) 808 809 GRB_SEMIRING (MAX, FIRST, INT8) 810 GRB_SEMIRING (MAX, FIRST, INT16) 811 GRB_SEMIRING (MAX, FIRST, INT32) 812 GRB_SEMIRING (MAX, FIRST, INT64) 813 GRB_SEMIRING (MAX, FIRST, UINT8) 814 GRB_SEMIRING (MAX, FIRST, UINT16) 815 GRB_SEMIRING (MAX, FIRST, UINT32) 816 GRB_SEMIRING (MAX, FIRST, UINT64) 817 GRB_SEMIRING (MAX, FIRST, FP32) 818 GRB_SEMIRING (MAX, FIRST, FP64) 819 820 GRB_SEMIRING (MAX, SECOND, INT8) 821 GRB_SEMIRING (MAX, SECOND, INT16) 822 GRB_SEMIRING (MAX, SECOND, INT32) 823 GRB_SEMIRING (MAX, SECOND, INT64) 824 GRB_SEMIRING (MAX, SECOND, UINT8) 825 GRB_SEMIRING (MAX, SECOND, UINT16) 826 GRB_SEMIRING (MAX, SECOND, UINT32) 827 GRB_SEMIRING (MAX, SECOND, UINT64) 828 GRB_SEMIRING (MAX, SECOND, FP32) 829 GRB_SEMIRING (MAX, SECOND, FP64) 830 831 GRB_SEMIRING (MAX, MIN, INT8) 832 GRB_SEMIRING (MAX, MIN, INT16) 833 GRB_SEMIRING (MAX, MIN, INT32) 834 GRB_SEMIRING (MAX, MIN, INT64) 835 GRB_SEMIRING (MAX, MIN, UINT8) 836 GRB_SEMIRING (MAX, MIN, UINT16) 837 GRB_SEMIRING (MAX, MIN, UINT32) 838 GRB_SEMIRING (MAX, MIN, UINT64) 839 GRB_SEMIRING (MAX, MIN, FP32) 840 GRB_SEMIRING (MAX, MIN, FP64) 841 842